using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using ExtraSlots;
using ExtraSlots.Compatibility;
using ExtraSlots.HotBars;
using HarmonyLib;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using ServerSync;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.UI;
using YamlDotNet.Serialization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ExtraSlots")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ExtraSlots")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7e559c9a-ba1c-45b5-a260-ec3a1455248b")]
[assembly: AssemblyFileVersion("1.1.15")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.15.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace LocalizationManager
{
	[PublicAPI]
	public class Localizer
	{
		[CompilerGenerated]
		private sealed class <Load>d__12 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => PlatformManager.DistributionPlatform != null && PlatformInitializer.PreferencesInitialized));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (string.IsNullOrEmpty(PlatformPrefs.GetString("language", "")))
					{
						PlatformPrefs.SetString("language", "English");
					}
					LoadLocalization(Localization.instance, Localization.instance.GetSelectedLanguage());
					return false;
				}
			}

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

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

		private const string defaultLanguage = "English";

		private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;

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

		private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;

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

		private static BaseUnityPlugin? _plugin;

		private static readonly List<string> fileExtensions;

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

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

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

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

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

		private static void LoadLocalization(Localization __instance, string language)
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Expected O, but got Unknown
			if (!localizationLanguage.Remove(__instance))
			{
				localizationObjects.Add(new WeakReference<Localization>(__instance));
			}
			localizationLanguage.Add(__instance, language);
			Dictionary<string, string> localizationFiles = new Dictionary<string, string>();
			string[] prefixes = new string[2]
			{
				Plugin.Info.Metadata.Name + ".",
				Plugin.Info.Metadata.Name.Replace(" ", "") + "."
			};
			Scan(Paths.ConfigPath, warn: true);
			Scan(Paths.PluginPath, warn: false);
			byte[] array = LoadTranslationFromAssembly("English");
			if (array == null)
			{
				throw new Exception("Found no English localizations in mod " + Plugin.Info.Metadata.Name + ". Expected an embedded resource Translations/English.json or Translations/English.yml.");
			}
			Dictionary<string, string> dictionary = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array));
			if (dictionary == null)
			{
				throw new Exception("Localization for mod " + Plugin.Info.Metadata.Name + " failed: Localization file was empty.");
			}
			string text = null;
			if (language != "English")
			{
				if (localizationFiles.ContainsKey(language))
				{
					text = File.ReadAllText(localizationFiles[language]);
				}
				else
				{
					byte[] array2 = LoadTranslationFromAssembly(language);
					if (array2 != null)
					{
						text = Encoding.UTF8.GetString(array2);
					}
				}
			}
			if (text == null && localizationFiles.ContainsKey("English"))
			{
				text = File.ReadAllText(localizationFiles["English"]);
			}
			if (text != null)
			{
				Dictionary<string, string> dictionary2;
				try
				{
					dictionary2 = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text) ?? new Dictionary<string, string>();
				}
				catch (Exception arg)
				{
					global::ExtraSlots.ExtraSlots.LogWarning($"Failed to deserialize localization for language '{language}'. Using base localization only.\n{arg}");
					dictionary2 = new Dictionary<string, string>();
				}
				foreach (KeyValuePair<string, string> item in dictionary2)
				{
					dictionary[item.Key] = item.Value;
				}
			}
			loadedTexts[language] = dictionary;
			foreach (KeyValuePair<string, string> item2 in dictionary)
			{
				UpdatePlaceholderText(__instance, item2.Key);
			}
			void Scan(string root, bool warn)
			{
				foreach (string item3 in from f in Directory.GetFiles(root, "*.*", SearchOption.AllDirectories)
					where fileExtensions.Contains(Path.GetExtension(f))
					select f)
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item3);
					string[] array3 = prefixes;
					foreach (string text2 in array3)
					{
						if (fileNameWithoutExtension.StartsWith(text2))
						{
							string text3 = fileNameWithoutExtension.Substring(text2.Length);
							if (!string.IsNullOrWhiteSpace(text3))
							{
								if (localizationFiles.ContainsKey(text3))
								{
									if (warn)
									{
										global::ExtraSlots.ExtraSlots.LogWarning("Duplicate localization '" + text3 + "' for " + Plugin.Info.Metadata.Name + ". Skipping " + item3);
									}
								}
								else
								{
									localizationFiles[text3] = item3;
								}
							}
							break;
						}
					}
				}
			}
		}

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

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

		public static byte[]? ReadEmbeddedFileBytes(string resourceFileName, Assembly? containingAssembly = null)
		{
			string resourceFileName2 = resourceFileName;
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault((string str) => str.EndsWith(resourceFileName2, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
}
namespace ExtraSlots
{
	internal static class DebugLogging
	{
		[HarmonyPatch(typeof(Player), "CreateTombStone")]
		internal static class Player_CreateTombstone_LoggingItems
		{
			[HarmonyPriority(800)]
			private static void Prefix(Player __instance)
			{
				if (IsDebugEnabled && Slots.IsValidPlayer((Character)(object)__instance))
				{
					ExtraSlots.LogDebug("Player.CreateTombStone:Prefix Player Item List:");
					((Humanoid)__instance).GetInventory().LogInventory();
				}
			}

			[HarmonyPriority(0)]
			private static void Finalizer(Player __instance)
			{
				if (IsDebugEnabled && Slots.IsValidPlayer((Character)(object)__instance))
				{
					ExtraSlots.LogDebug("Player.CreateTombStone:Finalizer Player Item List:");
					((Humanoid)__instance).GetInventory().LogInventory();
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "MoveInventoryToGrave")]
		internal static class Inventory_MoveInventoryToGrave_LoggingItems
		{
			[HarmonyPriority(800)]
			private static void Prefix(Inventory __instance, Inventory original)
			{
				if (IsDebugEnabled)
				{
					ExtraSlots.LogDebug("Inventory.MoveInventoryToGrave:Prefix");
					ExtraSlots.LogDebug("From inventory " + GetInventoryState(original));
					original.LogInventory();
					ExtraSlots.LogDebug("To inventory " + GetInventoryState(__instance));
					__instance.LogInventory();
				}
			}

			[HarmonyPriority(0)]
			private static void Finalizer(Inventory __instance, Inventory original)
			{
				if (IsDebugEnabled)
				{
					ExtraSlots.LogDebug("Inventory.MoveInventoryToGrave:Finalizer");
					ExtraSlots.LogDebug("From inventory " + GetInventoryState(original));
					original.LogInventory();
					ExtraSlots.LogDebug("To inventory " + GetInventoryState(__instance));
					__instance.LogInventory();
				}
			}
		}

		internal static bool IsDebugEnabled => ExtraSlots.loggingEnabled.Value && ExtraSlots.loggingDebugEnabled.Value;

		internal static void LogItem(ItemData item)
		{
			//IL_0012: 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)
			string text = $"{item.m_shared.m_name} {item.m_gridPos} ";
			Slots.Slot itemSlot = Slots.GetItemSlot(item);
			ExtraSlots.LogDebug(text + ((itemSlot != null) ? $"slot: {itemSlot} {itemSlot.GridPosition}" : ""));
		}

		internal static string GetInventoryState(Inventory inventory)
		{
			object[] obj = new object[6] { inventory.m_name, null, null, null, null, null };
			Player localPlayer = Player.m_localPlayer;
			obj[1] = ((localPlayer != null) ? ((Humanoid)localPlayer).GetInventory() : null) == inventory;
			obj[2] = inventory.m_width;
			obj[3] = inventory.m_height;
			obj[4] = inventory.m_totalWeight;
			obj[5] = inventory.m_inventory.Count;
			return string.Format("name:{0} isPlayer:{1} size:{2}x{3} weight:{4} items:{5}", obj);
		}

		internal static void LogInventory(this Inventory inventory)
		{
			CollectionExtensions.Do<ItemData>((IEnumerable<ItemData>)inventory.GetAllItemsInGridOrder(), (Action<ItemData>)LogItem);
		}
	}
	public static class ItemNameTokens
	{
		[HarmonyPatch(typeof(Player), "Load")]
		private static class Player_Load_UpdateRegisters
		{
			private static void Prefix()
			{
				UpdateRegisters();
			}
		}

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

		public static void UpdateRegisters()
		{
			if (!Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				return;
			}
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				ItemDrop component = item.GetComponent<ItemDrop>();
				if (component == null)
				{
					continue;
				}
				ItemData itemData = component.m_itemData;
				if (itemData != null)
				{
					SharedData shared = itemData.m_shared;
					if (shared != null && shared.m_name.StartsWith("$"))
					{
						itemNames[((Object)item).name] = shared.m_name;
						itemNames[shared.m_name] = shared.m_name;
					}
				}
			}
			Slots.UpdateCustomItemLists();
			ExtraUtilitySlots.UpdateUniqueEquipped();
			TombStoneInteraction.UpdateItemLists();
		}

		public static string GetItemName(this string input)
		{
			return CollectionExtensions.GetValueOrDefault<string, string>((IReadOnlyDictionary<string, string>)itemNames, input.Trim(), input);
		}
	}
	public static class LightenedSlots
	{
		private static readonly List<int> m_affectedRows = new List<int>();

		public static bool IsEnabled => ExtraSlots.lightenedSlotsStartIndex.Value != 0;

		public static float WeightFactor => ExtraSlots.lightenedSlotsWeightFactor.Value;

		public static bool IsRowAffected(int row)
		{
			return IsEnabled && m_affectedRows.Contains(row);
		}

		public static void UpdateState()
		{
			UpdateAffectedRows();
			InventoryInteraction.UpdateTotalWeight();
		}

		public static void UpdateAffectedRows()
		{
			m_affectedRows.Clear();
			if (!IsEnabled || !SlotsProgression.IsPlayerKeyItemConditionMet(ExtraSlots.lightenedSlotsPlayerKey.Value, ExtraSlots.lightenedSlotsItemDiscovered.Value))
			{
				return;
			}
			for (int i = 0; i < Slots.InventoryHeightPlayer; i++)
			{
				if (!ExtraSlots.lightenedSlotsOnlyExtraRows.Value || i >= 4)
				{
					if (ExtraSlots.lightenedSlotsStartIndex.Value < 0 && i >= ExtraSlots.lightenedSlotsStartIndex.Value + Slots.InventoryHeightPlayer)
					{
						m_affectedRows.Add(i);
					}
					else if (ExtraSlots.lightenedSlotsStartIndex.Value > 0 && i >= ExtraSlots.lightenedSlotsStartIndex.Value - 1)
					{
						m_affectedRows.Add(i);
					}
				}
			}
		}
	}
	internal class CustomConfigs
	{
		internal class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public Action<ConfigEntryBase>? CustomDrawer;
		}

		internal static object? configManager;

		internal static Type? configManagerStyles;

		internal static GUIStyle GetStyle(GUIStyle other)
		{
			//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_0051: Expected O, but got Unknown
			if (configManagerStyles == null)
			{
				return other;
			}
			FieldInfo fieldInfo = AccessTools.Field(configManagerStyles, "fontSize");
			if (fieldInfo == null)
			{
				return other;
			}
			return new GUIStyle(other)
			{
				fontSize = (int)fieldInfo.GetValue(configManagerStyles)
			};
		}

		internal static void Awake()
		{
			Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "ConfigurationManager");
			Type type = assembly?.GetType("ConfigurationManager.ConfigurationManager");
			configManager = ((type == null) ? null : Chainloader.ManagerObject.GetComponent(type));
			configManagerStyles = assembly?.GetType("ConfigurationManager.ConfigurationManagerStyles");
		}

		internal static Action<ConfigEntryBase> DrawSeparatedStrings(string splitString)
		{
			string splitString2 = splitString;
			return delegate(ConfigEntryBase cfg)
			{
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Expected O, but got Unknown
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0170: Expected O, but got Unknown
				bool valueOrDefault = cfg.Description.Tags.Select((object a) => (a.GetType().Name == "ConfigurationManagerAttributes") ? ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a)) : null).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
				bool flag = false;
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				List<string> list = new List<string>();
				List<string> list2 = ((string)cfg.BoxedValue).Split(new string[1] { splitString2 }, StringSplitOptions.None).ToList();
				for (int i = 0; i < list2.Count; i++)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					string text = list2[i];
					string text2 = GUILayout.TextField(text, GetStyle(GUI.skin.textArea), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
					if (text2 != text && !valueOrDefault)
					{
						flag = true;
					}
					if (GUILayout.Button("x", new GUIStyle(GetStyle(GUI.skin.button))
					{
						fixedWidth = 21f
					}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
					{
						flag = true;
					}
					else
					{
						list.Add(text2);
					}
					if (GUILayout.Button("+", new GUIStyle(GetStyle(GUI.skin.button))
					{
						fixedWidth = 21f
					}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
					{
						flag = true;
						list.Add("");
					}
					GUILayout.EndHorizontal();
				}
				GUILayout.EndVertical();
				if (flag)
				{
					cfg.BoxedValue = string.Join(splitString2, list);
				}
			};
		}

		internal static Action<ConfigEntryBase> DrawOrderedFixedStrings(string splitString)
		{
			string splitString2 = splitString;
			return delegate(ConfigEntryBase cfg)
			{
				//IL_00e4: 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_00ff: Expected O, but got Unknown
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0176: Expected O, but got Unknown
				bool valueOrDefault = cfg.Description.Tags.Select((object a) => (a.GetType().Name == "ConfigurationManagerAttributes") ? ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a)) : null).FirstOrDefault((bool? v) => v.HasValue).GetValueOrDefault();
				bool flag = false;
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				string[] array = ((string)cfg.BoxedValue).Split(new string[1] { splitString2 }, StringSplitOptions.None).ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					string text = array[i];
					GUILayout.Label(text, GetStyle(GUI.skin.textArea), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
					if (GUILayout.Button("ʌ", new GUIStyle(GetStyle(GUI.skin.button))
					{
						fixedWidth = 21f
					}, Array.Empty<GUILayoutOption>()) && !valueOrDefault && (flag = i > 0))
					{
						ref string reference = ref array[i];
						ref string reference2 = ref array[i - 1];
						string text2 = array[i - 1];
						string text3 = array[i];
						reference = text2;
						reference2 = text3;
					}
					if (GUILayout.Button("v", new GUIStyle(GetStyle(GUI.skin.button))
					{
						fixedWidth = 21f
					}, Array.Empty<GUILayoutOption>()) && !valueOrDefault && (flag = i < array.Length - 1))
					{
						ref string reference = ref array[i];
						ref string reference3 = ref array[i + 1];
						string text3 = array[i + 1];
						string text2 = array[i];
						reference = text3;
						reference3 = text2;
					}
					GUILayout.EndHorizontal();
				}
				GUILayout.EndVertical();
				if (flag)
				{
					cfg.BoxedValue = string.Join(splitString2, array);
				}
			};
		}
	}
	public static class EquipmentPanel
	{
		public class SidePanelDefaults
		{
			public bool active;

			public Vector2 anchoredPosition = Vector2.zero;

			public Vector2 anchorMin = Vector2.zero;

			public Vector2 anchorMax = Vector2.zero;
		}

		private static class SlotPositions
		{
			private static int Column(int i)
			{
				return i / 3;
			}

			private static int Row(int i)
			{
				return i % 3;
			}

			private static int LastEquipmentRow()
			{
				return Row(equipmentSlotsCount - 1);
			}

			internal static int LastEquipmentColumn()
			{
				return Column(equipmentSlotsCount - 1);
			}

			internal static Vector2 GetEquipmentTileOffset(int i)
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				int x = Column(i) * 4 + ((ExtraSlots.equipmentSlotsAlignment.Value == ExtraSlots.SlotsAlignment.VerticalTopHorizontalMiddle && Row(i) > LastEquipmentRow()) ? 1 : 0) * 2 + Math.Max(quickSlotsCount - 1 - LastEquipmentColumn(), 0) * 2;
				int y = Row(i) * 4 + Math.Max((ExtraSlots.equipmentSlotsAlignment.Value == ExtraSlots.SlotsAlignment.VerticalMiddleHorizontalLeft && Column(i) == LastEquipmentColumn()) ? (2 - LastEquipmentRow()) : 0, 0) * 2;
				return GetSlotPosition(x, y);
			}

			internal static Vector2 GetQuickSlotTileOffset(int i)
			{
				//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_003c: Unknown result type (might be due to invalid IL or missing references)
				int x = i * 4 + Math.Max(ExtraSlots.quickSlotsAlignmentCenter.Value ? (LastEquipmentColumn() + 1 - quickSlotsCount) : 0, 0);
				int y = EquipmentHeight * 4 + 1;
				return GetSlotPosition(x, y);
			}

			internal static Vector2 GetFoodSlotTileOffset(int i)
			{
				//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_0025: Unknown result type (might be due to invalid IL or missing references)
				int x = Math.Max(LastEquipmentColumn() + 1, quickSlotsCount) * 4 + 1;
				int y = i * 4;
				return GetSlotPosition(x, y);
			}

			internal static Vector2 GetAmmoSlotTileOffset(int i)
			{
				//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_0031: Unknown result type (might be due to invalid IL or missing references)
				int x = Math.Max(LastEquipmentColumn() + 1, quickSlotsCount) * 4 + 1 + (Slots.IsFoodSlotAvailable() ? 4 : 0);
				int y = i * 4;
				return GetSlotPosition(x, y);
			}

			internal static Vector2 GetMiscSlotTileOffset(int i)
			{
				//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)
				int x = Math.Max(LastEquipmentColumn() + 1, quickSlotsCount) * 4 + i * 4 + 1;
				int y = EquipmentHeight * 4 + 1;
				return GetSlotPosition(x, y);
			}

			private static Vector2 GetSlotPosition(int x, int y)
			{
				//IL_0000: 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)
				return PanelPosition + new Vector2((float)x * 70f / 4f, (float)(-y) * 70f / 4f);
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		private static class InventoryGui_Show_UpdatePanel
		{
			private static void Postfix()
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null))
				{
					UpdatePanel();
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnDestroy")]
		private static class InventoryGui_OnDestroy_ClearObjects
		{
			private static void Postfix()
			{
				ClearPanel();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Update")]
		private static class InventoryGui_Update_UpdateEquipmentPanel
		{
			private static void Postfix()
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && InventoryGui.IsVisible())
				{
					UpdateEquipmentBackground();
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
		internal static class InventoryGrid_UpdateGui_UpdateSlotsOnDirty
		{
			private static void Prefix(InventoryGrid __instance, ref int __state)
			{
				if (!((Object)(object)__instance != (Object)(object)InventoryGui.instance.m_playerGrid))
				{
					__state = __instance.m_elements.Count;
				}
			}

			private static void Postfix(InventoryGrid __instance, int __state)
			{
				if (!((Object)(object)__instance != (Object)(object)InventoryGui.instance.m_playerGrid))
				{
					if (__state != __instance.m_elements.Count)
					{
						MarkDirty();
					}
					UpdateInventorySlots();
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "SetupDragItem")]
		private static class InventoryGui_SetupDragItem_UpdateSlotsOnItemDrag
		{
			private static void Prefix(InventoryGui __instance, ref bool __state)
			{
				__state = Object.op_Implicit((Object)(object)__instance.m_dragGo);
			}

			private static void Postfix(InventoryGui __instance, bool __state)
			{
				MarkDirty();
				if (!Object.op_Implicit((Object)(object)__instance.m_dragGo) && __state)
				{
					UpdateSidePanels();
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "UpdateGamepad")]
		public static class InventoryGrid_UpdateGamepad_GamepadSupport
		{
			public static Vector2i FindEquipmentSlot(int row = -1, Slots.Slot slotRow = null, int col = -1, Slots.Slot slotCol = null, bool right = false, Slots.Slot before = null, Slots.Slot after = null)
			{
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				Slots.Slot[] equipmentSlots = Slots.GetEquipmentSlots();
				if (row == -1 && slotRow != null)
				{
					row = Array.IndexOf(equipmentSlots, slotRow) % 3;
				}
				if (col == -1 && slotCol != null)
				{
					col = Array.IndexOf(equipmentSlots, slotCol) / 3;
				}
				int num = ((before == null) ? (-1) : Array.IndexOf(equipmentSlots, before));
				int num2 = ((after == null) ? (-1) : Array.IndexOf(equipmentSlots, after));
				int num3 = (right ? equipmentSlots.Length : (-1));
				while (true)
				{
					num3 = ((!right) ? (num3 + 1) : (num3 - 1));
					if (num3 < 0 || num3 == equipmentSlots.Length)
					{
						break;
					}
					if ((num <= -1 || num3 < num) && (num2 <= -1 || num3 > num2))
					{
						if (row == -1 && col == -1)
						{
							return equipmentSlots[num3].GridPosition;
						}
						if ((row != -1 && row == num3 % 3) || (col != -1 && col == num3 / 3))
						{
							return equipmentSlots[num3].GridPosition;
						}
					}
				}
				return Slots.emptyPosition;
			}

			private static bool Prefix(InventoryGrid __instance)
			{
				//IL_0034: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_0367: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: Unknown result type (might be due to invalid IL or missing references)
				//IL_014c: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_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_04f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0797: Unknown result type (might be due to invalid IL or missing references)
				//IL_049c: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_032b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0330: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0214: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_055d: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_065e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0663: Unknown result type (might be due to invalid IL or missing references)
				//IL_0514: Unknown result type (might be due to invalid IL or missing references)
				//IL_0519: Unknown result type (might be due to invalid IL or missing references)
				//IL_0405: Unknown result type (might be due to invalid IL or missing references)
				//IL_040a: Unknown result type (might be due to invalid IL or missing references)
				//IL_09de: Unknown result type (might be due to invalid IL or missing references)
				//IL_07ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_07f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0831: Unknown result type (might be due to invalid IL or missing references)
				//IL_0836: Unknown result type (might be due to invalid IL or missing references)
				//IL_075b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0760: Unknown result type (might be due to invalid IL or missing references)
				//IL_0580: Unknown result type (might be due to invalid IL or missing references)
				//IL_0585: Unknown result type (might be due to invalid IL or missing references)
				//IL_0471: Unknown result type (might be due to invalid IL or missing references)
				//IL_0476: Unknown result type (might be due to invalid IL or missing references)
				//IL_0458: Unknown result type (might be due to invalid IL or missing references)
				//IL_045d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0296: Unknown result type (might be due to invalid IL or missing references)
				//IL_029b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0281: Unknown result type (might be due to invalid IL or missing references)
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_0982: Unknown result type (might be due to invalid IL or missing references)
				//IL_0987: Unknown result type (might be due to invalid IL or missing references)
				//IL_0919: Unknown result type (might be due to invalid IL or missing references)
				//IL_091e: Unknown result type (might be due to invalid IL or missing references)
				//IL_06d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_06d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0644: Unknown result type (might be due to invalid IL or missing references)
				//IL_0649: Unknown result type (might be due to invalid IL or missing references)
				//IL_02de: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0bd1: Unknown result type (might be due to invalid IL or missing references)
				//IL_09a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_09a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_093f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0944: Unknown result type (might be due to invalid IL or missing references)
				//IL_08b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_08ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_08b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_05f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_095f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0964: Unknown result type (might be due to invalid IL or missing references)
				//IL_0888: Unknown result type (might be due to invalid IL or missing references)
				//IL_088d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0732: Unknown result type (might be due to invalid IL or missing references)
				//IL_0737: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a3d: Unknown result type (might be due to invalid IL or missing references)
				//IL_08de: Unknown result type (might be due to invalid IL or missing references)
				//IL_08e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b51: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b1e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b23: Unknown result type (might be due to invalid IL or missing references)
				//IL_0aeb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0af0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b45: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b4a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0aa2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0aa7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b95: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance != (Object)(object)InventoryGui.instance.m_playerGrid || !__instance.m_uiGroup.IsActive || Console.IsVisible())
				{
					return true;
				}
				Slots.Slot slotInGrid = Slots.GetSlotInGrid(__instance.m_selected);
				if (ZInput.GetButtonDown("JoyDPadLeft") || ZInput.GetButtonDown("JoyLStickLeft"))
				{
					ExtraSlots.LogDebug($"From {__instance.m_selected} {slotInGrid} left");
					if (slotInGrid != null)
					{
						if (slotInGrid.IsAmmoSlot)
						{
							__instance.m_selected.x += 3;
							Slots.Slot slotInGrid2 = Slots.GetSlotInGrid(__instance.m_selected);
							if (slotInGrid2 == null || !slotInGrid2.IsActive)
							{
								int num = __instance.m_selected.x % 3;
								__instance.m_selected = FindEquipmentSlot(num, null, -1, null, right: true);
								if (__instance.m_selected == Slots.emptyPosition)
								{
									__instance.m_selected = new Vector2i(Slots.InventoryWidth - 1, num);
								}
							}
						}
						else if (slotInGrid.IsFoodSlot)
						{
							int num2 = __instance.m_selected.x % 3;
							__instance.m_selected = FindEquipmentSlot(num2, null, -1, null, right: true);
							if (__instance.m_selected == Slots.emptyPosition)
							{
								__instance.m_selected = new Vector2i(Slots.InventoryWidth - 1, num2);
							}
						}
						else if (slotInGrid.IsQuickSlot)
						{
							__instance.m_selected.x--;
							if (__instance.m_selected.x < 0)
							{
								__instance.m_selected = new Vector2i(Slots.InventoryWidth - 1, 3);
							}
						}
						else if (slotInGrid.IsMiscSlot)
						{
							__instance.m_selected.x--;
							Slots.Slot slotInGrid3 = Slots.GetSlotInGrid(__instance.m_selected);
							if (slotInGrid3 == null)
							{
								__instance.m_selected = new Vector2i(Slots.InventoryWidth - 1, 3);
							}
							else if (!slotInGrid3.IsActive)
							{
								if (slotInGrid3.IsQuickSlot)
								{
									IEnumerable<Slots.Slot> source = from slot in Slots.GetQuickSlots()
										where slot.IsActive
										select slot;
									if (source.Any())
									{
										__instance.m_selected = source.Last().GridPosition;
									}
									else
									{
										__instance.m_selected = new Vector2i(Slots.InventoryWidth - 1, 3);
									}
								}
								else if (slotInGrid3.IsMiscSlot && quickSlotsCount == 0)
								{
									__instance.m_selected = new Vector2i(Slots.InventoryWidth - 1, 3);
								}
								else
								{
									__instance.m_selected = new Vector2i(Slots.InventoryWidth - 1, 3);
								}
							}
						}
						else
						{
							__instance.m_selected = FindEquipmentSlot(-1, slotInGrid, -1, null, right: true, slotInGrid);
							if (__instance.m_selected.x < 0)
							{
								__instance.m_selected = new Vector2i(Slots.InventoryWidth - 1, Array.IndexOf(Slots.GetEquipmentSlots(), slotInGrid) % 3);
							}
						}
						return false;
					}
				}
				if (ZInput.GetButtonDown("JoyDPadRight") || ZInput.GetButtonDown("JoyLStickRight"))
				{
					ExtraSlots.LogDebug($"From {__instance.m_selected} {slotInGrid} right");
					if (slotInGrid != null)
					{
						if (slotInGrid.IsFoodSlot)
						{
							Slots.Slot slotInGrid4 = Slots.GetSlotInGrid(new Vector2i(__instance.m_selected.x - 3, __instance.m_selected.y));
							if (slotInGrid4 != null && slotInGrid4.IsActive)
							{
								__instance.m_selected = slotInGrid4.GridPosition;
							}
						}
						else
						{
							if (slotInGrid.IsAmmoSlot)
							{
								return false;
							}
							if (slotInGrid.IsMiscSlot)
							{
								Slots.Slot slotInGrid5 = Slots.GetSlotInGrid(new Vector2i(__instance.m_selected.x + 1, __instance.m_selected.y));
								if (slotInGrid5 != null && slotInGrid5.IsActive)
								{
									__instance.m_selected = slotInGrid5.GridPosition;
								}
							}
							else if (slotInGrid.IsQuickSlot)
							{
								if (__instance.m_selected.x < quickSlotsCount - 1)
								{
									Slots.Slot slotInGrid6 = Slots.GetSlotInGrid(new Vector2i(__instance.m_selected.x + 1, __instance.m_selected.y));
									if (slotInGrid6 != null && slotInGrid6.IsActive)
									{
										__instance.m_selected = slotInGrid6.GridPosition;
									}
								}
								else
								{
									IEnumerable<Slots.Slot> source2 = from slot in Slots.GetMiscSlots()
										where slot.IsActive
										select slot;
									if (source2.Any())
									{
										__instance.m_selected = source2.First().GridPosition;
									}
								}
							}
							else
							{
								__instance.m_selected = FindEquipmentSlot(-1, slotInGrid, -1, null, right: false, null, slotInGrid);
								if (__instance.m_selected.x < 0)
								{
									Slots.Slot[] array = (from slot in Slots.GetFoodSlots()
										where slot.IsActive
										select slot).ToArray();
									if (array.Length == 3)
									{
										__instance.m_selected = array[Array.IndexOf(Slots.GetEquipmentSlots(), slotInGrid) % 3].GridPosition;
										return false;
									}
									Slots.Slot[] array2 = (from slot in Slots.GetAmmoSlots()
										where slot.IsActive
										select slot).ToArray();
									if (array2.Length == 3)
									{
										__instance.m_selected = array2[Array.IndexOf(Slots.GetEquipmentSlots(), slotInGrid) % 3].GridPosition;
										return false;
									}
								}
								if (__instance.m_selected.x < 0)
								{
									__instance.m_selected = slotInGrid.GridPosition;
								}
							}
						}
						return false;
					}
					if (__instance.m_selected.x >= Slots.InventoryWidth - 1)
					{
						if (__instance.m_selected.y > 2)
						{
							IEnumerable<Slots.Slot> source3 = from slot in Slots.GetQuickSlots()
								where slot.IsActive
								select slot;
							if (source3.Any())
							{
								__instance.m_selected = source3.First().GridPosition;
								return false;
							}
							IEnumerable<Slots.Slot> source4 = from slot in Slots.GetMiscSlots()
								where slot.IsActive
								select slot;
							if (source4.Any())
							{
								__instance.m_selected = source4.First().GridPosition;
								return false;
							}
							__instance.m_selected = new Vector2i(0, Slots.InventoryHeightPlayer);
						}
						else
						{
							Vector2i val = FindEquipmentSlot(Math.Min(__instance.m_selected.y, equipmentSlotsCount - 1));
							if (val != Slots.emptyPosition)
							{
								__instance.m_selected = val;
							}
						}
						return false;
					}
				}
				if (ZInput.GetButtonDown("JoyDPadUp") || ZInput.GetButtonDown("JoyLStickUp"))
				{
					ExtraSlots.LogDebug($"From {__instance.m_selected} {slotInGrid} up");
					if (slotInGrid != null)
					{
						if (slotInGrid.IsFoodSlot)
						{
							__instance.m_selected.x--;
							if (__instance.m_selected.x < 3)
							{
								__instance.m_selected = slotInGrid.GridPosition;
							}
						}
						else if (slotInGrid.IsAmmoSlot)
						{
							__instance.m_selected.x--;
							if (__instance.m_selected.x < 0)
							{
								__instance.m_selected = slotInGrid.GridPosition;
							}
						}
						else if (slotInGrid.IsMiscSlot)
						{
							if (slotInGrid.Index == 6)
							{
								Slots.Slot slot2 = Slots.GetFoodSlots().Last();
								__instance.m_selected = ((slot2 != null && slot2.IsActive) ? slot2 : Slots.GetAmmoSlots().Last()).GridPosition;
							}
							else if (slotInGrid.Index == 7)
							{
								__instance.m_selected = Slots.GetAmmoSlots().Last().GridPosition;
							}
							Slots.Slot slotInGrid7 = Slots.GetSlotInGrid(__instance.m_selected);
							if (slotInGrid7 == null || !slotInGrid7.IsActive)
							{
								__instance.m_selected = slotInGrid.GridPosition;
							}
						}
						else if (slotInGrid.IsQuickSlot)
						{
							__instance.m_selected = FindEquipmentSlot(-1, null, Math.Min(__instance.m_selected.x, equipmentSlotsCount / 3), null, right: true);
							if (__instance.m_selected.x < 0)
							{
								__instance.m_selected = FindEquipmentSlot(-1, null, -1, null, right: true);
							}
							if (__instance.m_selected.x < 0)
							{
								__instance.m_selected = slotInGrid.GridPosition;
							}
						}
						else
						{
							__instance.m_selected = FindEquipmentSlot(-1, null, Array.IndexOf(Slots.GetEquipmentSlots(), slotInGrid) / 3, null, right: true, slotInGrid);
							if (__instance.m_selected.x < 0)
							{
								__instance.m_selected = slotInGrid.GridPosition;
							}
						}
						return false;
					}
				}
				if (ZInput.GetButtonDown("JoyDPadDown") || ZInput.GetButtonDown("JoyLStickDown"))
				{
					ExtraSlots.LogDebug($"From {__instance.m_selected} {slotInGrid} down");
					if (slotInGrid != null)
					{
						if (slotInGrid.IsQuickSlot || slotInGrid.IsMiscSlot)
						{
							if (!__instance.jumpToNextContainer)
							{
								return false;
							}
							__instance.OnMoveToLowerInventoryGrid?.Invoke(__instance.m_selected);
							return false;
						}
						if (slotInGrid.IsAmmoSlot)
						{
							__instance.m_selected.x++;
							if (__instance.m_selected.x > 2)
							{
								Slots.Slot slot3 = Slots.GetMiscSlots()[1];
								__instance.m_selected = ((slot3 != null && slot3.IsActive) ? slot3 : Slots.GetMiscSlots()[0]).GridPosition;
							}
						}
						else if (slotInGrid.IsFoodSlot)
						{
							__instance.m_selected.x++;
							if (__instance.m_selected.x > 5)
							{
								__instance.m_selected = Slots.GetMiscSlots()[0].GridPosition;
							}
						}
						else if (slotInGrid.IsEquipmentSlot)
						{
							int num3 = Array.IndexOf(Slots.GetEquipmentSlots(), slotInGrid) / 3;
							__instance.m_selected = FindEquipmentSlot(-1, null, num3, null, right: false, null, slotInGrid);
							if (__instance.m_selected.x < 0)
							{
								__instance.m_selected = Slots.GetQuickSlots()[num3].GridPosition;
							}
						}
						Slots.Slot slotInGrid8 = Slots.GetSlotInGrid(__instance.m_selected);
						if (slotInGrid8 == null || !slotInGrid8.IsActive)
						{
							if (!__instance.jumpToNextContainer)
							{
								return false;
							}
							__instance.OnMoveToLowerInventoryGrid?.Invoke(__instance.m_selected);
						}
						return false;
					}
					if (__instance.m_selected.y >= Slots.InventoryHeightPlayer - 1)
					{
						__instance.OnMoveToLowerInventoryGrid?.Invoke(__instance.m_selected);
						return false;
					}
				}
				return true;
			}

			private static void Postfix(InventoryGrid __instance, bool __runOriginal)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				if (!__runOriginal)
				{
					ExtraSlots.LogDebug($"Selected {__instance.m_selected}");
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "SetSelection")]
		public static class InventoryGrid_SetSelection_GamepadSupport
		{
			private static void Postfix(Vector2i pos)
			{
				//IL_0003: 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)
				pos.y = Math.Min(pos.y, Slots.InventoryHeightPlayer - 1);
				ExtraSlots.LogDebug($"SetSelection {pos}");
			}
		}

		[HarmonyPatch(typeof(RectTransformUtility), "RectangleContainsScreenPoint", new Type[]
		{
			typeof(RectTransform),
			typeof(Vector2)
		})]
		public static class RectTransformUtility_RectangleContainsScreenPoint_BackpacksCompat
		{
			private static void Postfix(RectTransform rect, Vector2 screenPoint, ref bool __result)
			{
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)InventoryGui.instance) || (Object)(object)rect != (Object)(object)InventoryGui.instance.m_playerGrid.m_gridRoot)
				{
					return;
				}
				for (int i = 0; i < Math.Min(Slots.slots.Length, InventoryGui.instance.m_playerGrid.m_elements.Count - Slots.InventorySizePlayer); i++)
				{
					Transform transform = InventoryGui.instance.m_playerGrid.m_elements[Slots.InventorySizePlayer + i].m_go.transform;
					if (RectTransformUtility.RectangleContainsScreenPoint((RectTransform)(object)((transform is RectTransform) ? transform : null), screenPoint))
					{
						__result = true;
						break;
					}
				}
			}
		}

		private const string BackgroundName = "ExtraSlotsEquipmentPanel";

		private const float tileSpace = 6f;

		private const float tileSize = 70f;

		private const float interslotSpaceInTiles = 0.25f;

		private const float inventoryPanelOffset = 100f;

		private static int equipmentSlotsCount = 0;

		internal static int quickSlotsCount = 0;

		public static RectTransform inventoryDarken = null;

		public static RectTransform inventoryBackground = null;

		public static Image inventoryBackgroundImage = null;

		public static RectTransform equipmentBackground = null;

		public static Image equipmentBackgroundImage = null;

		public static RectTransform selectedFrame = null;

		public static RectTransform inventorySelectedFrame = null;

		private static bool isDirty = true;

		private static int updateSidePanelsInFrames;

		private static int updateSidePanelsPreviousExtraRows = -10;

		private static Color normalColor = Color.clear;

		private static Color highlightedColor = Color.clear;

		private static Color normalColorUnfit = Color.clear;

		private static Color highlightedColorUnfit = Color.clear;

		private static Material iconMaterial;

		private static Vector3 originalScale = Vector3.zero;

		private static Vector2 originalTooltipPosition = Vector2.zero;

		internal static Sprite ammoSlot;

		internal static Sprite miscSlot;

		internal static Sprite quickSlot;

		internal static Sprite lightenedSlot;

		internal static Sprite background;

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

		private static float InventoryPanelWidth
		{
			get
			{
				//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)
				float result;
				if (!Object.op_Implicit((Object)(object)InventoryGui.instance))
				{
					result = 0f;
				}
				else
				{
					Rect rect = InventoryGui.instance.m_player.rect;
					result = ((Rect)(ref rect)).width;
				}
				return result;
			}
		}

		private static float PanelWidth => ((float)Math.Max(quickSlotsCount, SlotPositions.LastEquipmentColumn() + 1) + FoodAmmoSlotsWidthInTiles) * 70f + 3f;

		private static float PanelHeight => (((quickSlotsCount > 0 || Slots.IsFirstMiscSlotAvailable()) ? 1.25f : 0f) + (float)EquipmentHeight) * 70f + 3f;

		private static Vector2 PanelOffset => new Vector2(ExtraSlots.equipmentPanelOffset.Value.x, 0f - ExtraSlots.equipmentPanelOffset.Value.y);

		private static Vector2 PanelPosition => new Vector2(InventoryPanelWidth + 100f, 0f) + PanelOffset;

		private static float FoodAmmoSlotsWidthInTiles => ((Slots.IsFoodSlotAvailable() || Slots.IsAmmoSlotAvailable()) ? 0.25f : 0f) + (Slots.IsFoodSlotAvailable() ? 1f : 0f) + (Slots.IsAmmoSlotAvailable() ? 1f : 0f);

		private static int EquipmentHeight => (equipmentSlotsCount > 3 || Slots.IsFoodSlotAvailable() || Slots.IsAmmoSlotAvailable()) ? 3 : equipmentSlotsCount;

		private static RectTransform SelectedFrameArmor
		{
			get
			{
				Transform obj = ((Transform)InventoryGui.instance.m_player).Find("selected_frame/selected (2)");
				return (RectTransform)(object)((obj is RectTransform) ? obj : null);
			}
		}

		private static RectTransform SelectedFrameWeight
		{
			get
			{
				Transform obj = ((Transform)InventoryGui.instance.m_player).Find("selected_frame/selected (3)");
				return (RectTransform)(object)((obj is RectTransform) ? obj : null);
			}
		}

		public static void MarkDirty()
		{
			isDirty = true;
		}

		public static void UpdateSidePanels()
		{
			updateSidePanelsInFrames = 3;
		}

		internal static void UpdateSlotsCount()
		{
			equipmentSlotsCount = Slots.GetEquipmentSlotsCount();
			quickSlotsCount = Slots.GetQuickSlotsCount();
		}

		internal static void ReorderVanillaSlots()
		{
			List<string> list = Slots.VanillaOrder.Split(',').ToList();
			List<string> list2 = (from s in ExtraSlots.vanillaSlotsOrder.Value.Split(',')
				select s.Trim() into s
				where Slots.Slot.IsVanillaSlotID(s)
				select s).Distinct().ToList();
			foreach (string item in list)
			{
				if (!list2.Contains(item))
				{
					list2.Add(item);
				}
			}
			List<Slots.Slot> list3 = Slots.slots.Where((Slots.Slot s) => s?.IsVanillaEquipment() ?? false).ToList();
			CollectionExtensions.Do<Slots.Slot>((IEnumerable<Slots.Slot>)list3, (Action<Slots.Slot>)delegate(Slots.Slot slot)
			{
				slot.CacheItem();
			});
			List<Slots.Slot> list4 = new List<Slots.Slot>();
			foreach (string id in list2)
			{
				Slots.Slot slot2 = list3.FirstOrDefault((Slots.Slot s) => s.ID == id);
				if (slot2 != null)
				{
					list4.Add(slot2);
				}
			}
			list4.AddRange(list3.Except(list4));
			int num = 0;
			for (int i = 0; i < Slots.slots.Length; i++)
			{
				if (Slots.slots[i] != null && Slots.slots[i].IsVanillaEquipment())
				{
					Slots.slots[i] = list4[num++];
				}
			}
			for (int j = 0; j < Slots.slots.Length; j++)
			{
				if (Slots.slots[j] != null && Slots.slots[j].IsVanillaEquipment())
				{
					Slots.slots[j].SetSlotIndex(j);
					Slots.slots[j].UpdateGridPosition();
				}
			}
			SetSlotsPositions();
			Inventory playerInventory = Slots.PlayerInventory;
			if (playerInventory != null)
			{
				playerInventory.Changed();
			}
			if (ExtraSlots.vanillaSlotsOrder.Value != Slots.VanillaOrder)
			{
				ExtraSlots.LogInfo("Vanilla slots reordered: " + GeneralExtensions.Join<string>((IEnumerable<string>)list2, (Func<string, string>)null, ", "));
			}
		}

		internal static void UpdatePanel()
		{
			UpdateSlotsCount();
			UpdateBackground();
			SetSlotsPositions();
			MarkDirty();
			UpdateSidePanels();
		}

		internal static void UpdateInventorySlots()
		{
			//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_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_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			InventoryGui.instance.m_playerGrid.m_gridRoot.SetSizeWithCurrentAnchors((Axis)1, (float)Slots.InventoryHeightPlayer * InventoryGui.instance.m_playerGrid.m_elementSpace);
			if (originalScale == Vector3.zero && InventoryGui.instance.m_playerGrid.m_elements.Count > 0)
			{
				Image icon = InventoryGui.instance.m_playerGrid.m_elements[0].m_icon;
				if (icon != null && (Object)(object)((Graphic)icon).material != (Object)null)
				{
					originalScale = ((Component)icon).transform.localScale;
				}
			}
			int inventorySizePlayer = Slots.InventorySizePlayer;
			for (int i = 0; i < Math.Min(Slots.slots.Length, InventoryGui.instance.m_playerGrid.m_elements.Count - inventorySizePlayer); i++)
			{
				SetSlotBackgroundImage(InventoryGui.instance.m_playerGrid.m_elements[inventorySizePlayer + i], Slots.slots[i]);
			}
			for (int j = 0; j < Math.Min(inventorySizePlayer, InventoryGui.instance.m_playerGrid.m_elements.Count); j++)
			{
				SetInventorySlotBackgroundImage(InventoryGui.instance.m_playerGrid.m_elements[j], LightenedSlots.IsRowAffected(j / Slots.InventoryWidth));
			}
			if (!isDirty || Slots.PlayerInventory == null || !Object.op_Implicit((Object)(object)InventoryGui.instance.m_playerGrid))
			{
				return;
			}
			bool flag = InventoryGui.instance.m_dragItem != null && ((Humanoid)Slots.CurrentPlayer).IsItemEquiped(InventoryGui.instance.m_dragItem) && Slots.IsItemInEquipmentSlot(InventoryGui.instance.m_dragItem);
			for (int k = 0; k < Math.Min(InventoryGui.instance.m_playerGrid.m_elements.Count, inventorySizePlayer); k++)
			{
				Element obj = InventoryGui.instance.m_playerGrid.m_elements[k];
				object button;
				if (obj == null)
				{
					button = null;
				}
				else
				{
					GameObject go = obj.m_go;
					button = ((go != null) ? go.GetComponent<Button>() : null);
				}
				SetSlotColor((Button)button, flag);
			}
			for (int l = 0; l < Math.Min(Slots.slots.Length, InventoryGui.instance.m_playerGrid.m_elements.Count - inventorySizePlayer); l++)
			{
				SetSlotElement(InventoryGui.instance.m_playerGrid.m_elements[inventorySizePlayer + l], Slots.slots[l], flag);
			}
			for (int m = inventorySizePlayer + Slots.slots.Length; m < InventoryGui.instance.m_playerGrid.m_elements.Count; m++)
			{
				Element obj2 = InventoryGui.instance.m_playerGrid.m_elements[m];
				if (obj2 != null)
				{
					GameObject go2 = obj2.m_go;
					if (go2 != null)
					{
						go2.SetActive(false);
					}
				}
			}
			if (originalTooltipPosition == Vector2.zero)
			{
				originalTooltipPosition = InventoryGui.instance.m_playerGrid.m_tooltipAnchor.anchoredPosition;
			}
			if (ExtraSlots.equipmentPanelTooltipOffset.Value == Vector2.zero)
			{
				InventoryGui.instance.m_playerGrid.m_tooltipAnchor.anchoredPosition = originalTooltipPosition - new Vector2(0f, PanelHeight + 21f);
			}
			else
			{
				InventoryGui.instance.m_playerGrid.m_tooltipAnchor.anchoredPosition = originalTooltipPosition + new Vector2(ExtraSlots.equipmentPanelTooltipOffset.Value.x, 0f - ExtraSlots.equipmentPanelTooltipOffset.Value.y);
			}
			isDirty = false;
		}

		public static void UpdateBackground()
		{
			//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)
			//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_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_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_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)equipmentBackground))
			{
				equipmentBackground.sizeDelta = new Vector2(PanelWidth, PanelHeight);
				equipmentBackground.anchoredPosition = PanelPosition + new Vector2(PanelWidth / 2f, (0f - PanelHeight) / 2f);
				if (Object.op_Implicit((Object)(object)selectedFrame))
				{
					selectedFrame.sizeDelta = equipmentBackground.sizeDelta + Vector2.one * 26f;
					selectedFrame.anchoredPosition = equipmentBackground.anchoredPosition;
				}
			}
		}

		internal static void SetSlotElement(Element element, Slots.Slot slot, bool regularInventoryUnfitsForDragItem)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = element?.m_go;
			if (Object.op_Implicit((Object)(object)val))
			{
				val.gameObject.SetActive(slot.IsActive);
				val.GetComponent<RectTransform>().anchoredPosition = slot.Position;
				SetSlotLabel(val.transform.Find("binding"), slot);
				SetSlotColor(val.GetComponent<Button>(), InventoryGui.instance.m_dragItem != null && slot.IsActive && (!slot.ItemFits(InventoryGui.instance.m_dragItem) || (!slot.IsEquipmentSlot && regularInventoryUnfitsForDragItem)));
				SetSlotStackColor(element.m_amount, slot);
			}
		}

		internal static void SetSlotLabel(Transform binding, Slots.Slot slot, bool hotbarElement = false)
		{
			if (Object.op_Implicit((Object)(object)binding) && slot.IsActive)
			{
				SetSlotLabel(((Component)binding).GetComponent<RectTransform>(), ((Component)binding).GetComponent<TMP_Text>(), slot, hotbarElement);
			}
		}

		internal static void SetSlotLabel(RectTransform rectTransform, TMP_Text textComponent, Slots.Slot slot, bool hotbarElement = false)
		{
			//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_003e: 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_00bf: 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_00dd: 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_00f6: 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_0145: 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_015e: 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_0172: 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_01b7: 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_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			rectTransform.sizeDelta = Vector2.zero;
			rectTransform.anchoredPosition = Vector2.zero;
			textComponent.enableAutoSizing = true;
			textComponent.text = ((!hotbarElement) ? slot.Name : (ZInput.IsGamepadActive() ? "" : slot.GetShortcutText()));
			((Behaviour)textComponent).enabled = true;
			textComponent.overflowMode = (TextOverflowModes)0;
			textComponent.fontSizeMin = ((!slot.IsHotkeySlot) ? ExtraSlots.equipmentSlotLabelFontSize.Value.x : (slot.IsAmmoSlot ? ExtraSlots.ammoSlotLabelFontSize.Value.x : ExtraSlots.quickSlotLabelFontSize.Value.x));
			textComponent.fontSizeMax = ((!slot.IsHotkeySlot) ? ExtraSlots.equipmentSlotLabelFontSize.Value.y : (slot.IsAmmoSlot ? ExtraSlots.ammoSlotLabelFontSize.Value.y : ExtraSlots.quickSlotLabelFontSize.Value.y));
			((Graphic)textComponent).color = ((!slot.IsHotkeySlot) ? ExtraSlots.equipmentSlotLabelFontColor.Value : (slot.IsAmmoSlot ? ExtraSlots.ammoSlotLabelFontColor.Value : ExtraSlots.quickSlotLabelFontColor.Value));
			textComponent.margin = ((!slot.IsHotkeySlot) ? ExtraSlots.equipmentSlotLabelMargin.Value : (slot.IsAmmoSlot ? ExtraSlots.ammoSlotLabelMargin.Value : ExtraSlots.quickSlotLabelMargin.Value));
			textComponent.textWrappingMode = ((!slot.IsHotkeySlot) ? ExtraSlots.equipmentSlotLabelWrappingMode.Value : (slot.IsAmmoSlot ? ExtraSlots.ammoSlotLabelWrappingMode.Value : ExtraSlots.quickSlotLabelWrappingMode.Value));
			textComponent.horizontalAlignment = ((!slot.IsHotkeySlot) ? ExtraSlots.equipmentSlotLabelAlignment.Value : (slot.IsAmmoSlot ? ExtraSlots.ammoSlotLabelAlignment.Value : ExtraSlots.quickSlotLabelAlignment.Value));
			textComponent.verticalAlignment = (VerticalAlignmentOptions)256;
		}

		internal static void SetSlotColor(Button button, bool useUnfitColor)
		{
			//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_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_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_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_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_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_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_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_007f: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: 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_0110: 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 (Object.op_Implicit((Object)(object)button))
			{
				ColorBlock colors;
				if (normalColor == Color.clear)
				{
					colors = ((Selectable)button).colors;
					normalColor = ((ColorBlock)(ref colors)).normalColor;
				}
				if (highlightedColor == Color.clear)
				{
					colors = ((Selectable)button).colors;
					highlightedColor = ((ColorBlock)(ref colors)).highlightedColor;
				}
				if (normalColorUnfit == Color.clear)
				{
					colors = ((Selectable)button).colors;
					normalColorUnfit = ((ColorBlock)(ref colors)).normalColor + new Color(0.3f, 0f, 0f, 0.1f);
				}
				if (highlightedColorUnfit == Color.clear)
				{
					colors = ((Selectable)button).colors;
					highlightedColorUnfit = ((ColorBlock)(ref colors)).highlightedColor + new Color(0.3f, 0f, 0f, 0.1f);
				}
				ColorBlock colors2 = ((Selectable)button).colors;
				((ColorBlock)(ref colors2)).normalColor = (useUnfitColor ? normalColorUnfit : normalColor);
				((ColorBlock)(ref colors2)).highlightedColor = (useUnfitColor ? highlightedColorUnfit : highlightedColor);
				((Selectable)button).colors = colors2;
			}
		}

		private static void SetInventorySlotBackgroundImage(Element element, bool weightReduction)
		{
			//IL_00f3: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//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_0193: 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_00a4: 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)
			if ((Object)(object)iconMaterial == (Object)null && (Object)(object)((Graphic)element.m_icon).material != (Object)null)
			{
				iconMaterial = ((Graphic)element.m_icon).material;
			}
			if ((Object)(object)((Graphic)element.m_icon).material == (Object)null)
			{
				((Graphic)element.m_icon).material = iconMaterial;
			}
			if (element.m_used || !weightReduction)
			{
				((Graphic)element.m_icon).material = iconMaterial;
				((Component)element.m_icon).transform.localScale = ((originalScale == Vector3.zero) ? Vector3.one : originalScale);
				return;
			}
			((Behaviour)element.m_icon).enabled = ExtraSlots.lightenedSlotsShowHintImage.Value;
			((Graphic)element.m_icon).material = null;
			element.m_icon.sprite = lightenedSlot;
			((Component)element.m_icon).transform.localScale = Vector3.one * 0.7f;
			((Graphic)element.m_icon).color = Color.grey - new Color(0f, 0f, 0f, 0.7f);
			if (ExtraSlots.lightenedSlotsShowTooltip.Value)
			{
				element.m_tooltip.Set("$exsl_slot_lightened", Localization.instance.Localize("$exsl_slot_lightened_desc", new string[1] { $"{1f - LightenedSlots.WeightFactor:P0}" }), InventoryGui.instance.m_playerGrid.m_tooltipAnchor, default(Vector2));
			}
		}

		private static void SetSlotBackgroundImage(Element element, Slots.Slot slot)
		{
			//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_0102: 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_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: 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_0534: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: 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_01ce: 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_01ee: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)iconMaterial == (Object)null && (Object)(object)((Graphic)element.m_icon).material != (Object)null)
			{
				iconMaterial = ((Graphic)element.m_icon).material;
			}
			if ((Object)(object)((Graphic)element.m_icon).material == (Object)null)
			{
				((Graphic)element.m_icon).material = iconMaterial;
			}
			bool isFree = slot.IsFree;
			if (!isFree)
			{
				ItemData item = slot.Item;
				if (element.m_tooltip.m_topic.IndexOf(item.m_shared.m_name, StringComparison.OrdinalIgnoreCase) == -1)
				{
					element.m_tooltip.Set(item.m_shared.m_name, item.GetTooltip(-1), InventoryGui.instance.m_playerGrid.m_tooltipAnchor, default(Vector2));
				}
				((Component)element.m_icon).transform.localScale = ((originalScale == Vector3.zero) ? Vector3.one : originalScale);
				((Graphic)element.m_icon).material = iconMaterial;
				if (!slot.IsEquipmentSlot || !EpicLootCompat.isEnabled || ExtraSlots.epicLootMagicItemUnequippedAlpha.Value == 1f || item.m_equipped)
				{
					return;
				}
				Transform val = element.m_go.transform.Find("magicItem");
				if (val != null)
				{
					Image component = ((Component)val).GetComponent<Image>();
					if (component != null)
					{
						((Graphic)component).color = new Color(((Graphic)component).color.r, ((Graphic)component).color.g, ((Graphic)component).color.b, ExtraSlots.epicLootMagicItemUnequippedAlpha.Value);
					}
				}
			}
			else if (slot.IsEquipmentSlot)
			{
				if (ExtraSlots.equipmentSlotsShowTooltip.Value)
				{
					SetTooltip("$exsl_slot_equipment", "$exsl_slot_equipment_desc");
				}
			}
			else if (slot.IsAmmoSlot)
			{
				((Behaviour)element.m_icon).enabled = ExtraSlots.ammoSlotsShowHintImage.Value;
				((Graphic)element.m_icon).material = null;
				element.m_icon.sprite = ammoSlot;
				((Component)element.m_icon).transform.localScale = Vector3.one * 0.8f;
				((Graphic)element.m_icon).color = Color.grey - new Color(0f, 0f, 0f, 0.1f);
				if (ExtraSlots.ammoSlotsShowTooltip.Value)
				{
					SetTooltip(string.Format(ExtraSlots.ammoSlotsTooltipNameFormat.Value, "$exsl_slot_ammo", slot.GetShortcutText()), "$exsl_slot_ammo_desc");
				}
			}
			else if (slot.IsQuickSlot)
			{
				((Behaviour)element.m_icon).enabled = ExtraSlots.quickSlotsShowHintImage.Value;
				((Graphic)element.m_icon).material = null;
				element.m_icon.sprite = quickSlot;
				((Component)element.m_icon).transform.localScale = Vector3.one * 0.6f;
				((Graphic)element.m_icon).color = Color.grey - new Color(0f, 0f, 0f, 0.6f);
				if (ExtraSlots.quickSlotsShowTooltip.Value)
				{
					SetTooltip(string.Format(ExtraSlots.quickSlotsTooltipNameFormat.Value, "$exsl_slot_quick", slot.GetShortcutText()), "$exsl_slot_quick_desc");
				}
			}
			else if (slot.IsMiscSlot)
			{
				((Behaviour)element.m_icon).enabled = ExtraSlots.miscSlotsShowHintImage.Value;
				((Graphic)element.m_icon).material = null;
				element.m_icon.sprite = miscSlot;
				((Component)element.m_icon).transform.localScale = Vector3.one * 0.8f;
				((Graphic)element.m_icon).color = Color.grey - new Color(0f, 0f, 0f, 0.75f);
				if (ExtraSlots.miscSlotsShowTooltip.Value)
				{
					SetTooltip("$exsl_slot_misc", "$exsl_slot_misc_desc");
				}
			}
			else if (slot.IsFoodSlot && isFree)
			{
				((Behaviour)element.m_food).enabled = ExtraSlots.foodSlotsShowHintImage.Value;
				((Graphic)element.m_food).color = Color.grey - new Color(0f, 0f, 0f, 0.5f);
				if (ExtraSlots.foodSlotsShowTooltip.Value)
				{
					SetTooltip(string.Format(ExtraSlots.foodSlotsTooltipNameFormat.Value, "$exsl_slot_food", slot.GetShortcutText()), "$exsl_slot_food_desc");
				}
			}
			void SetTooltip(string topic, string description)
			{
				//IL_0029: 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)
				element.m_tooltip.Set(topic, GetCombinedTooltip(description, slot), InventoryGui.instance.m_playerGrid.m_tooltipAnchor, default(Vector2));
			}
		}

		private static string GetCombinedTooltip(string tooltip, Slots.Slot slot)
		{
			float itemWeightFactor = InventoryInteraction.GetItemWeightFactor(slot);
			if (itemWeightFactor == 1f)
			{
				return tooltip;
			}
			return (tooltip + "\n" + Localization.instance.Localize("$exsl_slot_lightened_desc", new string[1] { $"{1f - itemWeightFactor:P0}" })).Trim();
		}

		private static void SetSlotStackColor(TMP_Text text, Slots.Slot 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_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_0018: Unknown result type (might be due to invalid IL or missing references)
			Color slotStackSizeColor = GetSlotStackSizeColor(slot);
			if (slotStackSizeColor != Color.clear)
			{
				((Graphic)text).color = slotStackSizeColor;
			}
		}

		internal static void SetSlotsPositions()
		{
			SetPosition(Slots.GetEquipmentSlots(), SlotPositions.GetEquipmentTileOffset);
			SetPosition(Slots.GetQuickSlots(), SlotPositions.GetQuickSlotTileOffset);
			SetPosition(Slots.GetFoodSlots(), SlotPositions.GetFoodSlotTileOffset);
			SetPosition(Slots.GetAmmoSlots(), SlotPositions.GetAmmoSlotTileOffset);
			SetPosition(Slots.GetMiscSlots(), SlotPositions.GetMiscSlotTileOffset);
			CollectionExtensions.Do<Slots.Slot>((IEnumerable<Slots.Slot>)Slots.GetInactiveSlots(), (Action<Slots.Slot>)delegate(Slots.Slot slot)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				slot.SetPosition(Vector2.zero);
			});
			static void SetPosition(Slots.Slot[] collection, Func<int, Vector2> offsetFunc)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				for (int i = 0; i < collection.Length; i++)
				{
					collection[i].SetPosition(offsetFunc(i));
				}
			}
		}

		private static Color GetSlotStackSizeColor(Slots.Slot 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_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_0067: 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_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_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)
			if (slot.IsMiscSlot)
			{
				return ExtraSlots.miscSlotsStackColor.Value;
			}
			if (slot.IsFoodSlot)
			{
				return ExtraSlots.foodSlotsStackColor.Value;
			}
			if (slot.IsAmmoSlot)
			{
				return ExtraSlots.ammoSlotsStackColor.Value;
			}
			if (slot.IsQuickSlot)
			{
				return ExtraSlots.quickSlotsStackColor.Value;
			}
			return Color.clear;
		}

		internal static void UpdateEquipmentBackground()
		{
			//IL_03dc: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: 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_017f: 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_01de: 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_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)InventoryGui.instance))
			{
				return;
			}
			if (inventoryBackground == null)
			{
				RectTransform player = InventoryGui.instance.m_player;
				object obj;
				if (player == null)
				{
					obj = null;
				}
				else
				{
					Transform obj2 = ((Transform)player).Find("Bkg");
					obj = ((obj2 != null) ? ((Component)obj2).GetComponent<RectTransform>() : null);
				}
				inventoryBackground = (RectTransform)obj;
			}
			if ((Object)(object)inventoryBackground == (Object)null)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)equipmentBackground) && Object.op_Implicit((Object)(object)InventoryGui.instance.m_player))
			{
				UIGroupHandler component = ((Component)InventoryGui.instance.m_player).GetComponent<UIGroupHandler>();
				Transform val = ((component != null) ? component.m_enableWhenActiveAndGamepad.transform : null);
				inventoryDarken = ((Component)((Transform)InventoryGui.instance.m_player).Find("Darken")).GetComponent<RectTransform>();
				equipmentBackground = new GameObject("ExtraSlotsEquipmentPanel", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
				((Component)equipmentBackground).gameObject.layer = ((Component)inventoryBackground).gameObject.layer;
				((Transform)equipmentBackground).SetParent((Transform)(object)InventoryGui.instance.m_player, false);
				((Transform)equipmentBackground).SetSiblingIndex(1 + (((Object)(object)val == (Object)null) ? ((Transform)inventoryDarken).GetSiblingIndex() : val.GetSiblingIndex()));
				equipmentBackground.offsetMin = Vector2.zero;
				equipmentBackground.offsetMax = Vector2.zero;
				equipmentBackground.sizeDelta = Vector2.zero;
				equipmentBackground.anchoredPosition = Vector2.zero;
				equipmentBackground.anchorMin = new Vector2(0f, 1f);
				equipmentBackground.anchorMax = new Vector2(0f, 1f);
				RectTransform val2 = Object.Instantiate<RectTransform>(inventoryDarken, (Transform)(object)equipmentBackground);
				((Object)val2).name = "Darken";
				val2.sizeDelta = Vector2.one * 70f;
				Transform val3 = Object.Instantiate<Transform>(((Component)inventoryBackground).transform, (Transform)(object)equipmentBackground);
				((Object)val3).name = "Bkg";
				equipmentBackgroundImage = ((Component)val3).GetComponent<Image>();
				inventoryBackgroundImage = ((Component)((Component)inventoryBackground).transform).GetComponent<Image>();
				if ((Object)(object)val != (Object)null)
				{
					Transform child = val.GetChild(0);
					inventorySelectedFrame = (RectTransform)(object)((child is RectTransform) ? child : null);
					selectedFrame = Object.Instantiate<RectTransform>(inventorySelectedFrame, val);
					((Object)selectedFrame).name = "selected (ExtraSlots)";
					selectedFrame.offsetMin = equipmentBackground.offsetMin;
					selectedFrame.offsetMax = equipmentBackground.offsetMax;
					selectedFrame.sizeDelta = equipmentBackground.sizeDelta;
					selectedFrame.anchoredPosition = equipmentBackground.anchoredPosition;
					selectedFrame.anchorMin = equipmentBackground.anchorMin;
					selectedFrame.anchorMax = equipmentBackground.anchorMax;
				}
				UpdateBackground();
			}
			if (Object.op_Implicit((Object)(object)equipmentBackgroundImage))
			{
				if (Object.op_Implicit((Object)(object)inventoryBackgroundImage))
				{
					equipmentBackgroundImage.sprite = inventoryBackgroundImage.sprite;
					equipmentBackgroundImage.overrideSprite = inventoryBackgroundImage.overrideSprite;
					((Graphic)equipmentBackgroundImage).color = ((Graphic)inventoryBackgroundImage).color;
				}
				if (Object.op_Implicit((Object)(object)background))
				{
					equipmentBackgroundImage.sprite = background;
					equipmentBackgroundImage.overrideSprite = background;
				}
			}
			int extraRowsPlayer = Slots.ExtraRowsPlayer;
			if (Object.op_Implicit((Object)(object)inventoryBackground))
			{
				inventoryBackground.anchorMin = new Vector2(0f, -1f * ((float)extraRowsPlayer / 4f - 0.01f * (float)Math.Max(extraRowsPlayer - 1, 0)));
				if (Object.op_Implicit((Object)(object)inventorySelectedFrame))
				{
					inventorySelectedFrame.anchorMin = inventoryBackground.anchorMin;
				}
				if (Object.op_Implicit((Object)(object)inventoryDarken))
				{
					inventoryDarken.anchorMin = inventoryBackground.anchorMin;
				}
			}
			if (ExtraSlots.fixContainerPosition.Value)
			{
				InventoryGui.instance.m_container.pivot = new Vector2(0f, 1f + (float)extraRowsPlayer * 0.2f);
			}
			if (updateSidePanelsInFrames >= 0)
			{
				updateSidePanelsInFrames--;
			}
			if (updateSidePanelsInFrames != 0)
			{
				return;
			}
			if (updateSidePanelsPreviousExtraRows == -10)
			{
				UpdateSidePanelsDefaultPositions();
				updateSidePanelsPreviousExtraRows = extraRowsPlayer;
			}
			bool num;
			if (updateSidePanelsPreviousExtraRows >= extraRowsPlayer)
			{
				num = extraRowsPlayer < 0;
			}
			else
			{
				if (extraRowsPlayer <= 0)
				{
					goto IL_04d6;
				}
				num = updateSidePanelsPreviousExtraRows < 0;
			}
			if (num)
			{
				goto IL_04d6;
			}
			goto IL_04dd;
			IL_04d6:
			MoveSidePanels(extraRowsPlayer);
			goto IL_04dd;
			IL_04dd:
			updateSidePanelsPreviousExtraRows = extraRowsPlayer;
		}

		private static void MoveSidePanels(int extraRows)
		{
			//IL_010e: 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_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: 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_016a: 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_01e6: 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_01b3: 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_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: 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_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: 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)
			List<List<RectTransform>> list = new List<List<RectTransform>>();
			AddPanelGroup(list, ExtraSlots.reducedInventoryPanel1.Value);
			AddPanelGroup(list, ExtraSlots.reducedInventoryPanel2.Value);
			AddPanelGroup(list, ExtraSlots.reducedInventoryPanel3.Value);
			if (extraRows >= 0)
			{
				CollectionExtensions.Do<List<RectTransform>>((IEnumerable<List<RectTransform>>)list, (Action<List<RectTransform>>)delegate(List<RectTransform> group)
				{
					CollectionExtensions.Do<RectTransform>((IEnumerable<RectTransform>)group, (Action<RectTransform>)RestorePositionAndVisibility);
				});
				RestorePositionAndVisibility(SelectedFrameArmor);
				RestorePositionAndVisibility(SelectedFrameWeight);
				return;
			}
			CollectionExtensions.Do<List<RectTransform>>((IEnumerable<List<RectTransform>>)list, (Action<List<RectTransform>>)delegate(List<RectTransform> group)
			{
				CollectionExtensions.Do<RectTransform>((IEnumerable<RectTransform>)group, (Action<RectTransform>)CheckVisibility);
			});
			list.RemoveAll((List<RectTransform> group) => !group.Any((RectTransform g) => ((Component)g).gameObject.activeSelf));
			RectTransform val = null;
			RectTransform val2 = null;
			for (int i = 0; i < list.Count; i++)
			{
				for (int j = 0; j < list[i].Count; j++)
				{
					RectTransform val3 = list[i][j];
					if (extraRows == -3)
					{
						val3.anchorMin = Vector2.one;
						val3.anchorMax = Vector2.one;
						val3.anchoredPosition = new Vector2(val3.anchoredPosition.x, -37f);
					}
					else if (extraRows == -2)
					{
						val3.anchorMin = Vector2.one;
						val3.anchorMax = Vector2.one;
						if (i == 0)
						{
							val3.anchoredPosition = new Vector2(val3.anchoredPosition.x, -37f);
						}
						else
						{
							val3.anchoredPosition = new Vector2(val3.anchoredPosition.x, -107f);
						}
					}
					else if (extraRows == -1)
					{
						val3.anchorMin = Vector2.one;
						val3.anchorMax = Vector2.one;
						if (list.Count == 3)
						{
							switch (i)
							{
							case 0:
								val3.anchoredPosition = new Vector2(val3.anchoredPosition.x, -33f);
								break;
							case 1:
								val3.anchoredPosition = new Vector2(val3.anchoredPosition.x, -107f);
								break;
							default:
								val3.anchoredPosition = new Vector2(val3.anchoredPosition.x, -183f);
								break;
							}
						}
						else if (i == 0)
						{
							val3.anchoredPosition = new Vector2(val3.anchoredPosition.x, -42f);
						}
						else
						{
							val3.anchoredPosition = new Vector2(val3.anchoredPosition.x, -172f);
						}
					}
					if (((Object)val3).name == "Armor")
					{
						val = val3;
					}
					else if (((Object)val3).name == "Weight")
					{
						val2 = val3;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				RectTransform selectedFrameArmor = SelectedFrameArmor;
				if (selectedFrameArmor != null)
				{
					((Component)selectedFrameArmor).gameObject.SetActive(((Component)val).gameObject.activeSelf);
					selectedFrameArmor.anchorMin = val.anchorMin;
					selectedFrameArmor.anchorMax = val.anchorMax;
					selectedFrameArmor.anchoredPosition = val.anchoredPosition + new Vector2(-2f, 0f);
				}
			}
			if ((Object)(object)val2 != (Object)null)
			{
				RectTransform selectedFrameWeight = SelectedFrameWeight;
				if (selectedFrameWeight != null)
				{
					((Component)selectedFrameWeight).gameObject.SetActive(((Component)val2).gameObject.activeSelf);
					selectedFrameWeight.anchorMin = val2.anchorMin;
					selectedFrameWeight.anchorMax = val2.anchorMax;
					selectedFrameWeight.anchoredPosition = val2.anchoredPosition + new Vector2(1f, 0f);
				}
			}
			void CheckVisibility(RectTransform panel)
			{
				bool flag = true;
				if (defaultPositionsSidePanels.TryGetValue(((Object)panel).name, out var value))
				{
					flag = value.active;
				}
				if (extraRows < -2)
				{
					flag = flag && ExtraSlots.reducedInventoryPanelVisibility1.Value.Split(',').Contains<string>(((Object)panel).name, StringComparer.OrdinalIgnoreCase);
				}
				else if (extraRows < -1)
				{
					flag = flag && ExtraSlots.reducedInventoryPanelVisibility2.Value.Split(',').Contains<string>(((Object)panel).name, StringComparer.OrdinalIgnoreCase);
				}
				else if (extraRows < 0)
				{
					flag = flag && ExtraSlots.reducedInventoryPanelVisibility3.Value.Split(',').Contains<string>(((Object)panel).name, StringComparer.OrdinalIgnoreCase);
				}
				((Component)panel).gameObject.SetActive(flag);
			}
		}

		private static void RestorePositionAndVisibility(RectTransform panel)
		{
			//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_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)panel == (Object)null) && defaultPositionsSidePanels.TryGetValue(((Object)panel).name, out var value))
			{
				panel.anchorMin = value.anchorMin;
				panel.anchorMax = value.anchorMax;
				panel.anchoredPosition = value.anchoredPosition;
				((Component)panel).gameObject.SetActive(value.active);
			}
		}

		private static void AddPanelGroup(List<List<RectTransform>> groups, string config)
		{
			List<RectTransform> list = new List<RectTransform>();
			string[] array = config.Split(',', StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				if (!string.IsNullOrWhiteSpace(text))
				{
					Transform obj = ((Transform)InventoryGui.instance.m_player).Find(text);
					RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
					if (val != null)
					{
						list.Add(val);
					}
				}
			}
			if (list.Count > 0)
			{
				groups.Add(list);
			}
		}

		private static void UpdateSidePanelsDefaultPositions()
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: 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_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: 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_01c4: 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)
			defaultPositionsSidePanels.Clear();
			if (!Object.op_Implicit((Object)(object)InventoryGui.instance.m_player))
			{
				return;
			}
			List<string> list = new List<string>();
			list.AddRange(ExtraSlots.reducedInventoryPanel1.Value.Split(','));
			list.AddRange(ExtraSlots.reducedInventoryPanel2.Value.Split(','));
			list.AddRange(ExtraSlots.reducedInventoryPanel3.Value.Split(','));
			foreach (string item in list)
			{
				Transform obj = ((Transform)InventoryGui.instance.m_player).Find(item);
				RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if (val != null)
				{
					defaultPositionsSidePanels[item] = new SidePanelDefaults
					{
						active = ((Component)val).gameObject.activeSelf,
						anchoredPosition = val.anchoredPosition,
						anchorMax = val.anchorMax,
						anchorMin = val.anchorMin
					};
				}
			}
			RectTransform selectedFrameArmor = SelectedFrameArmor;
			if (selectedFrameArmor != null)
			{
				defaultPositionsSidePanels[((Object)selectedFrameArmor).name] = new SidePanelDefaults
				{
					active = ((Component)selectedFrameArmor).gameObject.activeSelf,
					anchoredPosition = selectedFrameArmor.anchoredPosition,
					anchorMax = selectedFrameArmor.anchorMax,
					anchorMin = selectedFrameArmor.anchorMin
				};
			}
			RectTransform selectedFrameWeight = SelectedFrameWeight;
			if (selectedFrameWeight != null)
			{
				defaultPositionsSidePanels[((Object)selectedFrameWeight).name] = new SidePanelDefaults
				{
					active = ((Component)selectedFrameWeight).gameObject.activeSelf,
					anchoredPosition = selectedFrameWeight.anchoredPosition,
					anchorMax = selectedFrameWeight.anchorMax,
					anchorMin = selectedFrameWeight.anchorMin
				};
			}
		}

		internal static void ClearPanel()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			inventoryDarken = null;
			inventoryBackground = null;
			equipmentBackground = null;
			equipmentBackgroundImage = null;
			inventoryBackgroundImage = null;
			selectedFrame = null;
			inventorySelectedFrame = null;
			normalColor = Color.clear;
			highlightedColor = Color.clear;
			normalColorUnfit = Color.clear;
			highlightedColorUnfit = Color.clear;
			iconMaterial = null;
			originalScale = Vector3.zero;
			updateSidePanelsInFrames = 0;
			updateSidePanelsPreviousExtraRows = -10;
		}
	}
	public static class InventoryInteraction
	{
		[HarmonyPatch(typeof(Player), "Awake")]
		private static class Player_Awake_SetInventoryHeight
		{
			private static void Postfix(Player __instance)
			{
				((Humanoid)__instance).m_inventory.m_height = Slots.InventoryHeightFull;
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class Player_OnSpawned_UpdateInventoryOnSpawn
		{
			private static void Postfix(Player __instance)
			{
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !ExtraSlots.IsAwaitingForSlotsUpdate())
				{
					UpdatePlayerInventorySize();
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Update")]
		private static class Player_Update_UpdateInventoryHeight
		{
			private static Container tombstoneContainer;

			private static void Postfix(Player __instance)
			{
				((Humanoid)__instance).m_inventory.m_height = Slots.InventoryHeightFull;
				if (tombstoneContainer == null)
				{
					tombstoneContainer = __instance.m_tombstone.GetComponent<Container>();
				}
				if ((Object)(object)tombstoneContainer != (Object)null)
				{
					tombstoneContainer.m_height = ((Humanoid)__instance).m_inventory.m_height;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Save")]
		private static class Player_Save_SaveLastEquippedSlots
		{
			private static void Prefix(Player __instance)
			{
				if (((Humanoid)__instance).GetInventory() == Slots.PlayerInventory)
				{
					Slots.SaveLastEquippedSlotsToItems();
				}
			}
		}

		[HarmonyPatch(typeof(Player), "AutoPickup")]
		public static class Player_AutoPickup_PreventAutoPickupInExtraSlots
		{
			public static bool preventAddItem;

			[HarmonyPriority(800)]
			private static void Prefix(Player __instance)
			{
				preventAddItem = ExtraSlots.preventAutoPickup.Value && (Object)(object)__instance == (Object)(object)Slots.CurrentPlayer;
			}

			[HarmonyPriority(800)]
			private static void Postfix()
			{
				preventAddItem = false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "SlotsUsedPercentage")]
		private static class Inventory_SlotsUsedPercentage_ExcludeRedundantSlots
		{
			private static void Postfix(Inventory __instance, ref float __result)
			{
				if (__instance == Slots.PlayerInventory)
				{
					__result = (float)__instance.m_inventory.Count / (float)Slots.InventorySizeActive * 100f;
					ExtraSlots.LogDebug($"Inventory.SlotsUsedPercentage: {__result}");
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "GetEmptySlots")]
		private static class Inventory_GetEmptySlots_CheckRegularInventoryAndQuickSlots
		{
			[HarmonyPriority(800)]
			private static void Postfix(Inventory __instance, ref int __result)
			{
				if (__instance == Slots.PlayerInventory)
				{
					__result = Slots.InventoryHeightPlayer * __instance.m_width - __instance.m_inventory.Count((ItemData item) => !API.IsItemInSlot(item)) + ((!Player_AutoPickup_PreventAutoPickupInExtraSlots.preventAddItem) ? Slots.GetEmptyQuickSlots() : 0);
					ExtraSlots.LogDebug($"Inventory.GetEmptySlots: {__result}, PreventAutoPickupInQuickSlots: {Player_AutoPickup_PreventAutoPickupInExtraSlots.preventAddItem}");
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "FindEmptySlot")]
		private static class Inventory_FindEmptySlot_FindAppropriateSlot
		{
			[HarmonyPriority(800)]
			private static void Prefix(Inventory __instance)
			{
				if (__instance == Slots.PlayerInventory)
				{
					__instance.m_height = Slots.InventoryHeightPlayer;
				}
			}

			[HarmonyPriority(800)]
			private static void Postfix(Inventory __instance, ref Vector2i __result)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: 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_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: 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_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
				if (__instance != Slots.PlayerInventory)
				{
					return;
				}
				__instance.m_height = Slots.InventoryHeightFull;
				if (__result == Slots.emptyPosition && InventoryGui.instance.m_craftTimer >= InventoryGui.instance.m_craftDuration)
				{
					ItemData craftUpgradeItem = InventoryGui.instance.m_craftUpgradeItem;
					if (craftUpgradeItem != null && Slots.TryFindFreeSlotForItem(craftUpgradeItem, out var slot))
					{
						__result = slot.GridPosition;
						ExtraSlots.LogDebug($"Inventory.FindEmptySlot for upgraded item {craftUpgradeItem.m_shared.m_name} {__result}");
					}
				}
				if (__result == Slots.emptyPosition && Slots.TryFindFreeEquipmentSlotForItem(Inventory_AddItem_ByName_FindAppropriateSlot.itemToFindSlot, out var slot2))
				{
					__result = slot2.GridPosition;
					ExtraSlots.LogDebug($"Inventory.FindEmptySlot free equipment slot for AddItem_ByName item {Inventory_AddItem_ByName_FindAppropriateSlot.itemToFindSlot.m_shared.m_name} {__result}");
				}
				if (__result == Slots.emptyPosition && Slots.TryFindFreeSlotForItem(Inventory_AddItem_ByName_FindAppropriateSlot.itemToFindSlot, out var slot3))
				{
					__result = slot3.GridPosition;
					ExtraSlots.LogDebug($"Inventory.FindEmptySlot free slot for AddItem_ByName item {Inventory_AddItem_ByName_FindAppropriateSlot.itemToFindSlot.m_shared.m_name} {__result}");
				}
				if (__result == Slots.emptyPosition && !Player_AutoPickup_PreventAutoPickupInExtraSlots.preventAddItem)
				{
					__result = Slots.FindEmptyQuickSlot();
					ExtraSlots.LogDebug($"Inventory.FindEmptySlot free quick slot {__result}");
				}
				if (__result == Slots.emptyPosition && Inventory_AddItem_ByName_FindAppropriateSlot.itemToFindSlot != null && Slots.TryMakeFreeSpaceInPlayerInventory(tryFindRegularInventorySlot: true, out var gridPos))
				{
					__result = gridPos;
					ExtraSlots.LogDebug($"Inventory.FindEmptySlot made free space for AddItem_ByName item {Inventory_AddItem_ByName_FindAppropriateSlot.itemToFindSlot.m_shared.m_name} {__result}");
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "HaveEmptySlot")]
		private static class Inventory_HaveEmptySlot_CheckRegularInventoryAndQuickSlots
		{
			[HarmonyPriority(800)]
			private static void Postfix(Inventory __instance, ref bool __result)
			{
				__result = __instance.GetEmptySlots() > 0;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
		public static class InventoryGui_OnSelectedItem_GetEquippedDragItem
		{
			public static bool Prefix(InventoryGui __instance, InventoryGrid grid, Vector2i pos)
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && !((Character)Player.m_localPlayer).IsTeleporting() && Object.op_Implicit((Object)(object)__instance.m_dragGo) && __instance.m_dragItem != null && __instance.m_dragInventory != null)
				{
					return PassDropItem("InventoryGui.OnSelectedItem", grid, __instance.m_dragInventory, __instance.m_dragItem, pos);
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "DropItem")]
		public static class InventoryGrid_DropItem_DropPrevention
		{
			public static bool Prefix(InventoryGrid __instance, Inventory fromInventory, ItemData item, Vector2i pos)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				return PassDropItem("InventoryGrid.DropItem", __instance, fromInventory, item, pos);
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		private static class Inventory_AddItem_ItemData_amount_x_y_TargetPositionRerouting
		{
			[HarmonyPriority(0)]
			private static void Prefix(Inventory __instance, ItemData item, ref int x, ref int y)
			{
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: 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_0226: Unknown result type (might be due to invalid IL or missing references)
				//IL_0270: Unknown result type (might be due to invalid IL or missing references)
				//IL_0283: Unknown result type (might be due to invalid IL or missing references)
				//IL_028b: Unknown result type (might be due to invalid IL or missing references)
				if (__instance != Slots.PlayerInventory)
				{
					if (Inventory_AddItem_OnLoad_FindAppropriateSlot.inCall && y >= __instance.m_height && item.m_customData.ContainsKey("ExtraSlotsEquippedSlot") && item.m_customData.ContainsKey("ExtraSlotsEquippedBy"))
					{
						ExtraSlots.LogDebug($"Inventory \"{__instance.m_name}\" loading: Inventory.AddItem X Y item {item.m_shared.m_name} adding at {x},{y} position insufficient height {__instance.m_height} -> {y + 1}");
						__instance.m_height = y + 1;
					}
				}
				else
				{
					if ((Inventory_AddItem_OnLoad_FindAppropriateSlot.inCall && Slots.CurrentPlayer.m_isLoading) || item == null)
					{
						return;
					}
					ItemData itemAt = __instance.GetItemAt(x, y);
					if (itemAt != null)
					{
						ExtraSlots.LogDebug($"Inventory.AddItem X Y item {item.m_shared.m_name} adding at {x},{y} position is taken {itemAt.m_shared.m_name}");
						return;
					}
					Slots.Slot slotInGrid = Slots.GetSlotInGrid(new Vector2i(x, y));
					if (slotInGrid != null && !slotInGrid.ItemFits(item))
					{
						ExtraSlots.LogDebug($"Inventory.AddItem X Y item {item.m_shared.m_name} adding at {x},{y} unfits slot {slotInGrid} {slotInGrid.GridPosition}");
						if (Slots.TryFindFreeSlotForItem(item, out var slot))
						{
							ExtraSlots.LogDebug($"Inventory.AddItem X Y Rerouted {item.m_shared.m_name} from {x},{y} to free slot {slot} {slot.GridPosition}");
							x = slot.GridPosition.x;
							y = slot.GridPosition.y;
						}
						if (Slots.TryMakeFreeSpaceInPlayerInventory(tryFindRegularInventorySlot: true, out var gridPos))
						{
							ExtraSlots.LogDebug($"Inventory.AddItem X Y Rerouted {item.m_shared.m_name} from {x},{y} to created free space {gridPos}");
							x = gridPos.x;
							y = gridPos.y;
						}
					}
				}
			}

			[HarmonyPriority(0)]
			private static void Postfix(Inventory __instance, ItemData item, int x, int y, int amount, ref bool __result)
			{
				//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_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: 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_01ee: 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_015a: 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)
				if (__instance == Slots.PlayerInventory && Inventory_AddItem_OnLoad_FindAppropriateSlot.inCall && !__result)
				{
					amount = Mathf.Min(amount, item.m_stack);
					ItemData val = item.Clone();
					val.m_stack = amount;
					ExtraSlots.LogMessage($"Item dissappearing prevention at Inventory.AddItem_OnLoad -> Inventory.AddItem_ItemData_amount_x_y: item {item.m_shared.m_name} at {x},{y} amount {amount}");
					Slots.Slot slot2;
					Vector2i gridPos;
					if (Slots.TryFindFreeEquipmentSlotForItem(val, out var slot))
					{
						val.m_gridPos = slot.GridPosition;
						ExtraSlots.LogDebug($"Inventory.AddItem_ItemData_amount_x_y found free equipment slot for item {val.m_shared.m_name}. Position rerouted {x},{y} -> {val.m_gridPos}");
					}
					else if (Slots.TryFindFreeSlotForItem(val, out slot2))
					{
						val.m_gridPos = slot2.GridPosition;
						ExtraSlots.LogDebug($"Inventory.AddItem_ItemData_amount_x_y found free slot for item {val.m_shared.m_name}. Position rerouted {x},{y} -> {val.m_gridPos}");
					}
					else if (Slots.TryMakeFreeSpaceInPlayerInventory(tryFindRegularInventorySlot: true, out gridPos))
					{
						val.m_gridPos = gridPos;
						ExtraSlots.LogDebug($"Inventory.AddItem_ItemData_amount_x_y made free space for item {val.m_shared.m_name}. Position rerouted {x},{y} -> {val.m_gridPos}");
					}
					else
					{
						val.m_gridPos = new Vector2i(Slots.InventoryWidth - 1, Slots.InventoryHeightFull - 1);
						ExtraSlots.LogDebug($"Inventory.AddItem_ItemData_amount_x_y item {val.m_shared.m_name} put in the last slot to find place later. Position rerouted {x},{y} -> {val.m_gridPos}");
					}
					__instance.m_inventory.Add(val);
					item.m_stack -= amount;
					__result = true;
					__instance.Changed();
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "CanAddItem", new Type[]
		{
			typeof(ItemData),
			typeof(int)
		})]
		private static class Inventory_CanAddItem_ItemData_TryFindAppropriateExtraSlot
		{
			private static readonly List<ItemData> tempItems = new List<ItemData>();

			[HarmonyPriority(800)]
			private static void Prefix(Inventory __instance)
			{
				if (__instance != Slots.PlayerInventory)
				{
					return;
				}
				__instance.m_height = Slots.InventoryHeightPlayer;
				tempItems.Clear();
				for (int num = __instance.m_inventory.Count - 1; num >= 0; num--)
				{
					ItemData item = __instance.m_inventory[num];
					if (API.IsItemInSlot(item))
					{
						tempItems.Add(item);
						__instance.m_inventory.RemoveAt(num);
					}
				}
				tempItems.Reverse();
			}

			[HarmonyPriority(800)]
			private static void Postfix(Inventory __instance, ItemData item, int stack, ref bool __result)
			{
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				if (__instance != Slots.PlayerInventory)
				{
					return;
				}
				__instance.m_height = Slots.InventoryHeightFull;
				if (tempItems.Count > 0)
				{
					__instance.m_inventory.AddRange(tempItems);
					tempItems.Clear();
				}
				if (!__result)
				{
					int num = __instance.FindFreeStackSpace(item.m_shared.m_name, (float)item.m_worldLevel);
					int num2 = __instance.GetEmptySlots() * item.m_shared.m_maxStackSize;
					int num3 = num + num2;
					if (num3 < 0)
					{
						num3 = int.MaxValue;
					}
					Slots.Slot slot;
					if (__result = num3 >= stack)
					{
						ExtraSlots.LogDebug($"Inventory.CanAddItem_ItemData_int item {item.m_shared.m_name} result {__result}, free stack space: {num}, free quick slot stack space: {num2}, have free stack space");
					}
					else if (stack <= item.m_shared.m_maxStackSize && !Player_AutoPickup_PreventAutoPickupInExtraSlots.preventAddItem && (__result = Slots.TryFindFreeSlotForItem(item, out slot)))
					{
						ExtraSlots.LogDebug($"Inventory.CanAddItem_ItemData_int item {item.m_shared.m_name} result {__result}, free stack space: {num}, free quick slot stack space: {num2}, no free stack space, free single slot found {slot} {slot.GridPosition}");
					}
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[] { typeof(ItemData) })]
		private static class Inventory_AddItem_ItemData_TryFindAppropriateExtraSlot
		{
			[HarmonyPriority(800)]
			private static void Postfix(Inventory __instance, ItemData item, bool __runOriginal, ref bool __result)
			{
				//IL_0053: 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)
				if (__instance == Slots.PlayerInventory && !__result && __runOriginal && !Player_AutoPickup_PreventAutoPickupInExtraSlots.preventAddItem && Slots.TryFindFreeSlotForItem(item, out var slot))
				{
					ExtraSlots.LogDebug($"Inventory.AddItem_Item item {item.m_shared.m_name} found free slot {slot} {slot.GridPosition}");
					item.m_gridPos = slot.GridPosition;
					__instance.m_inventory.Add(item);
					__instance.Changed();
					__result = true;
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(ItemData),
			typeof(Vector2i)
		})]
		private static class Inventory_AddItem_ItemData_pos_TargetPositionRerouting
		{
			[HarmonyPriority(800)]
			private static void Prefix(Inventory __instance, ItemData item, ref Vector2i pos)
			{
				//IL_004d: 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_0185: 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_01a2: 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_01d8: 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_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				if (__instance != Slots.PlayerInventory || item == null || __instance.GetItemAt(pos.x, pos.y) != null)
				{
					return;
				}
				Slots.Slot slotInGrid = Slots.GetSlotInGrid(pos);
				if (slotInGrid == null || slotInGrid.ItemFits(item))
				{
					return;
				}
				if (item.m_shared.m_maxStackSize > 1)
				{
					int num = (from itemInv in __instance.GetAllItems()
						where item.m_shared.m_name == itemInv.m_shared.m_name && item.m_quality == itemInv.m_quality && item.m_worldLevel == itemInv.m_worldLevel
						select itemInv).Sum((ItemData itemInv) => itemInv.m_shared.m_maxStackSize - itemInv.m_stack);
					if (num > item.m_stack)
					{
						return;
					}
					ExtraSlots.LogDebug($"Inventory.AddItem_Item_Vector2i item {item.m_shared.m_name}x{item.m_stack} adding at {pos} not enough free stack space {num}");
				}
				Vector2i gridPos;
				if (Slots.TryFindFreeSlotForItem(item, out var slot))
				{
					ExtraSlots.LogDebug($"Inventory.AddItem_Item_Vector2i Rerouted {item.m_shared.m_name} from {pos} to free slot {slot} {slot.GridPosition}");
					pos = slot.GridPosition;
				}
				else if (Slots.TryMakeFreeSpaceInPlayerInventory(tryFindRegularInventorySlot: true, out gridPos))
				{
					ExtraSlots.LogDebug($"Inventory.AddItem_Item_Vector2i Rerouted {item.m_shared.m_name} from {pos} to created free space {gridPos}");
					pos = gridPos;
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(string),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(long),
			typeof(string),
			typeof(Vector2i),
			typeof(bool)
		})]
		public static class Inventory_AddItem_ByName_FindAppropriateSlot
		{
			public static ItemData itemToFindSlot;

			[HarmonyPriority(800)]
			private static void Prefix(Inventory __instance, string name)
			{
				if (__instance == Slots.PlayerInventory)
				{
					ObjectDB instance = ObjectDB.instance;
					object obj;
					if (instance == null)
					{
						obj = null;
					}
					else
					{
						GameObject itemPrefab = instance.GetItemPrefab(name);
						obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
					}
					ItemDrop val = (ItemDrop)obj;
					if (!((Object)(object)val == (Object)null) && val.m_itemData.m_shared.m_maxStackSize <= 1)
					{
						itemToFindSlot = val.m_itemData;
					}
				}
			}

			[HarmonyPriority(800)]
			private static void Postfix()
			{
				itemToFindSlot = null;
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(string),
			typeof(int),
			typeof(float),
			typeof(Vector2i),
			typeof(bool),
			typeof(int),
			typeof(int),
			typeof(long),
			typeof(string),
			typeof(Dictionary<string, string>),
			typeof(int),
			typeof(bool)
		})]
		public static class Inventory_AddItem_OnLoad_FindAppropriateSlot
		{
			public static bool inCall;

			[HarmonyPriority(800)]
			private static void Prefix()
			{
				inCall = true;
			}

			[HarmonyPriority(800)]
			private static void Postfix()
			{
				inCall = false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "MoveInventoryToGrave")]
		private static class Inventory_MoveInventoryToGrave_UpdateGraveInventory
		{
			private static void Prefix(Inventory original)
			{
				if (original == Slots.PlayerInventory)
				{
					original.m_height = Slots.InventoryHeightFull;
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "UpdateTotalWeight")]
		public static class Inventory_UpdateTotalWeight_ApplyWeightFactor
		{
			public static bool inCall;

			private static void Prefix(Inventory __instance)
			{
				inCall = __instance == Slots.PlayerInventory;
			}

			private static void Postfix()
			{
				inCall = false;
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetWeight")]
		public static class ItemDrop_ItemData_GetWeight_UpdateTotalWeight_ApplyWeightFactor
		{
			private static void Postfix(ItemData __instance, ref float __result)
			{
				if (!Inventory_UpdateTotalWeight_ApplyWeightFactor.inCall)
				{
					return;
				}
				if (LightenedSlots.IsRowAffected(__instance.m_gridPos.y))
				{
					__result *= LightenedSlots.WeightFactor;
					return;
				}
				Slots.Slot itemSlot = Slots.GetItemSlot(__instance);
				if (itemSlot != null)
				{
					__result *= GetItemWeightFactor(itemSlot);
				}
			}
		}

		public static void UpdatePlayerInventorySize()
		{
			if (!((Object)(object)Slots.CurrentPlayer == (Object)null))
			{
				if (((Humanoid)Slots.CurrentPlayer).m_inventory.m_height != Slots.InventoryHeightFull)
				{
					ExtraSlots.LogInfo($"Player inventory height changed {((Humanoid)Slots.CurrentPlayer).m_inventory.m_height} -> {Slots.InventoryHeightFull}");
					((Humanoid)Slots.CurrentPlayer).m_inventory.m_height = Slots.InventoryHeightFull;
					((Humanoid)Slots.CurrentPlayer).m_inventory.Changed();
				}
				GameObject tombstone = Slots.CurrentPlayer.m_tombstone;
				Container val = ((tombstone != null) ? tombstone.GetComponent<Container>() : null);
				if (val != null)
				{
					val.m_height = Mathf.Max(val.m_height, Slots.InventoryHeightFull);
				}
				ItemsSlotsValidation.ValidateItems();
			}
		}

		public static float GetItemWeightFactor(Slots.Slot slot)
		{
			if (slot.IsEquipmentSlot)
			{
				return ExtraSlots.itemWeightFactorEquipmentSlots.Value;
			}
			if (slot.IsQuickSlot)
			{
				return ExtraSlots.itemWeightFactorQuickSlots.Value;
			}
			if (slot.IsAmmoSlot)
			{
				return ExtraSlots.itemWeightFactorAmmoSlots.Value;
			}
			if (slot.IsFoodSlot)
			{
				return ExtraSlots.itemWeightFactorFoodSlots.Value;
			}
			if (slot.IsMiscSlot)
			{
				return ExtraSlots.itemWeightFactorMiscSlots.Value;
			}
			return 1f;
		}

		private static bool PassDropItem(string source, InventoryGrid grid, Inventory fromInventory, ItemData item, Vector2i pos)
		{
			//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_0053: 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_008b: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: 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)
			//IL_0284: 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)
			if (item.m_gridPos == pos)
			{
				return true;
			}
			if (grid.m_inventory == Slots.PlayerInventory)
			{
				Slots.Slot itemSlot = Slots.GetItemSlot(item);
				if (itemSlot != null && itemSlot.IsEquipmentSlot && ((Humanoid)Player.m_localPlayer).IsItemEquiped(item))
				{
					Slots.Slot slotInGrid = Slots.GetSlotInGrid(pos);
					if (slotInGrid == null)
					{
						ExtraSlots.LogDebug($"{source} Prevented dropping equipped item {item.m_shared.m_name} {item.m_gridPos} into regular inventory {pos}");
						return false;
					}
					if (!Slots.IsSameSlotType(itemSlot, slotInGrid))
					{
						ExtraSlots.LogDebug($"{source} Prevented dropping equipped item {item.m_shared.m_name} {item.m_gridPos} into slot with other type {slotInGrid}");
						return false;
					}
				}
			}
			if (grid.m_inventory == Slots.PlayerInventory)
			{
				Slots.Slot slotInGrid2 = Slots.GetSlotInGrid(pos);
				if (slotInGrid2 != null)
				{
					if (!slotInGrid2.ItemFits(item))
					{
						ExtraSlots.LogDebug($"{source} Prevented dropping {item.m_shared.m_name} {item.m_gridPos} into unfit slot {slotInGrid2}");
						return false;
					}
					if (slotInGrid2.IsEquipmentSlot && slotInGrid2.Item != null && ((Humanoid)Player.m_localPlayer).IsItemEquiped(slotInGrid2.Item))
					{
						Slots.Slot itemSlot2 = Slots.GetItemSlot(item);
						if (itemSlot2 == null || !itemSlot2.IsEquipmentSlot)
						{
							ExtraSlots.LogDebug($"{source} Prevented dropping {item.m_shared.m_name} {item.m_gridPos} into occupied equipment slot {slotInGrid2}");
							return false;
						}
					}
				}
			}
			ItemData itemAt = grid.m_inventory.GetItemAt(pos.x, pos.y);
			if (itemAt != null && fromInventory == Slots.PlayerInventory)
			{
				Slots.Slot slotInGrid3 = Slots.GetSlotInGrid(item.m_gridPos);
				if (slotInGrid3 != null && !slotInGrid3.ItemFits(itemAt))
				{
					ExtraSlots.LogDebug($"{source} Prevented swapping {item.m_shared.m_name} {slotInGrid3} with unfit item {itemAt.m_shared.m_name} {pos}");
					return false;
				}
			}
			return true;
		}

		internal static void UpdateTotalWeight()
		{
			Inventory playerInventory = Slots.PlayerInventory;
			if (playerInventory != null)
			{
				playerInventory.UpdateTotalWeight();
			}
		}
	}
	internal static class InventoryPreventStackAll
	{
		[HarmonyPatch(typeof(Inventory), "StackAll")]
		private static class Inventory_StackAll_PreventStackingItemsFromSlots
		{
			public static bool inCall;

			[HarmonyPriority(800)]
			private static void Prefix(Inventory fromInventory)
			{
				if (inCall = fromInventory == Slots.PlayerInventory && !ZenBeehiveCompat.IsHoneyOpen)
				{
					RemoveItemsFromPlayerInventory();
				}
			}

			[HarmonyPriority(800)]
			private static void Postfix()
			{
				if (inCall)
				{
					BringItemsBack();
				}
				inCall = false;
			}

			private static void Finally()
			{
				Postfix();
			}
		}

		[HarmonyPatch(typeof(Inventory), "Changed")]
		private static class Inventory_Changed_BringItemsBack
		{
			[HarmonyPriority(800)]
			private static void Prefix(Inventory __instance)
			{
				if (__instance == Slots.PlayerInventory && Inventory_StackAll_PreventStackingItemsFromSlots.inCall)
				{
					BringItemsBack();
				}
			}
		}

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

		private static void RemoveItemsFromPlayerInventory()
		{
			for (int num = Slots.PlayerInventory.m_inventory.Count - 1; num >= 0; num--)
			{
				ItemData item = Slots.PlayerInventory.m_inventory[num];
				if (!AllowStackAll(item))
				{
					removedItems.Add(item);
					Slots.PlayerInventory.m_inventory.RemoveAt(num);
				}
			}
			ExtraSlots.LogDebug($"Removed {removedItems.Count} items from player inventory before StackAll");
		}

		private static void BringItemsBack()
		{
			if (removedItems.Count != 0)
			{
				Slots.PlayerInventory.m_inventory.AddRange(removedItems);
				ExtraSlots.LogDebug($"Returned {removedItems.Count} items to player inventory after StackAll");
				removedItems.Clear();
			}
		}

		private static bool AllowStackAll(ItemData item)
		{
			Slots.Slot itemSlot = Slots.GetItemSlot(item);
			if (itemSlot == null)
			{
				return !ExtraSlots.hotbarPreventStackAll.Value || !((Humanoid)Player.m_localPlayer).GetInventory().GetHotbar(false).Contains(item);
			}
			if (itemSlot.IsQuickSlot)
			{
				return !ExtraSlots.quickSlotsPreventStackAll.Value;
			}
			if (itemSlot.IsEquipmentSlot)
			{
				return !ExtraSlots.equipmentSlotsPreventStackAll.Value;
			}
			if (itemSlot.IsMiscSlot)
			{
				return !ExtraSlots.miscSlotsPreventStackAll.Value;
			}
			if (itemSlot.IsAmmoSlot)
			{
				return !ExtraSlots.ammoSlotsPreventStackAll.Value;
			}
			if (itemSlot.IsFoodSlot)
			{
				return !ExtraSlots.foodSlotsPreventStackAll.Value;
			}
			return true;
		}
	}
	public static class RectTransformExtensions
	{
		public enum ElementAnchor
		{
			TopLeft,
			Top,
			TopRight,
			Right,
			BottomRight,
			Bottom,
			BottomLeft,
			Left,
			Middle
		}

		public static void SetAnchor(this RectTransform rectTransform, ElementAnchor anchor)
		{
			//IL_003f: 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_0070: 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_00a1: 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_00d2: 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_0103: 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_0134: 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_0165: 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_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: 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)
			switch (anchor)
			{
			case ElementAnchor.TopLeft:
				rectTransform.anchorMin = new Vector2(0f, 1f);
				rectTransform.anchorMax = new Vector2(0f, 1f);
				break;
			case ElementAnchor.Top:
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				break;
			case ElementAnchor.TopRight:
				rectTransform.anchorMin = new Vector2(1f, 1f);
				rectTransform.anchorMax = new Vector2(1f, 1f);
				break;
			case ElementAnchor.Right:
				rectTransform.anchorMin = new Vector2(1f, 0.5f);
				rectTransform.anchorMax = new Vector2(1f, 0.5f);
				break;
			case ElementAnchor.BottomRight:
				rectTransform.anchorMin = new Vector2(1f, 0f);
				rectTransform.anchorMax = new Vector2(1f, 0f);
				break;
			case ElementAnchor.Bottom:
				rectTransform.anchorMin = new Vector2(0.5f, 0f);
				rectTransform.anchorMax = new Vector2(0.5f, 0f);
				break;
			case ElementAnchor.BottomLeft:
				rectTransform.anchorMin = new Vector2(0f, 0f);
				rectTransform.anchorMax = new Vector2(0f, 0f);
				break;
			case ElementAnchor.Left:
				rectTransform.anchorMin = new Vector2(0f, 0.5f);
				rectTransform.anchorMax = new Vector2(0f, 0.5f);
				break;
			case ElementAnchor.Middle:
				rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
				rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
				break;
			default:
				throw new ArgumentOutOfRangeException("anchor", anchor, null);
			}
		}
	}
	public static class TombStoneInteraction
	{
		[HarmonyPatch(typeof(TombStone), "OnTakeAllSuccess")]
		private static class TombStone_OnTakeAllSuccess_AutoEquip
		{
			private static void Postfix(TombStone __instance)
			{
				if (Slots.PlayerInventory != null)
				{
					FloatingTerrain val = default(FloatingTerrain);
					if (Player.m_enableAutoPickup && (Object)(object)((Component)((Component)__instance.m_body).transform.root).gameObject != (Object)(object)((Component)__instance).gameObject && ((Component)__instance).TryGetComponent<FloatingTerrain>(ref val))
					{
						Rigidbody body = __instance.m_body;
						ExtraSlots.LogDebug($"Destroyed tombstone component {((body != null) ? ((Component)body).gameObject : null)} to prevent NullReferenceException on AutoPickup");
						val.m_lastHeightmap = null;
						Rigidbody body2 = __instance.m_body;
						Object.Destroy((Object)(object)((body2 != null) ? ((Component)body2).gameObject : null));
					}
					Player currentPlayer = Slots.CurrentPlayer;
					if (currentPlayer != null)
					{
						((MonoBehaviour)currentPlayer).StartCoroutine(AutoEquipItemsOnTombstoneTakeAll());
					}
				}
			}
		}

		[HarmonyPatch(typeof(Container), "Awake")]
		private static class Container_Awake_TombstoneContainerHeightAdjustment
		{
			private static void Prefix(Container __instance)
			{
				if (__instance.m_name == "Grave" || Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<TombStone>()))
				{
					int targetInventoryHeight = Slots.GetTargetInventoryHeight(Slots.InventorySizeFull, __instance.m_width);
					if (targetInventoryHeight > __instance.m_height)
					{
						ExtraSlots.LogDebug($"TombStone Container Awake height {__instance.m_height} -> {targetInventoryHeight}");
						__instance.m_height = targetInventoryHeight;
					}
					else
					{
						ExtraSlots.LogDebug($"TombStone Container Awake current height {__instance.m_height}, target height {targetInventoryHeight}");
					}
				}
			}

			private static void Postfix(Container __instance)
			{
				ZNetView nview = __instance.m_nview;
				if (nview != null && nview.IsValid() && __instance.m_nview.IsOwner() && ((Component)__instance).GetComponent<TombStone>() != null && __instance.m_height > 4)
				{
					string name = ((object)__instance).GetType().Name;
					__instance.m_nview.GetZDO().Set("HasFields", true);
					__instance.m_nview.GetZDO().Set(StringExtensionMethods.GetStableHashCode("HasFields" + name), true);
					__instance.m_nview.GetZDO().Set(name + ".m_height", Slots.InventoryHeightFull);
					ExtraSlots.LogDebug(string.Format("TombStone Container Awake Postfix height {0} saved with {1}", Slots.InventoryHeightFull, "HasFields"));
				}
			}
		}

		[HarmonyPatch(typeof(TombStone), "Interact")]
		internal static class TombStone_Interact_AdjustHeightAndStopAutoPickup
		{
			[HarmonyPriority(800)]
			private static void Prefix(TombStone __instance, bool hold)
			{
				if (!hold)
				{
					int targetInventoryHeight = Slots.GetTargetInventoryHeight(Slots.InventorySizeFull, __instance.m_container.m_width);
					if (targetInventoryHeight > __instance.m_container.m_height)
					{
						ExtraSlots.LogDebug($"TombStone Interact height {__instance.m_container.m_height} -> {targetInventoryHeight}. Inventory reloaded.");
						__instance.m_container.m_height = targetInventoryHeight;
						__instance.m_container.m_inventory.m_height = targetInventoryHeight;
						__instance.m_container.m_lastRevision = 0u;
						__instance.m_container.m_lastDataString = "";
						__instance.m_container.Load();
					}
				}
			}
		}

		[HarmonyPatch(typeof(TombStone), "EasyFitInInventory")]
		private static class TombStone_EasyFitInInventory_HeightAdjustment
		{
			private static float GetDynamicWeightChange(StatusEffect se)
			{
				float result = 0f;
				se.ModifyMaxCarryWeight(0f, ref result);
				return result;
			}

			private static void Prefix(TombStone __instance, Player player, ref float __state)
			{
				if (!Slots.IsValidPlayer((Character)(object)player))
				{
					return;
				}
				StatusEffect lootStatusEffect = __instance.m_lootStatusEffect;
				__state = ((SE_Stats)(((lootStatusEffect is SE_Stats) ? lootStatusEffect : null)?)).m_addMaxCarryWeight ?? 0f;
				if (ExtraSlots.slotsTombstoneAutoEquipCarryWeightItemsEnabled.Value || ExtraSlots.slotsTombstoneAutoEquipEnabled.Value)
				{
					__state += __instance.m_container.GetInventory().GetAllItems().Where(delegate(ItemData item)
					{
						//IL_0018: Unknown result type (might be due to invalid IL or missing references)
						int result;
						if (item != null)
						{
							StatusEffect equipStatusEffect = item.m_shared.m_equipStatusEffect;
							SE_Stats val = (SE_Stats)(object)((equipStatusEffect is SE_Stats) ? equipStatusEffect : null);
							if (val != null)
							{
								Slots.Slot slotInGrid = Slots.GetSlotInGrid(item.m_gridPos);
								if (slotInGrid != null)
								{
									result = (slotInGrid.IsEquipmentSlot ? 1 : 0);
									goto IL_002f;
								}
							}
						}
						result = 0;
						goto IL_002f;
						IL_002f:
						return (byte)result != 0;
					})
						.Sum((ItemData item) => GetDynamicWeightChange(item.m_shared.m_equipStatusEffect));
				}
				Player localPlayer = Player.m_localPlayer;
				localPlayer.m_maxCarryWeight += __state;
			}

			private static void Postfix(TombStone __instance, Player player, float __state, ref bool __result)
			{
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				if (!Slots.IsValidPlayer((Character)(object)player))
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				localPlayer.m_maxCarryWeight -= __state;
				if (__result || __instance.m_container.GetInventory().NrOfItems() > Slots.InventorySizeActive)
				{
					return;
				}
				int num = 0;
				takenSlots.Clear();
				foreach (ItemData item in __instance.m_container.GetInventory().GetAllItemsInGridOrder())
				{
					if (item.m_gridPos.y < Slots.InventoryHeightPlayer)
					{
						num++;
						continue;
					}
					Slots.Slot slotInGrid = Slots.GetSlotInGrid(item.m_gridPos);
					if (slotInGrid == null)
					{
						num++;
						continue;
					}
					if (takenSlots.Contains(slotInGrid))
					{
						num++;
						continue;
					}
					takenSlots.Add(slotInGrid);
					if (slotInGrid.IsQuickSlot)
					{
						num++;
					}
					else if (!slotInGrid.ItemFits(item))
					{
						num++;
					}
				}
				__result = num <= Slots.PlayerInventory.GetEmptySlots() && ((Humanoid)player).GetInventory().GetTotalWeight() + __instance.m_container.GetInventory().GetTotalWeight() < player.GetMaxCarryWeight() + __state;
			}
		}

		[HarmonyPatch(typeof(Character), "CheckDeath")]
		private static class Character_CheckDeath_OnDeathWrapping
		{
			[HarmonyPriority(800)]
			private static void Prefix(Character __instance)
			{
				if (Slots.IsValidPlayer(__instance) && !__instance.IsDead() && __instance.GetHealth() <= 0f)
				{
					OnDeathPrefix((Player)(object)((__instance is Player) ? __instance : null));
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnDeath")]
		private static class Player_OnDeath_RestoreItemsToKeep
		{
			private static void Postfix(Player __instance)
			{
				if (Slots.IsValidPlayer((Character)(object)__instance))
				{
					OnDeathPostfix(__instance);
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass21_0
		{
			public float timeoutTime;

			internal bool <AutoEquipItemsOnTombstoneTakeAll>b__0()
			{
				Player currentPlayer = Slots.CurrentPlayer;
				int result;
				if (currentPlayer != null)
				{
					SEMan sEMan = ((Character)currentPlayer).GetSEMan();
					if (((sEMan != null) ? new bool?(sEMan.HaveStatusEffect(AfterdeathGhost)) : null) == false)
					{
						Player currentPlayer2 = Slots.CurrentPlayer;
						if (currentPlayer2 != null && !((Character)currentPlayer2).IsDead())
						{
							result = 1;
							goto IL_006f;
						}
					}
				}
				result = ((Time.time >= timeoutTime) ? 1 : 0);
				goto IL_006f;
				IL_006f:
				return (byte)result != 0;
			}
		}

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

			private object <>2__current;

			private <>c__DisplayClass21_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass21_0();
					<>8__1.timeoutTime = Time.time + 5f;
					<>2__current = (object)new WaitUntil((Func<bool>)delegate
					{
						Player currentPlayer = Slots.CurrentPlayer;
						int result;
						if (currentPlayer != null)
						{
							SEMan sEMan = ((Character)currentPlayer).GetSEMan();
							if (((sEMan != null) ? new bool?(sEMan.HaveStatusEffect(AfterdeathGhost)) : null) == false)
							{
								Player currentPlayer2 = Slots.CurrentPlayer;
								if (currentPlayer2 != null && !((Character)currentPlayer2).IsDead())
								{
									result = 1;
									goto IL_006f;
								}
							}
						}
						result = ((Time.time >= <>8__1.timeoutTime) ? 1 : 0);
						goto IL_006f;
						IL_006f:
						return (byte)result != 0;
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = EquipItemsInSlots();
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = EquipWeaponShield();
					<>1__state = 4;
					return true;
				case 4:
					<>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();
			}
		}

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

			private object <>2__current;

			private List<Slots.Slot>.Enumerator <>s__1;

			private Slots.Slot <slot>5__2;

			private ItemData <item>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = default(List<Slots.Slot>.Enumerator);
				<slot>5__2 = null;
				<item>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Slots.ClearCachedItems();
						<>s__1 = Slots.GetEquipmentSlots(onlyActive: false).ToList().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<item>5__3 = null;
						<slot>5__2 = null;
						break;
					}
					if (<>s__1.MoveNext())
					{
						<slot>5__2 = <>s__1.Current;
						<item>5__3 = <slot>5__2.Item;
						if (IsItemToEquip(<item>5__3))
						{
							TryEquipItem(<item>5__3);
						}
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__1 = default(List<Slots.Slot>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__1).Dispose();
			}

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

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

			private object <>2__current;

			private List<ItemData> <items>5__1;

			private List<ItemData>.Enumerator <>s__2;

			private ItemData <item>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<items>5__1 = null;
				<>s__2 = default(List<ItemData>.Enumerator);
				<item>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<items>5__1 = Slots.PlayerInventory.GetAllItems().Where(IsWeaponShieldToEquip).ToList();
						<>s__2 = <items>5__1.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<item>5__3 = null;
						break;
					}
					if (<>s__2.MoveNext())
					{
						<item>5__3 = <>s__2.Current;
						TryEquipItem(<item>5__3);
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__2 = default(List<ItemData>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__2).Dispose();
			}

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

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

		private static readonly HashSet<Slots.Slot> takenSlots = new HashSet<Slots.Slot>();

		public static List<string> autoEquipItemList = new List<string>();

		public static List<string> autoEquipWhiteList = new List<string>();

		public static List<string> autoEquipBlackList = new List<string>();

		public static List<string> keepItemList = new List<string>();

		public static List<string> keepItemWhiteList = new List<string>();

		public static List<string> keepItemBlackList = new List<string>();

		public static readonly int AfterdeathGhost = StringExtensionMethods.GetStableHashCode("Afterdeath Ghost");

		public static void UpdateItemLists()
		{
			UpdateItemList(autoEquipItemList, ExtraSlots.slotsTombstoneAutoEquipItemList);
			UpdateItemList(autoEquipWhiteList, ExtraSlots.slotsTombstoneAutoEquipWhiteList);
			UpdateItemList(autoEquipBlackList, ExtraSlots.slotsTombstoneAutoEquipBlackList);
			UpdateItemList(keepItemList, ExtraSlots.keepOnDeathItemList);
			UpdateItemList(keepItemWhiteList, ExtraSlots.keepOnDeathWhiteList);
			UpdateItemList(keepItemBlackList, ExtraSlots.keepOnDeathBlackList);
		}

		private static void UpdateItemList(List<string> list, ConfigEntry<string> config)
		{
			list.Clear();
			CollectionExtensions.Do<string>(from p in config.Value.Split(',')
				select p.GetItemName() into p
				where !string.IsNullOrWhiteSpace(p)
				select p, (Action<string>)list.Add);
		}

		internal static bool ItemFitLists(ItemData item, List<string> itemList, List<string> whiteList, List<string> blackList)
		{
			if (item == null)
			{
				return true;
			}
			if (itemList.Contains(item.m_shared.m_name.ToLower()))
			{
				return true;
			}
			if (whiteList.Contains(item.m_shared.m_name.ToLower()))
			{
				return true;
			}
			if (whiteList.Count > 0)
			{
				return false;
			}
			if (blackList.Contains(item.m_shared.m_name.ToLower()))
			{
				return false;
			}
			return true;
		}

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

		private static bool IsItemToEquip(ItemData item)
		{
			if (ExtraSlots.slotsTombstoneAutoEquipCarryWeightItemsEnabled.Value && item != null)
			{
				StatusEffect equipStatusEffect = item.m_shared.m_equipStatusEffect;
				SE_Stats val = (SE_Stats)(object)((equipStatusEffect is SE_Stats) ? equipStatusEffect : null);
				if (val != null && val.m_addMaxCarryWeight > 0f)
				{
					return true;
				}
			}
			if (!ExtraSlots.slotsTombstoneAutoEquipEnabled.Value)
			{
				return false;
			}
			return ItemFitLists(item, autoEquipItemList, autoEquipWhiteList, autoEquipBlackList);
		}

		private static bool IsWeaponShieldToEquip(ItemData item)
		{
			string value;
			return ExtraSlots.slotsTombstoneAutoEquipWeaponShield.Value && item.m_customData.TryGetValue("ExtraSlotsEquippedWeaponShield", out value) && value == Game.instance.GetPlayerProfile().GetPlayerID().ToString();
		}

		private static void TryEquipItem(ItemData item)
		{
			if (item != null && !((Humanoid)Slots.CurrentPlayer).IsItemEquiped(item) && ((Humanoid)Slots.CurrentPlayer).EquipItem(item, true))
			{
				ExtraSlots.LogDebug("Item " + item.m_shared.m_name + " was equipped on tombstone interaction");
			}
		}

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

		public static void OnDeathPrefix(Player player)
		{
			itemsToKeep.Clear();
			CollectionExtensions.DoIf<Slots.Slot>((IEnumerable<Slots.Slot>)Slots.slots, (Func<Slots.Slot, bool>)IsSlotToKeep, (Action<Slots.Slot>)KeepItem);
			Slots.ClearCachedItems();
			Slots.SaveLastEquippedSlotsToItems();
			Slots.SaveLastEquippedWeaponShieldToItems(player);
			void KeepItem(Slots.Slot slot)
			{
				ItemData item = slot.Item;
				itemsToKeep.Add(item);
				((Humanoid)player).GetInventory().m_inventory.Remove(item);
				ExtraSlots.LogDebug($"Character.CheckDeath.Prefix: On death drop prevented for item {item.m_shared.m_name} from slot {slot}. Item temporary removed from player inventory.");
			}
		}

		public static bool IsSlotToKeep(Slots.Slot slot)
		{
			ItemData item = slot.Item;
			if (item == null)
			{
				return false;
			}
			if ((!slot.IsEquipmentSlot || !ExtraSlots.keepOnDeathEquipmentSlots.Value) && (!slot.IsQuickSlot || !ExtraSlots.keepOnDeathQuickSlots.Value) && (!slot.IsAmmoSlot || !ExtraSlots.keepOnDeathAmmoSlots.Value) && (!slot.IsFoodSlot || !ExtraSlots.keepOnDeathFoodSlots.Value) && (!slot.IsMiscSlot || !ExtraSlots.keepOnDeathMiscSlots.Value) && !keepItemList.Contains(item.m_shared.m_name.ToLower()))
			{
				return false;
			}
			return ItemFitLists(item, keepItemList, keepItemWhiteList, keepItemBlackList);
		}

		public static void OnDeathPostfix(Player player)
		{
			if (itemsToKeep.Count != 0)
			{
				((Humanoid)player).GetInventory().m_inventory.AddRange(itemsToKeep);
				ExtraSlots.LogDebug($"Player.OnDeath.Postfix: {itemsToKeep.Count} item(s) returned to player inventory after preventing on death drop.");
				itemsToKeep.Clear();
			}
		}

		[IteratorStateMachine(typeof(<AutoEquipItemsOnTombstoneTakeAll>d__21))]
		public static IEnumerator AutoEquipItemsOnTombstoneTakeAll()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AutoEquipItemsOnTombstoneTakeAll>d__21(0);
		}
	}
	[Serializable]
	public class HumanoidExtraUtilitySlots
	{
		public ItemData utility1;

		public ItemData utility2;

		public ItemData utility3;

		public ItemData utility4;

		[NonSerialized]
		public List<ItemData> equippedItemsCache;

		[NonSerialized]
		public bool equippedItemsDirty = true;

		[NonSerialized]
		public int equippedItemsCachedActiveSlots = -1;
	}
	public static class HumanoidExtension
	{
		private static readonly ConditionalWeakTable<Humanoid, HumanoidExtraUtilitySlots> data = new ConditionalWeakTable<Humanoid, HumanoidExtraUtilitySlots>();

		public static HumanoidExtraUtilitySlots GetExtraUtilityData(this Humanoid humanoid)
		{
			return data.GetOrCreateValue(humanoid);
		}

		public static ItemData GetExtraUtility(this Humanoid humanoid, int index)
		{
			if (1 == 0)
			{
			}
			ItemData result = (ItemData)(index switch
			{
				0 => humanoid.GetExtraUtilityData().utility1, 
				1 => humanoid.GetExtraUtilityData().utility2, 
				2 => humanoid.GetExtraUtilityData().utility3, 
				3 => humanoid.GetExtraUtilityData().utility4, 
				_ => null, 
			});
			if (1 == 0)
			{
			}
			return result;
		}

		public static ItemData SetExtraUtility(this Humanoid humanoid, int index, ItemData item)
		{
			if ((Object)(object)humanoid == (Object)null)
			{
				return null;
			}
			if (index < 0 || index > 3)
			{
				return null;
			}
			HumanoidExtraUtilitySlots extraUtilityData = humanoid.GetExtraUtilityData();
			if (1 == 0)
			{
			}
			ItemData val = (ItemData)(index switch
			{
				0 => extraUtilityData.utility1, 
				1 => extraUtilityData.utility2, 
				2 => extraUtilityData.utility3, 
				3 => extraUtilityData.utility4, 
				_ => null, 
			});
			if (1 == 0)
			{
			}
			ItemData val2 = val;
			if (val2 == item)
			{
				return item;
			}
			switch (index)
			{
			case 0:
				extraUtilityData.utility1 = item;
				break;
			case 1:
				extraUtilityData.utility2 = item;
				break;
			case 2:
				extraUtilityData.utility3 = item;
				break;
			case 3:
				extraUtilityData.utility4 = item;
				break;
			}
			extraUtilityData.equippedItemsDirty = true;
			return item;
		}
	}
	[Serializable]
	public class VisEquipmentCustomItemState
	{
		public string m_item = "";

		public List<GameObject> m_instances;

		public int m_hash = 0;
	}
	[Serializable]
	public class VisEquipmentCustomItem
	{
		public VisEquipmentCustomItemState customItem1 = new VisEquipmentCustomItemState();

		public VisEquipmentCustomItemState customItem2 = new VisEquipmentCustomItemState();

		public VisEquipmentCustomItemState customItem3 = new VisEquipmentCustomItemState();

		public VisEquipmentCustomItemState customItem4 = new VisEquipmentCustomItemState();
	}
	public static class VisEquipmentExtension
	{
		[HarmonyPatch(typeof(VisEquipment), "UpdateEquipmentVisuals")]
		public static class VisEquipment_UpdateEquipmentVisuals_CustomItemType
		{
			public static VisEquipment visEq;

			public static bool updateLodGroup;

			private static void Prefix(VisEquipment __instance)
			{
				ZNetView nview = __instance.m_nview;
				ZDO val = ((nview != null) ? nview.GetZDO() : null);
				updateLodGroup = false;
				for (int i = 0; i < 4; i++)
				{
					int hash = 0;
					if (val != null)
					{
						hash = val.GetInt(customItemStateZdoHash[i], 0);
					}
					else
					{
						VisEquipmentCustomItemState customItemState = __instance.GetCustomItemState(i);
						if (!string.IsNullOrEmpty(customItemState.m_item))
						{
							hash = StringExtensionMethods.GetStableHashCode(customItemState.m_item);
						}
					}
					if (__instance.SetCustomItemEquipped(hash, i))
					{
						updateLodGroup = true;
					}
				}
				visEq = __instance;
			}

			private static void Postfix(VisEquipment __instance)
			{
				if (updateLodGroup)
				{
					__instance.UpdateLodgroup();
				}
				visEq = null;
				updateLodGroup = false;
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "UpdateLodgroup")]
		public static class VisEquipment_UpdateLodgroup_CustomItemType
		{
			private static void Finalizer(VisEquipment __instance)
			{
				if ((Object)(object)__instance == (Object)(object)VisEquipment_UpdateEquipmentVisuals_CustomItemType.visEq)
				{
					VisEquipment_UpdateEquipmentVisuals_CustomItemType.updateLodGroup = false;
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "SetupVisEquipment")]
		public static class Humanoid_SetupVisEquipment_CustomItemType
		{
			private static void Postfix(Humanoid __instance, VisEquipment visEq)
			{
				for (int i = 0; i < 4; i++)
				{
					ItemData extraUtility = __instance.GetExtraUtility(i);
					visEq.SetCustomItemState(i, (ExtraSlots.showExtraUtilityItems.Value && extraUtility != null && (Object)(object)extraUtility.m_dropPrefab != (Object)null) ? ((Object)extraUtility.m_dropPrefab).name : "");
				}
			}
		}

		private static readonly List<int> customItemStateZdoHash = new List<int>
		{
			StringExtensionMethods.GetStableHashCode("ExtraSlots_ExtraUtility_1"),
			StringExtensionMethods.GetStableHashCode("ExtraSlots_ExtraUtility_2"),
			StringExtensionMethods.GetStableHashCode("ExtraSlots_ExtraUtility_3"),
			StringExtensionMethods.GetStableHashCode("ExtraSlots_ExtraUtility_4")
		};

		private static readonly ConditionalWeakTable<VisEquipment, VisEquipmentCustomItem> data = new ConditionalWeakTable<VisEquipment, VisEquipmentCustomItem>();

		public static VisEquipmentCustomItem GetCustomItemData(this VisEquipment visEquipment)
		{
			return data.GetOrCreateValue(visEquipment);
		}

		public static VisEquipmentCustomItemState GetCustomItemState(this VisEquipment humanoid, int index)
		{
			if (1 == 0)
			{
			}
			VisEquipmentCustomItemState result = index switch
			{
				0 => humanoid.GetCustomItemData().customItem1, 
				1 => humanoid.GetCustomItemData().customItem2, 
				2 => humanoid.GetCustomItemData().customItem3, 
				3 => humanoid.GetCustomItemData().customItem4, 
				_ => null, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static void SetCustomItemState(this VisEquipment visEquipment, int index, string name)
		{
			VisEquipmentCustomItemState customItemState = visEquipment.GetCustomItemState(index);
			if (customItemState.m_item != name)
			{
				customItemState.m_item = name;
				if (visEquipment.m_nview.IsValid() && visEquipment.m_nview.IsOwner())
				{
					visEquipment.m_nview.GetZDO().Set(customItemStateZdoHash[index], (!string.IsNullOrEmpty(name)) ? StringExtensionMethods.GetStableHashCode(name) : 0, false);
				}
			}
		}

		public static bool SetCustomItemEquipped(this VisEquipment visEquipment, int hash, int index)
		{
			VisEquipmentCustomItemState customItemState = visEquipment.GetCustomItemState(index);
			if (customItemState.m_hash == hash)
			{
				return false;
			}
			if (customItemState.m_instances != null)
			{
				foreach (GameObject instance in customItemState.m_instances)
				{
					if (Object.op_Implicit((Object)(object)visEquipment.m_lodGroup))
					{
						Utils.RemoveFromLodgroup(visEquipment.m_lodGroup, instance);
					}
					Object.Destroy((Object)(object)instance);
				}
				customItemState.m_instances = null;
			}
			customItemState.m_hash = hash;
			if (hash != 0)
			{
				customItemState.m_instances = visEquipment.AttachArmor(hash, -1);
			}
			return true;
		}
	}
	public static class ExtraUtilitySlots
	{
		public static class ExtraUtilityPatches
		{
			[HarmonyPatch(typeof(Humanoid), "UpdateEquipmentStatusEffects")]
			private static class Humanoid_UpdateEquipmentStatusEffects_ExtraUtility
			{
				private static void Prefix(Humanoid __instance)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance))
					{
						return;
					}
					tempEffects.Clear();
					foreach (ItemData equippedItem in GetEquippedItems(__instance))
					{
						if (Object.op_Implicit((Object)(object)equippedItem.m_shared.m_equipStatusEffect))
						{
							tempEffects.Add(equippedItem.m_shared.m_equipStatusEffect);
						}
						if (__instance.HaveSetEffect(equippedItem))
						{
							tempEffects.Add(equippedItem.m_shared.m_setStatusEffect);
						}
					}
				}

				private static void Postfix(Humanoid __instance)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance))
					{
						tempEffects.Clear();
						return;
					}
					foreach (StatusEffect tempEffect in tempEffects)
					{
						if ((Object)(object)tempEffect != (Object)null && !__instance.m_equipmentStatusEffects.Contains(tempEffect))
						{
							((Character)__instance).m_seman.AddStatusEffect(tempEffect, false, 0, 0f);
						}
					}
					__instance.m_equipmentStatusEffects.UnionWith(tempEffects);
					tempEffects.Clear();
				}
			}

			[HarmonyPatch(typeof(SEMan), "RemoveStatusEffect", new Type[]
			{
				typeof(int),
				typeof(bool)
			})]
			private static class SEMan_RemoveStatusEffect_ExtraUtilityPreventRemoval
			{
				private static void Prefix(SEMan __instance, ref int nameHash)
				{
					Player currentPlayer = Slots.CurrentPlayer;
					if (__instance != ((currentPlayer != null) ? ((Character)currentPlayer).GetSEMan() : null) || tempEffects.Count == 0)
					{
						return;
					}
					foreach (StatusEffect tempEffect in tempEffects)
					{
						if ((Object)(object)tempEffect != (Object)null && tempEffect.NameHash() == nameHash)
						{
							nameHash = 0;
						}
					}
				}
			}

			[HarmonyPatch(typeof(Humanoid), "GetEquipmentWeight")]
			private static class Humanoid_GetEquipmentWeight_ExtraUtility
			{
				private static void Postfix(Humanoid __instance, ref float __result)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance))
					{
						return;
					}
					foreach (ItemData equippedItem in GetEquippedItems(__instance))
					{
						__result += equippedItem.m_shared.m_weight;
					}
				}
			}

			[HarmonyPatch(typeof(Humanoid), "EquipItem")]
			private static class Humanoid_EquipItem_ExtraUtility
			{
				private static readonly ItemType tempType = (ItemType)727;

				private static void Prefix(Humanoid __instance, ItemData item, ref int __state)
				{
					//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_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_00a5: 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)
					if (Slots.IsValidPlayer((Character)(object)__instance) && item != null && Slots.IsUtilitySlotItem(item) && !Slots.IsCustomSlotItem(item) && __instance.m_utilityItem != null && !IsItemEquipped(item) && (__state = GetSlotForItem(item)) != -1)
					{
						item.m_shared.m_itemType = tempType;
						if (Object.op_Implicit((Object)(object)__instance.m_visEquipment) && __instance.m_visEquipment.m_isPlayer)
						{
							item.m_shared.m_equipEffect.Create(((Component)__instance).transform.position + Vector3.up, ((Component)__instance).transform.rotation, (Transform)null, 1f, -1);
						}
					}
				}

				[HarmonyPriority(800)]
				private static void Postfix(Humanoid __instance, ItemData item, bool triggerEquipEffects, int __state, ref bool __result)
				{
					//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_003a: Unknown result type (might be due to invalid IL or missing references)
					if (Slots.IsValidPlayer((Character)(object)__instance) && item != null && item.m_shared.m_itemType == tempType && __state != -1)
					{
						item.m_shared.m_itemType = (ItemType)18;
						ItemData extraUtility = __instance.GetExtraUtility(__state);
						if (extraUtility != null)
						{
							__instance.UnequipItem(extraUtility, triggerEquipEffects);
						}
						__instance.SetExtraUtility(__state, item);
						if (__instance.IsItemEquiped(item))
						{
							item.m_equipped = true;
							__result = true;
						}
						__instance.SetupEquipment();
					}
				}
			}

			[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
			public static class Humanoid_UnequipItem_ExtraUtility
			{
				[HarmonyPriority(800)]
				private static void Postfix(Humanoid __instance, ItemData item)
				{
					if (item != null)
					{
						int utilityItemIndex = GetUtilityItemIndex(__instance, item);
						if (utilityItemIndex != -1)
						{
							__instance.SetExtraUtility(utilityItemIndex, null);
							__instance.SetupEquipment();
						}
					}
				}
			}

			[HarmonyPatch(typeof(Humanoid), "UnequipAllItems")]
			public static class Humanoid_UnequipAllItems_ExtraUtility
			{
				[HarmonyPriority(800)]
				private static void Postfix(Humanoid __instance)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance))
					{
						return;
					}
					foreach (ItemData equippedItem in GetEquippedItems(__instance))
					{
						__instance.UnequipItem(equippedItem, false);
					}
				}
			}

			[HarmonyPatch(typeof(Humanoid), "IsItemEquiped")]
			private static class Humanoid_IsItemEquiped_ExtraUtility
			{
				private static void Postfix(Humanoid __instance, ItemData item, ref bool __result)
				{
					if (Slots.IsValidPlayer((Character)(object)__instance))
					{
						__result = __result || GetUtilityItemIndex(__instance, item) != -1;
					}
				}
			}

			[HarmonyPatch(typeof(Player), "UnequipDeathDropItems")]
			private static class Player_UnequipDeathDropItems_ExtraUtility
			{
				private static void Prefix(Player __instance)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance))
					{
						return;
					}
					bool flag = false;
					for (int i = 0; i < ActiveSlots; i++)
					{
						ItemData extraUtility = ((Humanoid)(object)__instance).GetExtraUtility(i);
						if (extraUtility != null)
						{
							extraUtility.m_equipped = false;
							((Humanoid)(object)__instance).SetExtraUtility(i, null);
							flag = true;
						}
					}
					if (flag)
					{
						((Humanoid)__instance).SetupEquipment();
					}
				}
			}

			[HarmonyPatch(typeof(Player), "GetEquipmentEitrRegenModifier")]
			private static class Player_GetEquipmentEitrRegenModifier_ExtraUtility
			{
				private static void Postfix(Player __instance, ref float __result)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance))
					{
						return;
					}
					foreach (ItemData equippedItem in GetEquippedItems((Humanoid)(object)__instance))
					{
						__result += equippedItem.m_shared.m_eitrRegenModifier;
					}
				}
			}

			[HarmonyPatch(typeof(Humanoid), "UpdateEquipment")]
			private static class Humanoid_UpdateEquipment_ExtraUtilityDurabilityDrain
			{
				private static void Postfix(Humanoid __instance, float dt)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance))
					{
						return;
					}
					foreach (ItemData equippedItem in GetEquippedItems(__instance))
					{
						if (equippedItem.m_shared.m_useDurability)
						{
							__instance.DrainEquipedItemDurability(equippedItem, dt);
						}
					}
				}
			}

			[HarmonyPatch(typeof(Player), "ApplyArmorDamageMods")]
			private static class Player_ApplyArmorDamageMods_ExtraUtility
			{
				private static void Postfix(Player __instance, ref DamageModifiers mods)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance))
					{
						return;
					}
					foreach (ItemData equippedItem in GetEquippedItems((Humanoid)(object)__instance))
					{
						((DamageModifiers)(ref mods)).Apply(equippedItem.m_shared.m_damageModifiers);
					}
				}
			}

			[HarmonyPatch(typeof(Player), "UpdateModifiers")]
			private static class Player_UpdateModifiers_ExtraUtility
			{
				private static void Postfix(Player __instance)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance) || Player.s_equipmentModifierSourceFields == null)
					{
						return;
					}
					for (int i = 0; i < __instance.m_equipmentModifierValues.Length; i++)
					{
						float num = 0f;
						for (int j = 0; j < ActiveSlots; j++)
						{
							ItemData extraUtility = ((Humanoid)(object)__instance).GetExtraUtility(j);
							if (extraUtility != null)
							{
								num += (float)Player.s_equipmentModifierSourceFields[i].GetValue(extraUtility.m_shared);
							}
						}
						__instance.m_equipmentModifierValues[i] += num;
					}
				}
			}

			[HarmonyPatch(typeof(Player), "OnInventoryChanged")]
			private static class Player_OnInventoryChanged_ValidateExtraUtilitySlots
			{
				private static void Postfix(Player __instance)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance) || __instance.m_isLoading)
					{
						return;
					}
					bool flag = false;
					for (int i = 0; i < ActiveSlots; i++)
					{
						ItemData extraUtility = ((Humanoid)(object)__instance).GetExtraUtility(i);
						if (extraUtility != null && !Slots.PlayerInventory.ContainsItem(extraUtility))
						{
							((Humanoid)(object)__instance).SetExtraUtility(i, null);
							flag = true;
						}
					}
					if (flag)
					{
						((Humanoid)__instance).SetupEquipment();
					}
				}
			}

			[HarmonyPatch(typeof(Humanoid), "GetSetCount")]
			private static class Humanoid_GetSetCount_ExtraUtility
			{
				private static void Postfix(Humanoid __instance, string setName, ref int __result)
				{
					if (!Slots.IsValidPlayer((Character)(object)__instance))
					{
						return;
					}
					foreach (ItemData equippedItem in GetEquippedItems(__instance))
					{
						if (equippedItem.m_shared.m_setName == setName)
						{
							__result++;
						}
					}
				}
			}
		}

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

		private static readonly HashSet<StatusEffect> tempEffects = new HashSet<StatusEffect>();

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

		public static int ActiveSlots => Mathf.Clamp(ExtraSlots.extraUtilitySlotsAmount.Value, 0, 4);

		public static ItemData GetItem(int index)
		{
			return ((Humanoid)(object)Player.m_localPlayer)?.GetExtraUtility(index);
		}

		public static bool IsItemEquipped(ItemData item)
		{
			return GetUtilityItemIndex(item) != -1;
		}

		public static int GetEmptySlot()
		{
			for (int i = 0; i < ActiveSlots; i++)
			{
				if (IsSlotAvailable(i))
				{
					return i;
				}
			}
			return -1;
		}

		public static int GetSlotForItem(ItemData item)
		{
			foreach (HashSet<string> item3 in uniqueEquipped)
			{
				if (!item3.Contains(item.m_shared.m_name))
				{
					continue;
				}
				if (((Humanoid)Player.m_localPlayer).m_utilityItem != null && item3.Contains(((Humanoid)Player.m_localPlayer).m_utilityItem.m_shared.m_name))
				{
					return -1;
				}
				for (int i = 0; i < ActiveSlots; i++)
				{
					ItemData item2 = GetItem(i);
					if (item2 != null && item3.Contains(item2.m_shared.m_name))
					{
						return i;
					}
				}
			}
			return GetEmptySlot();
		}

		private static bool IsSlotAvailable(int index)
		{
			return Slots.IsExtraUtilitySlotAvailable(index) && GetItem(index) == null;
		}

		public static List<ItemData> GetEquippedItems()
		{
			return GetEquippedItems((Humanoid)(object)Player.m_localPlayer);
		}

		public static List<ItemData> GetEquippedItems(Humanoid humanoid)
		{
			if ((Object)(object)humanoid == (Object)null)
			{
				return emptyItems;
			}
			HumanoidExtraUtilitySlots extraUtilityData = humanoid.GetExtraUtilityData();
			int activeSlots = ActiveSlots;
			if (!extraUtilityData.equippedItemsDirty && extraUtilityData.equippedItemsCachedActiveSlots == activeSlots && extraUtilityData.equippedItemsCache != null)
			{
				return extraUtilityData.equippedItemsCache;
			}
			List<ItemData> list = new List<ItemData>(activeSlots);
			for (int i = 0; i < activeSlots; i++)
			{
				ItemData extraUtility = humanoid.GetExtraUtility(i);
				if (extraUtility != null)
				{
					list.Add(extraUtility);
				}
			}
			extraUtilityData.equippedItemsCache = list;
			extraUtilityData.equippedItemsCachedActiveSlots = activeSlots;
			extraUtilityData.equippedItemsDirty = false;
			return extraUtilityData.equippedItemsCache;
		}

		public static int GetUtilityItemIndex(ItemData item)
		{
			return GetUtilityItemIndex((Humanoid)(object)Player.m_localPlayer, item);
		}

		public static int GetUtilityItemIndex(Humanoid humanoid, ItemData item)
		{
			if ((Object)(object)humanoid == (Object)null || item == null)
			{
				return -1;
			}
			for (int i = 0; i < ActiveSlots; i++)
			{
				ItemData extraUtility = humanoid.GetExtraUtility(i);
				if (extraUtility != null && extraUtility == item)
				{
					return i;
				}
			}
			return -1;
		}

		public static void UpdateUniqueEquipped()
		{
			uniqueEquipped.Clear();
			string[] array = ExtraSlots.preventUniqueUtilityItemsEquip.Value.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				string[] array2 = text.Split(new char[1] { ':' }, StringSplitOptions.RemoveEmptyEntries);
				if (array2.Length != 0)
				{
					uniqueEquipped.Add(new HashSet<string>(array2.Select((string item) => item.GetItemName())));
				}
			}
		}
	}
	[BepInIncompatibility("aedenthorn.ExtendedPlayerInventory")]
	[BepInIncompatibility("Azumatt.AzuExtendedPlayerInventory")]
	[BepInIncompatibility("com.bruce.valheim.comfyquickslots")]
	[BepInIncompatibility("randyknapp.mods.equipmentandquickslots")]
	[BepInIncompatibility("moreslots")]
	[BepInIncompatibility("randyknapp.mods.auga")]
	[BepInIncompatibility("toombe.EquipMultipleUtilityItemsUpdate")]
	[BepInIncompatibility("aedenthorn.EquipMultipleUtilityItems")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("shudnal.ExtraSlots", "Extra Slots", "1.1.15")]
	public class ExtraSlots : BaseUnityPlugin
	{
		public enum SlotsAlignment
		{
			VerticalTopHorizontalLeft,
			VerticalTopHorizontalMiddle,
			VerticalMiddleHorizontalLeft
		}

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

			private object <>2__current;

			public ExtraSlots <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = waitForFrame;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					LogInfo("UpdateSlots delayed update");
					API.UpdateSlots();
					<>4__this.slotsUpdater = 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();
			}
		}

		public const string pluginID = "shudnal.ExtraSlots";

		public const string pluginName = "Extra Slots";

		public const string pluginVersion = "1.1.15";

		internal readonly Harmony harmony = new Harmony("shudnal.ExtraSlots");

		internal static readonly ConfigSync configSync = new ConfigSync("shudnal.ExtraSlots")
		{
			DisplayName = "Extra Slots",
			CurrentVersion = "1.1.15",
			MinimumRequiredVersion = "1.1.15"
		};

		internal static ExtraSlots instance;

		internal static ConfigEntry<bool> configLocked;

		internal static ConfigEntry<bool> loggingEnabled;

		internal static ConfigEntry<bool> loggingDebugEnabled;

		public static ConfigEntry<bool> fixContainerPosition;

		public static ConfigEntry<bool> hotbarPreventStackAll;

		public static ConfigEntry<bool> preventAutoPickup;

		public static ConfigEntry<int> extraRows;

		public static ConfigEntry<int> quickSlotsAmount;

		public static ConfigEntry<int> extraUtilitySlotsAmount;

		public static ConfigEntry<bool> foodSlotsEnabled;

		public static ConfigEntry<bool> miscSlotsEnabled;

		public static ConfigEntry<bool> ammoSlotsEnabled;

		public static ConfigEntry<bool> backupEnabled;

		public static ConfigEntry<string> preventUniqueUtilityItemsEquip;

		public static ConfigEntry<bool> useSingleHotbarItem;

		public static ConfigEntry<bool> showExtraUtilityItems;

		public static ConfigEntry<bool> slotsTombstoneAutoEquipWeaponShield;

		public static ConfigEntry<bool> slotsTombstoneAutoEquipEnabled;

		public static ConfigEntry<bool> slotsTombstoneAutoEquipCarryWeightItemsEnabled;

		public static ConfigEntry<string> slotsTombstoneAutoEquipWhiteList;

		public static ConfigEntry<string> slotsTombstoneAutoEquipBlackList;

		public static ConfigEntry<string> slotsTombstoneAutoEquipItemList;

		public static ConfigEntry<bool> keepOnDeathEquipmentSlots;

		public static ConfigEntry<bool> keepOnDeathQuickSlots;

		public static ConfigEntry<bool> keepOnDeathFoodSlots;

		public static ConfigEntry<bool> keepOnDeathAmmoSlots;

		public static ConfigEntry<bool> keepOnDeathMiscSlots;

		public static ConfigEntry<string> keepOnDeathItemList;

		public static ConfigEntry<string> keepOnDeathWhiteList;

		public static ConfigEntry<string> keepOnDeathBlackList;

		public static ConfigEntry<float> itemWeightFactorEquipmentSlots;

		public static ConfigEntry<float> itemWeightFactorQuickSlots;

		public static ConfigEntry<float> itemWeightFactorFoodSlots;

		public static ConfigEntry<float> itemWeightFactorAmmoSlots;

		public static ConfigEntry<float> itemWeightFactorMiscSlots;

		public static ConfigEntry<int> lightenedSlotsStartIndex;

		public static ConfigEntry<float> lightenedSlotsWeightFactor;

		public static ConfigEntry<bool> lightenedSlotsOnlyExtraRows;

		public static ConfigEntry<string> lightenedSlotsPlayerKey;

		public static ConfigEntry<string> lightenedSlotsItemDiscovered;

		public static ConfigEntry<bool> lightenedSlotsShowHintImage;

		public static ConfigEntry<bool> lightenedSlotsShowTooltip;

		public static ConfigEntry<string> vanillaSlotsOrder;

		public static ConfigEntry<SlotsAlignment> equipmentSlotsAlignment;

		public static ConfigEntry<Vector2> equipmentPanelOffset;

		public static ConfigEntry<Vector2> equipmentPanelTooltipOffset;

		public static ConfigEntry<bool> quickSlotsAlignmentCenter;

		public static ConfigEntry<bool> equipmentSlotsShowTooltip;

		public static ConfigEntry<bool> equipmentSlotsPreventStackAll;

		public static ConfigEntry<bool> foodSlotsHotBarEnabled;

		public static ConfigEntry<Vector2> foodSlotsHotBarOffset;

		public static ConfigEntry<RectTransformExtensions.ElementAnchor> foodSlotsHotBarAnchor;

		public static ConfigEntry<float> foodSlotsHotBarScale;

		public static ConfigEntry<bool> foodSlotsShowLabel;

		public static ConfigEntry<bool> foodSlotsShowHintImage;

		public static ConfigEntry<bool> foodSlotsShowTooltip;

		public static ConfigEntry<bool> foodSlotsHideStackSize;

		public static ConfigEntry<int> foodSlotsWidthInElements;

		public static ConfigEntry<bool> foodSlotsFillDirectionUp;

		public static ConfigEntry<float> foodSlotsElementSpace;

		public static ConfigEntry<string> foodSlotsTooltipNameFormat;

		public static ConfigEntry<Color> foodSlotsStackColor;

		public static ConfigEntry<bool> foodSlotsPreventStackAll;

		public static ConfigEntry<string> foodSlotsItemList;

		public static ConfigEntry<string> foodSlotsItemBlackList;

		public static ConfigEntry<KeyboardShortcut> foodSlotHotKey1;

		public static ConfigEntry<KeyboardShortcut> foodSlotHotKey2;

		public static ConfigEntry<KeyboardShortcut> foodSlotHotKey3;

		public static ConfigEntry<string> foodSlotHotKey1Text;

		public static ConfigEntry<string> foodSlotHotKey2Text;

		public static ConfigEntry<string> foodSlotHotKey3Text;

		public static ConfigEntry<bool> miscSlotsShowLabel;

		public static ConfigEntry<bool> miscSlotsShowHintImage;

		public static ConfigEntry<bool> miscSlotsShowTooltip;

		public static ConfigEntry<Color> miscSlotsStackColor;

		public static ConfigEntry<bool> miscSlotsPreventStackAll;

		public static ConfigEntry<string> miscSlotsItemList;

		public static ConfigEntry<string> miscSlotsItemBlackList;

		public static ConfigEntry<bool> ammoSlotsHotBarEnabled;

		public static ConfigEntry<Vector2> ammoSlotsHotBarOffset;

		public static ConfigEntry<RectTransformExtensions.ElementAnchor> ammoSlotsHotBarAnchor;

		public static ConfigEntry<float> ammoSlotsHotBarScale;

		public static ConfigEntry<bool> ammoSlotsShowLabel;

		public static ConfigEntry<bool> ammoSlotsShowHintImage;

		public static ConfigEntry<bool> ammoSlotsShowTooltip;

		public static ConfigEntry<bool> ammoSlotsHideStackSize;

		public static ConfigEntry<int> ammoSlotsWidthInElements;

		public static ConfigEntry<bool> ammoSlotsFillDirectionUp;

		public static ConfigEntry<float> ammoSlotsElementSpace;

		public static ConfigEntry<string> ammoSlotsTooltipNameFormat;

		public static ConfigEntry<Color> ammoSlotsStackColor;

		public static ConfigEntry<bool> ammoSlotsPreventStackAll;

		public static ConfigEntry<string> ammoSlotsItemList;

		public static ConfigEntry<bool> ammoSlotsAllowThrowables;

		public static ConfigEntry<string> ammoSlotsItemBlackList;

		public static ConfigEntry<KeyboardShortcut> ammoSlotHotKey1;

		public static ConfigEntry<KeyboardShortcut> ammoSlotHotKey2;

		public static ConfigEntry<KeyboardShortcut> ammoSlotHotKey3;

		public static ConfigEntry<string> ammoSlotHotKey1Text;

		public static ConfigEntry<string> ammoSlotHotKey2Text;

		public static ConfigEntry<string> ammoSlotHotKey3Text;

		public static ConfigEntry<bool> quickSlotsHotBarEnabled;

		public static ConfigEntry<Vector2> quickSlotsHotBarOffset;

		public static ConfigEntry<RectTransformExtensions.ElementAnchor> quickSlotsHotBarAnchor;

		public static ConfigEntry<float> quickSlotsHotBarScale;

		public static ConfigEntry<bool> quickSlotsShowLabel;

		public static ConfigEntry<bool> quickSlotsShowHintImage;

		public static ConfigEntry<bool> quickSlotsShowTooltip;

		public static ConfigEntry<bool> quickSlotsHideStackSize;

		public static ConfigEntry<int> quickSlotsWidthInElements;

		public static ConfigEntry<bool> quickSlotsFillDirectionUp;

		public static ConfigEntry<float> quickSlotsElementSpace;

		public static ConfigEntry<string> quickSlotsTooltipNameFormat;

		public static ConfigEntry<Color> quickSlotsStackColor;

		public static ConfigEntry<bool> quickSlotsPreventStackAll;

		public static ConfigEntry<KeyboardShortcut> quickSlotHotKey1;

		public static ConfigEntry<KeyboardShortcut> quickSlotHotKey2;

		public static ConfigEntry<KeyboardShortcut> quickSlotHotKey3;

		public static ConfigEntry<KeyboardShortcut> quickSlotHotKey4;

		public static ConfigEntry<KeyboardShortcut> quickSlotHotKey5;

		public static ConfigEntry<KeyboardShortcut> quickSlotHotKey6;

		public static ConfigEntry<string> quickSlotHotKey1Text;

		public static ConfigEntry<string> quickSlotHotKey2Text;

		public static ConfigEntry<string> quickSlotHotKey3Text;

		public static ConfigEntry<string> quickSlotHotKey4Text;

		public static ConfigEntry<string> quickSlotHotKey5Text;

		public static ConfigEntry<string> quickSlotHotKey6Text;

		public static ConfigEntry<HorizontalAlignmentOptions> equipmentSlotLabelAlignment;

		public static ConfigEntry<TextWrappingModes> equipmentSlotLabelWrappingMode;

		public static ConfigEntry<Vector4> equipmentSlotLabelMargin;

		public static ConfigEntry<Vector2> equipmentSlotLabelFontSize;

		public static ConfigEntry<Color> equipmentSlotLabelFontColor;

		public static ConfigEntry<HorizontalAlignmentOptions> quickSlotLabelAlignment;

		public static ConfigEntry<TextWrappingModes> quickSlotLabelWrappingMode;

		public static ConfigEntry<Vector4> quickSlotLabelMargin;

		public static ConfigEntry<Vector2> quickSlotLabelFontSize;

		public static ConfigEntry<Color> quickSlotLabelFontColor;

		public static ConfigEntry<HorizontalAlignmentOptions> ammoSlotLabelAlignment;

		public static ConfigEntry<TextWrappingModes> ammoSlotLabelWrappingMode;

		public static ConfigEntry<Vector4> ammoSlotLabelMargin;

		public static ConfigEntry<Vector2> ammoSlotLabelFontSize;

		public static ConfigEntry<Color> ammoSlotLabelFontColor;

		public static ConfigEntry<bool> slotsProgressionEnabled;

		public static ConfigEntry<string> quickSlotGlobalKey1;

		public static ConfigEntry<string> quickSlotGlobalKey2;

		public static ConfigEntry<string> quickSlotGlobalKey3;

		public static ConfigEntry<string> quickSlotGlobalKey4;

		public static ConfigEntry<string> quickSlotGlobalKey5;

		public static ConfigEntry<string> quickSlotGlobalKey6;

		public static ConfigEntry<string> ammoSlotsGlobalKey;

		public static ConfigEntry<string> foodSlotsGlobalKey;

		public static ConfigEntry<string> miscSlotsGlobalKey;

		public static ConfigEntry<string> utilitySlotGlobalKey1;

		public static ConfigEntry<string> utilitySlotGlobalKey2;

		public static ConfigEntry<string> utilitySlotGlobalKey3;

		public static ConfigEntry<string> utilitySlotGlobalKey4;

		public static ConfigEntry<string> utilitySlotItemDiscovered1;

		public static ConfigEntry<string> utilitySlotItemDiscovered2;

		public static ConfigEntry<string> utilitySlotItemDiscovered3;

		public static ConfigEntry<string> utilitySlotItemDiscovered4;

		public static ConfigEntry<string> quickSlotItemDiscovered1;

		public static ConfigEntry<string> quickSlotItemDiscovered2;

		public static ConfigEntry<string> quickSlotItemDiscovered3;

		public static ConfigEntry<string> quickSlotItemDiscovered4;

		public static ConfigEntry<string> quickSlotItemDiscovered5;

		public static ConfigEntry<string> quickSlotItemDiscovered6;

		public static ConfigEntry<bool> ammoSlotsAvailableAfterDiscovery;

		public static ConfigEntry<bool> utilitySlotAvailableAfterDiscovery;

		public static ConfigEntry<bool> foodSlotsAvailableAfterDiscovery;

		public static ConfigEntry<bool> equipmentSlotsAvailableAfterDiscovery;

		public static ConfigEntry<bool> rowsProgressionEnabled;

		public static ConfigEntry<string> extraRowPlayerKeyMinus2;

		public static ConfigEntry<string> extraRowPlayerKeyMinus1;

		public static ConfigEntry<string> extraRowPlayerKeyVanilla;

		public static ConfigEntry<string> extraRowPlayerKey1;

		public static ConfigEntry<string> extraRowPlayerKey2;

		public static ConfigEntry<string> extraRowPlayerKey3;

		public static ConfigEntry<string> extraRowPlayerKey4;

		public static ConfigEntry<string> extraRowPlayerKey5;

		public static ConfigEntry<string> extraRowItemDiscoveredMinus2;

		public static ConfigEntry<string> extraRowItemDiscoveredMinus1;

		public static ConfigEntry<string> extraRowItemDiscoveredVanilla;

		public static ConfigEntry<string> extraRowItemDiscovered1;

		public static ConfigEntry<string> extraRowItemDiscovered2;

		public static ConfigEntry<string> extraRowItemDiscovered3;

		public static ConfigEntry<string> extraRowItemDiscovered4;

		public static ConfigEntry<string> extraRowItemDiscovered5;

		public static ConfigEntry<float> epicLootMagicItemUnequippedAlpha;

		public static ConfigEntry<bool> epicLootExcludeMiscItemsFromSacrifice;

		public static ConfigEntry<bool> bbhArrowsFindingAndCounting;

		public static ConfigEntry<bool> recycle_N_ReclaimExcludeExtraSlots;

		public static ConfigEntry<KeyCode> rebindConnectPanel;

		public static ConfigEntry<string> reducedInventoryPanel1;

		public static ConfigEntry<string> reducedInventoryPanel2;

		public static ConfigEntry<string> reducedInventoryPanel3;

		public static ConfigEntry<string> reducedInventoryPanelVisibility1;

		public static ConfigEntry<string> reducedInventoryPanelVisibility2;

		public static ConfigEntry<string> reducedInventoryPanelVisibility3;

		public static ConfigEntry<bool> valheimRadialAddQuickSlots;

		public static ConfigEntry<bool> valheimRadialAddFoodSlots;

		public static ConfigEntry<bool> valheimRadialAddAmmoSlots;

		public static string configDirectory;

		private IEnumerator slotsUpdater;

		private static readonly WaitForEndOfFrame waitForFrame = new WaitForEndOfFrame();

		public static bool HasServerCharactersActive => !ZNet.IsSinglePlayer && Chainloader.PluginInfos.ContainsKey("org.bepinex.plugins.servercharacters");

		public static bool IsDedicated => (int)SystemInfo.graphicsDeviceType == 4;

		private void Awake()
		{
			instance = this;
			ConfigInit();
			configSync.AddLockingConfigEntry<bool>(configLocked);
			configDirectory = Path.Combine(Paths.ConfigPath, "shudnal.ExtraSlots");
			Game.isModded = true;
			LoadIcons();
			Slots.InitializeSlots();
			EquipmentPanel.ReorderVanillaSlots();
			if (loggingDebugEnabled.Value || loggingEnabled.Value)
			{
				LogCurrentLogLevel();
			}
			CompatibilityHelper.CheckForCompatibility();
			harmony.PatchAll();
			((MonoBehaviour)this).StartCoroutine(Localizer.Load());
		}

		private void LateUpdate()
		{
			if (Object.op_Implicit((Object)(object)InventoryGui.instance) && !IsAwaitingForSlotsUpdate())
			{
				ItemsSlotsValidation.Validate();
			}
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
			instance = null;
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}

		private ConfigDescription GetDescriptionSeparatedStrings(string description)
		{
			//IL_003f: 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_0045: Expected O, but got Unknown
			return Chainloader.PluginInfos.ContainsKey("_shudnal.ConfigurationManager") ? new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()) : new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
			{
				new CustomConfigs.ConfigurationManagerAttributes
				{
					CustomDrawer = CustomConfigs.DrawSeparatedStrings(",")
				}
			});
		}

		public void ConfigInit()
		{
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Expected O, but got Unknown
			//IL_0710: Unknown result type (might be due to invalid IL or missing references)
			//IL_071b: Expected O, but got Unknown
			//IL_0749: Unknown result type (might be due to invalid IL or missing references)
			//IL_0754: Expected O, but got Unknown
			//IL_0782: Unknown result type (might be due to invalid IL or missing references)
			//IL_078d: Expected O, but got Unknown
			//IL_07bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c6: Expected O, but got Unknown
			//IL_07f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ff: Expected O, but got Unknown
			//IL_08f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0901: Expected O, but got Unknown
			//IL_092f: Unknown result type (might be due to invalid IL or missing references)
			//IL_093a: Expected O, but got Unknown
			//IL_0ac0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b50: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b80: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ca0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cd0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d00: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0df0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e99: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ea4: Expected O, but got Unknown
			//IL_0ed0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f28: Unknown result type (might be due to invalid IL or missing references)
			//IL_1060: Unknown result type (might be due to invalid IL or missing references)
			//IL_1162: Unknown result type (might be due to invalid IL or missing references)
			//IL_1240: Unknown result type (might be due to invalid IL or missing references)
			//IL_124b: Expected O, but got Unknown
			//IL_12b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_13c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_149f: Unknown result type (might be due to invalid IL or missing references)
			//IL_14aa: Expected O, but got Unknown
			//IL_1516: Unknown result type (might be due to invalid IL or missing references)
			//IL_16dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_17ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_17c5: Expected O, but got Unknown
			//IL_1831: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a01: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a2b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a5a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b98: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bc2: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bf1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d2f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d59: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d88: Unknown result type (might be due to invalid IL or missing references)
			//IL_2d76: Unknown result type (might be due to invalid IL or missing references)
			//IL_2d85: Unknown result type (might be due to invalid IL or missing references)
			//IL_2dc4: Unknown result type (might be due to invalid IL or missing references)
			//IL_2dd3: Unknown result type (might be due to invalid IL or missing references)
			//IL_2db4: Unknown result type (might be due to invalid IL or missing references)
			//IL_2e12: Unknown result type (might be due to invalid IL or missing references)
			//IL_2e21: Unknown result type (might be due to invalid IL or missing references)
			//IL_2e02: Unknown result type (might be due to invalid IL or missing references)
			//IL_2e50: Unknown result type (might be due to invalid IL or missing references)
			config("General", "NexusID", 2901, "Nexus mod ID for updates");
			configLocked = config("General", "Lock Configuration", defaultValue: true, "Configuration is locked and can be changed by server admins only. [Synced with Server]", synchronizedSetting: true);
			loggingEnabled = config("General", "Logging enabled", defaultValue: false, "Enable logging.");
			loggingDebugEnabled = config("General", "Logging debug enabled", defaultValue: false, "Enable debug logging.");
			fixContainerPosition = config("General", "Fix container position for extra rows", defaultValue: true, "Moves container lower if there are extra inventory rows.\nDisable this if you have other mods repositioning the container grid element");
			hotbarPreventStackAll = config("General", "Prevent Stack All of hotbar items", defaultValue: true, "Prevent items from hotbar slots (1-8) to be placed into container when Stack All feature is used.");
			preventAutoPickup = config("General", "Prevent items auto pickup in extra slots", defaultValue: false, "Should extra slots be used for items auto pickup. If enabled - item from ground will not be put into extra slots.\nIt will not prevent autostacking similar items.");
			loggingEnabled.SettingChanged += delegate
			{
				LogCurrentLogLevel();
			};
			loggingDebugEnabled.SettingChanged += delegate
			{
				LogCurrentLogLevel();
			};
			quickSlotsAmount = config("Extra slots", "Amount of quick slots", 3, new ConfigDescription("How much quick slots should be added. [Synced with Server]", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 6), Array.Empty<object>()), synchronizedSetting: true);
			extraUtilitySlotsAmount = config("Extra slots", "Amount of extra utility slots", 2, new ConfigDescription("How much extra utility slots should be added [Synced with Server]", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 4), Array.Empty<object>()), synchronizedSetting: true);
			extraRows = config("Extra slots", "Amount of extra inventory rows", 0, new ConfigDescription("How much rows to add or remove from regular inventory [Synced with Server]", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-3, 5), Array.Empty<object>()), synchronizedSetting: true);
			ammoSlotsEnabled = config("Extra slots", "Enable ammo slots", defaultValue: true, "Enable 3 slots for ammo [Synced with Server]", synchronizedSetting: true);
			foodSlotsEnabled = config("Extra slots", "Enable food slots", defaultValue: true, "Enable 3 slots for food [Synced with Server]", synchronizedSetting: true);
			miscSlotsEnabled = config("Extra slots", "Enable misc slots", defaultValue: true, "Enable up to 2 slots for trophies, coins, fish, miscellaneous, keys and quest items. [Synced with Server]\n1 slot comes with Food slots, 1 slot comes with Ammo slots.\nIf both Food and Ammo slots are disabled there will be no Misc slots.\nIf there are no Quick slots there will be no Misc slots.", synchronizedSetting: true);
			backupEnabled = config("Extra slots", "Slots backup enabled", defaultValue: true, "Backup extra slots item on save. [Synced with Server]\nIt could be restored in case of loading character without mod installed leading to extra slots item loss.\nWhen character is loaded with no extra slots items but has backup items the items from backup will be recover.", synchronizedSetting: true);
			slotsProgressionEnabled = config("Extra slots", "Slots progression enabled", defaultValue: true, "Enabled slot obtaining progression. If disabled - all enabled slots will be available from the start. [Synced with Server]", synchronizedSetting: true);
			rowsProgressionEnabled = config("Extra slots", "Inventory rows progression enabled", defaultValue: false, "Enabled inventory rows obtaining progression. [Synced with Server]", synchronizedSetting: true);
			preventUniqueUtilityItemsEquip = config("Extra slots", "Unique utility items", "BeltStrength:BeltYmir_TW:InfusedBeltStrength", GetDescriptionSeparatedStrings("Comma-separated list of \":\" separated tuples of items that should not be equipped at the same time [Synced with Server]\nIf you just want one item to be unique-equipped just add its name without \":\"\nWorks with prefab names (like BeltStrength) and item names (like $item_beltstrength)."), synchronizedSetting: true);
			useSingleHotbarItem = config("Extra slots", "Use single hotbar item", defaultValue: true, "Enabled - only item from the first slot will be used with slots priority (Quick -> Ammo -> Food)\nDisabled - all items with similar hotkey will be used at once. [Synced with Server]", synchronizedSetting: true);
			showExtraUtilityItems = config("Extra slots", "Show extra utility items", defaultValue: true, "Show extra utility items on player model. [Synced with Server]", synchronizedSetting: true);
			extraRows.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			rowsProgressionEnabled.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraUtilitySlotsAmount.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotsAmount.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			foodSlotsEnabled.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			miscSlotsEnabled.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			ammoSlotsEnabled.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			slotsProgressionEnabled.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			preventUniqueUtilityItemsEquip.SettingChanged += delegate
			{
				ExtraUtilitySlots.UpdateUniqueEquipped();
			};
			showExtraUtilityItems.SettingChanged += delegate
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Humanoid)localPlayer).SetupEquipment();
				}
			};
			slotsTombstoneAutoEquipEnabled = config("Extra slots - Auto equip on tombstone pickup", "Equip all equipment slots", defaultValue: false, "Auto equip items in equipment slots if tombstone was successfully taken as whole. [Synced with Server]", synchronizedSetting: true);
			slotsTombstoneAutoEquipCarryWeightItemsEnabled = config("Extra slots - Auto equip on tombstone pickup", "Equip items increasing carry weight", defaultValue: true, "Auto equip items in equipment slots that increase max carry weight (like Megingjord) if tombstone was successfully taken as whole. [Synced with Server]\nThese items are unaffected by black and white lists", synchronizedSetting: true);
			slotsTombstoneAutoEquipWeaponShield = config("Extra slots - Auto equip on tombstone pickup", "Equip previous weapon and shield", defaultValue: false, "Auto equip weapon and shield that was equipped on death. [Synced with Server]\nThese items are unaffected by black and white lists", synchronizedSetting: true);
			slotsTombstoneAutoEquipWhiteList = config("Extra slots - Auto equip on tombstone pickup", "Items white list", "", "If this list is filled - only these items will be auto equipped. Works with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]", synchronizedSetting: true);
			slotsTombstoneAutoEquipBlackList = config("Extra slots - Auto equip on tombstone pickup", "Items black list", "", "Items from this list will not be auto equipped. Works with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]", synchronizedSetting: true);
			slotsTombstoneAutoEquipItemList = config("Extra slots - Auto equip on tombstone pickup", "Items list to always equip", "", "Items from this list will always be auto equipped. Works with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]", synchronizedSetting: true);
			slotsTombstoneAutoEquipWhiteList.SettingChanged += delegate
			{
				TombStoneInteraction.UpdateItemLists();
			};
			slotsTombstoneAutoEquipBlackList.SettingChanged += delegate
			{
				TombStoneInteraction.UpdateItemLists();
			};
			slotsTombstoneAutoEquipItemList.SettingChanged += delegate
			{
				TombStoneInteraction.UpdateItemLists();
			};
			keepOnDeathEquipmentSlots = config("Extra slots - Death tweaks", "Keep items at equipment slots", defaultValue: false, "Keep items in equipment slots after death. [Synced with Server]", synchronizedSetting: true);
			keepOnDeathQuickSlots = config("Extra slots - Death tweaks", "Keep items at quick slots", defaultValue: false, "Keep items in quick slots after death. [Synced with Server]", synchronizedSetting: true);
			keepOnDeathFoodSlots = config("Extra slots - Death tweaks", "Keep items at food slots", defaultValue: false, "Keep items in food slots after death. [Synced with Server]", synchronizedSetting: true);
			keepOnDeathAmmoSlots = config("Extra slots - Death tweaks", "Keep items at ammo slots", defaultValue: false, "Keep items in ammo slots after death. [Synced with Server]", synchronizedSetting: true);
			keepOnDeathMiscSlots = config("Extra slots - Death tweaks", "Keep items at misc slots", defaultValue: false, "Keep items in misc slots after death. [Synced with Server]", synchronizedSetting: true);
			keepOnDeathItemList = config("Extra slots - Death tweaks", "Keep items fixed list", "", "Items from this list will always be kept on death. Works with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]", synchronizedSetting: true);
			keepOnDeathWhiteList = config("Extra slots - Death tweaks", "Keep items white list", "", "If this list is filled - only these items will be kept after death. Works with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]", synchronizedSetting: true);
			keepOnDeathBlackList = config("Extra slots - Death tweaks", "Keep items black list", "", "Items from this list will not be kept after death. Works with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]", synchronizedSetting: true);
			keepOnDeathItemList.SettingChanged += delegate
			{
				TombStoneInteraction.UpdateItemLists();
			};
			keepOnDeathWhiteList.SettingChanged += delegate
			{
				TombStoneInteraction.UpdateItemLists();
			};
			keepOnDeathBlackList.SettingChanged += delegate
			{
				TombStoneInteraction.UpdateItemLists();
			};
			itemWeightFactorEquipmentSlots = config("Extra slots - Item weight factor", "Equipment slots", 1f, new ConfigDescription("Weight factor for items in equipment slots. [Synced with Server]", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), synchronizedSetting: true);
			itemWeightFactorQuickSlots = config("Extra slots - Item weight factor", "Quick slots", 1f, new ConfigDescription("Weight factor for items in quick slots. [Synced with Server]", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), synchronizedSetting: true);
			itemWeightFactorFoodSlots = config("Extra slots - Item weight factor", "Food slots", 1f, new ConfigDescription("Weight factor for items in food slots. [Synced with Server]", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), synchronizedSetting: true);
			itemWeightFactorAmmoSlots = config("Extra slots - Item weight factor", "Ammo slots", 1f, new ConfigDescription("Weight factor for items in ammo slots. [Synced with Server]", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), synchronizedSetting: true);
			itemWeightFactorMiscSlots = config("Extra slots - Item weight factor", "Misc slots", 1f, new ConfigDescription("Weight factor for items in misc slots. [Synced with Server]", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), synchronizedSetting: true);
			itemWeightFactorEquipmentSlots.SettingChanged += delegate
			{
				InventoryInteraction.UpdateTotalWeight();
			};
			itemWeightFactorQuickSlots.SettingChanged += delegate
			{
				InventoryInteraction.UpdateTotalWeight();
			};
			itemWeightFactorFoodSlots.SettingChanged += delegate
			{
				InventoryInteraction.UpdateTotalWeight();
			};
			itemWeightFactorAmmoSlots.SettingChanged += delegate
			{
				InventoryInteraction.UpdateTotalWeight();
			};
			itemWeightFactorMiscSlots.SettingChanged += delegate
			{
				InventoryInteraction.UpdateTotalWeight();
			};
			lightenedSlotsStartIndex = config("Extra slots - Lightened slots", "First row index", -2, new ConfigDescription("Defines which inventory rows will apply the weight-reduction effect. [Synced with Server]\nValue < 0: number of bottom rows to affect. Default value -2 means - apply to the last 2 rows\nValue = 0: feature disabled\nValue > 0: index of the first affected row (inclusive)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-9, 9), Array.Empty<object>()), synchronizedSetting: true);
			lightenedSlotsWeightFactor = config("Extra slots - Lightened slots", "Weight factor. Item weight will be multiplied by this value.", 0.5f, new ConfigDescription("Weight factor for items in lightened slots. [Synced with Server]", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), synchronizedSetting: true);
			lightenedSlotsOnlyExtraRows = config("Extra slots - Lightened slots", "Only extra rows", defaultValue: true, "Set if only rows of additional inventory should be affected (rows 5+). [Synced with Server]", synchronizedSetting: true);
			lightenedSlotsPlayerKey = config("Extra slots - Lightened slots", "Progression - Player key", "GP_Yagluth", "Comma-separated list of Player unique keys. [Synced with Server]\nLightened slots will be active only if any key is enabled or list is not set", synchronizedSetting: true);
			lightenedSlotsItemDiscovered = config("Extra slots - Lightened slots", "Progression - Item", "YagluthDrop", "Comma-separated list of items. [Synced with Server]\nLightened slots will be active only if any item is discovered or list is not set.", synchronizedSetting: true);
			lightenedSlotsShowHintImage = config("Extra slots - Lightened slots", "Show hint image", defaultValue: true, "Show slot background hint image");
			lightenedSlotsShowTooltip = config("Extra slots - Lightened slots", "Show help tooltip", defaultValue: true, "Show tooltip with slot info");
			lightenedSlotsStartIndex.SettingChanged += delegate
			{
				LightenedSlots.UpdateState();
			};
			lightenedSlotsWeightFactor.SettingChanged += delegate
			{
				InventoryInteraction.UpdateTotalWeight();
			};
			lightenedSlotsOnlyExtraRows.SettingChanged += delegate
			{
				LightenedSlots.UpdateState();
			};
			lightenedSlotsPlayerKey.SettingChanged += delegate
			{
				LightenedSlots.UpdateState();
			};
			lightenedSlotsItemDiscovered.SettingChanged += delegate
			{
				LightenedSlots.UpdateState();
			};
			quickSlotHotKey1 = config<KeyboardShortcut>("Hotkeys", "Quickslot 1", new KeyboardShortcut((KeyCode)122, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			quickSlotHotKey2 = config<KeyboardShortcut>("Hotkeys", "Quickslot 2", new KeyboardShortcut((KeyCode)120, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			quickSlotHotKey3 = config<KeyboardShortcut>("Hotkeys", "Quickslot 3", new KeyboardShortcut((KeyCode)99, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			quickSlotHotKey4 = config<KeyboardShortcut>("Hotkeys", "Quickslot 4", new KeyboardShortcut((KeyCode)118, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			quickSlotHotKey5 = config<KeyboardShortcut>("Hotkeys", "Quickslot 5", new KeyboardShortcut((KeyCode)113, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			quickSlotHotKey6 = config<KeyboardShortcut>("Hotkeys", "Quickslot 6", new KeyboardShortcut((KeyCode)114, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			quickSlotHotKey1Text = config("Hotkeys", "Quickslot 1 Text", "Alt + Z", "Hotkey 1 Display Text. Leave blank to use the hotkey itself.");
			quickSlotHotKey2Text = config("Hotkeys", "Quickslot 2 Text", "Alt + X", "Hotkey 2 Display Text. Leave blank to use the hotkey itself.");
			quickSlotHotKey3Text = config("Hotkeys", "Quickslot 3 Text", "Alt + C", "Hotkey 3 Display Text. Leave blank to use the hotkey itself.");
			quickSlotHotKey4Text = config("Hotkeys", "Quickslot 4 Text", "Alt + V", "Hotkey 4 Display Text. Leave blank to use the hotkey itself.");
			quickSlotHotKey5Text = config("Hotkeys", "Quickslot 5 Text", "Alt + Q", "Hotkey 5 Display Text. Leave blank to use the hotkey itself.");
			quickSlotHotKey6Text = config("Hotkeys", "Quickslot 6 Text", "Alt + R", "Hotkey 6 Display Text. Leave blank to use the hotkey itself.");
			ammoSlotHotKey1 = config<KeyboardShortcut>("Hotkeys", "Ammo 1", new KeyboardShortcut((KeyCode)49, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			ammoSlotHotKey2 = config<KeyboardShortcut>("Hotkeys", "Ammo 2", new KeyboardShortcut((KeyCode)50, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			ammoSlotHotKey3 = config<KeyboardShortcut>("Hotkeys", "Ammo 3", new KeyboardShortcut((KeyCode)51, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			ammoSlotHotKey1Text = config("Hotkeys", "Ammo 1 Text", "Alt + 1", "Hotkey 1 Display Text. Leave blank to use the hotkey itself.");
			ammoSlotHotKey2Text = config("Hotkeys", "Ammo 2 Text", "Alt + 2", "Hotkey 2 Display Text. Leave blank to use the hotkey itself.");
			ammoSlotHotKey3Text = config("Hotkeys", "Ammo 3 Text", "Alt + 3", "Hotkey 3 Display Text. Leave blank to use the hotkey itself.");
			foodSlotHotKey1 = config<KeyboardShortcut>("Hotkeys", "Food 1", new KeyboardShortcut((KeyCode)113, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			foodSlotHotKey2 = config<KeyboardShortcut>("Hotkeys", "Food 2", new KeyboardShortcut((KeyCode)101, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			foodSlotHotKey3 = config<KeyboardShortcut>("Hotkeys", "Food 3", new KeyboardShortcut((KeyCode)114, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "Use configuration manager to set shortcuts.");
			foodSlotHotKey1Text = config("Hotkeys", "Food 1 Text", "Alt + Q", "Hotkey 1 Display Text. Leave blank to use the hotkey itself.");
			foodSlotHotKey2Text = config("Hotkeys", "Food 2 Text", "Alt + E", "Hotkey 2 Display Text. Leave blank to use the hotkey itself.");
			foodSlotHotKey3Text = config("Hotkeys", "Food 3 Text", "Alt + R", "Hotkey 3 Display Text. Leave blank to use the hotkey itself.");
			vanillaSlotsOrder = config("Panels - Equipment slots", "Regular equipment slots order", Slots.VanillaOrder, new ConfigDescription("Comma separated list defining order of vanilla equipment slots", (AcceptableValueBase)null, new object[1]
			{
				new CustomConfigs.ConfigurationManagerAttributes
				{
					CustomDrawer = CustomConfigs.DrawOrderedFixedStrings(",")
				}
			}));
			equipmentSlotsAlignment = config("Panels - Equipment slots", "Equipment slots alignment", SlotsAlignment.VerticalTopHorizontalLeft, "Equipment slots alignment");
			equipmentPanelOffset = config<Vector2>("Panels - Equipment slots", "Offset", Vector2.zero, "Offset relative to the upper right corner of the inventory (side elements included)");
			quickSlotsAlignmentCenter = config("Panels - Equipment slots", "Quick slots alignment middle", defaultValue: false, "Place quickslots in the middle under equipment slots");
			equipmentSlotsShowTooltip = config("Panels - Equipment slots", "Show help tooltip", defaultValue: true, "Show tooltip with slot info");
			equipmentPanelTooltipOffset = config<Vector2>("Panels - Equipment slots", "Gamepad Tooltip Offset", Vector2.zero, "Offset relative to original position of tooltip at upper right corner of the inventory (side elements included)");
			equipmentSlotsPreventStackAll = config("Panels - Equipment slots", "Prevent Stack All", defaultValue: true, "Prevent items from equipment slots to be placed into container when Stack All feature is used.");
			vanillaSlotsOrder.SettingChanged += delegate
			{
				EquipmentPanel.ReorderVanillaSlots();
			};
			equipmentSlotsAlignment.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			equipmentPanelOffset.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			equipmentPanelTooltipOffset.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			miscSlotsShowLabel = config("Panels - Misc slots", "Show label", defaultValue: false, "Show slot label");
			miscSlotsShowHintImage = config("Panels - Misc slots", "Show hint image", defaultValue: true, "Show slot background hint image");
			miscSlotsShowTooltip = config("Panels - Misc slots", "Show help tooltip", defaultValue: true, "Show tooltip with slot info");
			miscSlotsStackColor = config<Color>("Panels - Misc slots", "Stack size color", Color.clear, "Color of stack size label.");
			miscSlotsPreventStackAll = config("Panels - Misc slots", "Prevent Stack All", defaultValue: true, "Prevent items from misc slots to be placed into container when Stack All feature is used.");
			miscSlotsItemList = config("Panels - Misc slots", "Custom item list", "AncientSeed,WitheredBone,BellFragment,DvergrKeyFragment", GetDescriptionSeparatedStrings("Comma separated list of items that should be treated as misc items\nWorks with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]"), synchronizedSetting: true);
			miscSlotsItemBlackList = config("Panels - Misc slots", "Custom item black list", "", GetDescriptionSeparatedStrings("Comma separated list of items that should NOT be treated as misc items\nWorks with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]"), synchronizedSetting: true);
			miscSlotsItemList.SettingChanged += delegate
			{
				Slots.UpdateMiscSlotCustomItemList();
			};
			miscSlotsItemBlackList.SettingChanged += delegate
			{
				Slots.UpdateMiscSlotCustomItemList();
			};
			quickSlotsHotBarEnabled = config("Panels - Quick slots", "Enabled", defaultValue: true, "Enable hotbar with quick slots [Synced with Server]", synchronizedSetting: true);
			quickSlotsHotBarOffset = config<Vector2>("Panels - Quick slots", "Offset", new Vector2(230f, 156f), "On screen position of quick slots hotbar panel");
			quickSlotsHotBarAnchor = config("Panels - Quick slots", "Offset Anchor", RectTransformExtensions.ElementAnchor.BottomLeft, "Anchor point for quick slots hotbar panel");
			quickSlotsHotBarScale = config("Panels - Quick slots", "Scale", 1f, "Relative size");
			quickSlotsShowLabel = config("Panels - Quick slots", "Show label", defaultValue: false, "Show slot label");
			quickSlotsShowHintImage = config("Panels - Quick slots", "Show hint image", defaultValue: true, "Show slot background hint image");
			quickSlotsShowTooltip = config("Panels - Quick slots", "Show help tooltip", defaultValue: true, "Show tooltip with slot info");
			quickSlotsHideStackSize = config("Panels - Quick slots", "Hide stack size in hotbar", defaultValue: false, "Hide stack size and left only current amount for consumable and equipable items in hotbar");
			quickSlotsWidthInElements = config("Panels - Quick slots", "Hotbar width in elements", 6, new ConfigDescription("How much quick slots should be displayed in one line", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 6), Array.Empty<object>()));
			quickSlotsFillDirectionUp = config("Panels - Quick slots", "Hotbar fill direction is up", defaultValue: false, "Quickslots hotbar will fill from bottom to top");
			quickSlotsElementSpace = config("Panels - Quick slots", "Hotbar element space", 70f, "Quickslots hotbar element size. Defines space between elements as well.");
			quickSlotsTooltipNameFormat = config("Panels - Quick slots", "Tooltip name format", "{0} ({1})", "Where {0} is slot name and {1} is slot shortcut.");
			quickSlotsStackColor = config<Color>("Panels - Quick slots", "Stack size color", Color.clear, "Color of stack size label.");
			quickSlotsPreventStackAll = config("Panels - Quick slots", "Prevent Stack All", defaultValue: true, "Prevent items from quick slots to be placed into container when Stack All feature is used.");
			quickSlotsHotBarEnabled.SettingChanged += delegate
			{
				QuickSlotsHotBar.MarkDirty();
			};
			quickSlotsHotBarOffset.SettingChanged += delegate
			{
				QuickSlotsHotBar.MarkDirty();
			};
			quickSlotsHotBarAnchor.SettingChanged += delegate
			{
				QuickSlotsHotBar.MarkDirty();
			};
			quickSlotsHotBarScale.SettingChanged += delegate
			{
				QuickSlotsHotBar.MarkDirty();
			};
			ammoSlotsHotBarEnabled = config("Panels - Ammo slots", "Enabled", defaultValue: true, "Enable hotbar with Ammo slots [Synced with Server]", synchronizedSetting: true);
			ammoSlotsHotBarOffset = config<Vector2>("Panels - Ammo slots", "Offset", new Vector2(230f, 228f), "On screen position of ammo slots hotbar panel");
			ammoSlotsHotBarAnchor = config("Panels - Ammo slots", "Offset Anchor", RectTransformExtensions.ElementAnchor.BottomLeft, "Anchor point for ammo slots hotbar panel");
			ammoSlotsHotBarScale = config("Panels - Ammo slots", "Scale", 1f, "Relative size");
			ammoSlotsShowLabel = config("Panels - Ammo slots", "Show label", defaultValue: false, "Show slot label");
			ammoSlotsShowHintImage = config("Panels - Ammo slots", "Show hint image", defaultValue: true, "Show slot background hint image");
			ammoSlotsShowTooltip = config("Panels - Ammo slots", "Show help tooltip", defaultValue: true, "Show tooltip with slot info");
			ammoSlotsHideStackSize = config("Panels - Ammo slots", "Hide stack size in hotbar", defaultValue: false, "Hide stack size and left only current amount for consumable and equipable items in hotbar");
			ammoSlotsWidthInElements = config("Panels - Ammo slots", "Hotbar width in elements", 3, new ConfigDescription("How much ammo slots should be displayed in one line", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 3), Array.Empty<object>()));
			ammoSlotsFillDirectionUp = config("Panels - Ammo slots", "Hotbar fill direction is up", defaultValue: false, "Ammo slots hotbar will fill from bottom to top");
			ammoSlotsElementSpace = config("Panels - Ammo slots", "Hotbar element space", 70f, "Ammo slots hotbar element size. Defines space between elements as well.");
			ammoSlotsTooltipNameFormat = config("Panels - Ammo slots", "Tooltip name format", "{0} ({1})", "Where {0} is slot name and {1} is slot shortcut.");
			ammoSlotsStackColor = config<Color>("Panels - Ammo slots", "Stack size color", Color.clear, "Color of stack size label.");
			ammoSlotsPreventStackAll = config("Panels - Ammo slots", "Prevent Stack All", defaultValue: true, "Prevent items from ammo slots to be placed into container when Stack All feature is used.");
			ammoSlotsAllowThrowables = config("Panels - Ammo slots", "Allow throwables", defaultValue: true, "Should bombs and other throwables be allowed to be placed into ammo slots");
			ammoSlotsItemList = config("Panels - Ammo slots", "Custom item list", "", GetDescriptionSeparatedStrings("Comma separated list of items that should be treated as ammo items to fit in ammo slots\nWorks with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]"), synchronizedSetting: true);
			ammoSlotsItemBlackList = config("Panels - Ammo slots", "Custom item black list", "", GetDescriptionSeparatedStrings("Comma separated list of items that should NOT be treated as ammo items to fit in ammo slots\nWorks with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]"), synchronizedSetting: true);
			ammoSlotsItemList.SettingChanged += delegate
			{
				Slots.UpdateAmmoSlotCustomItemList();
			};
			ammoSlotsItemBlackList.SettingChanged += delegate
			{
				Slots.UpdateAmmoSlotCustomItemList();
			};
			ammoSlotsHotBarEnabled.SettingChanged += delegate
			{
				AmmoSlotsHotBar.MarkDirty();
			};
			ammoSlotsHotBarOffset.SettingChanged += delegate
			{
				AmmoSlotsHotBar.MarkDirty();
			};
			ammoSlotsHotBarAnchor.SettingChanged += delegate
			{
				AmmoSlotsHotBar.MarkDirty();
			};
			ammoSlotsHotBarScale.SettingChanged += delegate
			{
				AmmoSlotsHotBar.MarkDirty();
			};
			foodSlotsHotBarEnabled = config("Panels - Food slots", "Enabled", defaultValue: true, "Enable hotbar with Food slots [Synced with Server]", synchronizedSetting: true);
			foodSlotsHotBarOffset = config<Vector2>("Panels - Food slots", "Offset", new Vector2(230f, 84f), "On screen position of Food slots hotbar panel");
			foodSlotsHotBarAnchor = config("Panels - Food slots", "Offset Anchor", RectTransformExtensions.ElementAnchor.BottomLeft, "Anchor point for Food slots hotbar panel");
			foodSlotsHotBarScale = config("Panels - Food slots", "Scale", 1f, "Relative size");
			foodSlotsShowLabel = config("Panels - Food slots", "Show label", defaultValue: false, "Show slot label");
			foodSlotsShowHintImage = config("Panels - Food slots", "Show hint image", defaultValue: true, "Show slot background hint image");
			foodSlotsShowTooltip = config("Panels - Food slots", "Show help tooltip", defaultValue: true, "Show tooltip with slot info");
			foodSlotsHideStackSize = config("Panels - Food slots", "Hide stack size in hotbar", defaultValue: false, "Hide stack size and left only current amount for consumable and equipable items in hotbar");
			foodSlotsWidthInElements = config("Panels - Food slots", "Hotbar width in elements", 3, new ConfigDescription("How much Food slots should be displayed in one line", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 3), Array.Empty<object>()));
			foodSlotsFillDirectionUp = config("Panels - Food slots", "Hotbar fill direction is up", defaultValue: false, "Food slots hotbar will fill from bottom to top");
			foodSlotsElementSpace = config("Panels - Food slots", "Hotbar element space", 70f, "Food slots hotbar element size. Defines space between elements as well.");
			foodSlotsTooltipNameFormat = config("Panels - Food slots", "Tooltip name format", "{0} ({1})", "Where {0} is slot name and {1} is slot shortcut.");
			foodSlotsStackColor = config<Color>("Panels - Food slots", "Stack size color", Color.clear, "Color of stack size label.");
			foodSlotsPreventStackAll = config("Panels - Food slots", "Prevent Stack All", defaultValue: true, "Prevent items from food slots to be placed into container when Stack All feature is used.");
			foodSlotsItemList = config("Panels - Food slots", "Custom item list", "", GetDescriptionSeparatedStrings("Comma separated list of items that should be treated as ammo items to fit in food slots\nWorks with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]"), synchronizedSetting: true);
			foodSlotsItemBlackList = config("Panels - Food slots", "Custom item black list", "", GetDescriptionSeparatedStrings("Comma separated list of items that should NOT be treated as ammo items to fit in food slots\nWorks with prefab names (like BeltStrength) and item names (like $item_beltstrength). [Synced with Server]"), synchronizedSetting: true);
			foodSlotsItemList.SettingChanged += delegate
			{
				Slots.UpdateFoodSlotCustomItemList();
			};
			foodSlotsItemBlackList.SettingChanged += delegate
			{
				Slots.UpdateFoodSlotCustomItemList();
			};
			foodSlotsHotBarEnabled.SettingChanged += delegate
			{
				FoodSlotsHotBar.MarkDirty();
			};
			foodSlotsHotBarOffset.SettingChanged += delegate
			{
				FoodSlotsHotBar.MarkDirty();
			};
			foodSlotsHotBarAnchor.SettingChanged += delegate
			{
				FoodSlotsHotBar.MarkDirty();
			};
			foodSlotsHotBarScale.SettingChanged += delegate
			{
				FoodSlotsHotBar.MarkDirty();
			};
			equipmentSlotLabelAlignment = config<HorizontalAlignmentOptions>("Panels - Equipment slots - Label style", "Horizontal alignment", (HorizontalAlignmentOptions)1, "Horizontal alignment of text component in equipment slot label");
			equipmentSlotLabelWrappingMode = config<TextWrappingModes>("Panels - Equipment slots - Label style", "Text wrapping mode", (TextWrappingModes)1, "Size of text component in slot label");
			equipmentSlotLabelMargin = config<Vector4>("Panels - Equipment slots - Label style", "Margin", new Vector4(5f, 0f, 5f, 0f), "Margin: left top right bottom");
			equipmentSlotLabelFontSize = config<Vector2>("Panels - Equipment slots - Label style", "Font size", new Vector2(10f, 14f), "Min and Max text size in slot label");
			equipmentSlotLabelFontColor = config<Color>("Panels - Equipment slots - Label style", "Font color", new Color(0.596f, 0.816f, 1f), "Text color in slot label");
			equipmentSlotLabelAlignment.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			equipmentSlotLabelWrappingMode.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			equipmentSlotLabelMargin.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			equipmentSlotLabelFontSize.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			equipmentSlotLabelFontColor.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			quickSlotLabelAlignment = config<HorizontalAlignmentOptions>("Panels - Quick slots - Label style", "Horizontal alignment", (HorizontalAlignmentOptions)1, "Horizontal alignment of text component in slot label");
			quickSlotLabelWrappingMode = config<TextWrappingModes>("Panels - Quick slots - Label style", "Text wrapping mode", (TextWrappingModes)1, "Size of text component in slot label");
			quickSlotLabelMargin = config<Vector4>("Panels - Quick slots - Label style", "Margin", new Vector4(3f, 0f, 3f, 0f), "Margin: left top right bottom");
			quickSlotLabelFontSize = config<Vector2>("Panels - Quick slots - Label style", "Font size", new Vector2(10f, 14f), "Min and Max text size in slot label");
			quickSlotLabelFontColor = config<Color>("Panels - Quick slots - Label style", "Font color", new Color(0.596f, 0.816f, 1f), "Text color in slot label");
			quickSlotLabelAlignment.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			quickSlotLabelWrappingMode.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			quickSlotLabelMargin.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			quickSlotLabelFontSize.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			quickSlotLabelFontColor.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			ammoSlotLabelAlignment = config<HorizontalAlignmentOptions>("Panels - Ammo slots - Label style", "Horizontal alignment", (HorizontalAlignmentOptions)1, "Horizontal alignment of text component in slot label");
			ammoSlotLabelWrappingMode = config<TextWrappingModes>("Panels - Ammo slots - Label style", "Text wrapping mode", (TextWrappingModes)1, "Size of text component in slot label");
			ammoSlotLabelMargin = config<Vector4>("Panels - Ammo slots - Label style", "Margin", new Vector4(3f, 0f, 3f, 0f), "Margin: left top right bottom");
			ammoSlotLabelFontSize = config<Vector2>("Panels - Ammo slots - Label style", "Font size", new Vector2(10f, 14f), "Min and Max text size in slot label");
			ammoSlotLabelFontColor = config<Color>("Panels - Ammo slots - Label style", "Font color", new Color(0.596f, 0.816f, 1f), "Text color in slot label");
			ammoSlotLabelAlignment.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			ammoSlotLabelWrappingMode.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			ammoSlotLabelMargin.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			ammoSlotLabelFontSize.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			ammoSlotLabelFontColor.SettingChanged += delegate
			{
				EquipmentPanel.MarkDirty();
			};
			quickSlotGlobalKey1 = config("Progression - Global keys", "Quickslot 1", "defeated_gdking", "Comma-separated list of global keys and player unique keys. Slot will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotGlobalKey2 = config("Progression - Global keys", "Quickslot 2", "defeated_gdking", "Comma-separated list of global keys and player unique keys. Slot will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotGlobalKey3 = config("Progression - Global keys", "Quickslot 3", "defeated_bonemass", "Comma-separated list of global keys and player unique keys. Slot will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotGlobalKey4 = config("Progression - Global keys", "Quickslot 4", "defeated_dragon", "Comma-separated list of global keys and player unique keys. Slot will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotGlobalKey5 = config("Progression - Global keys", "Quickslot 5", "defeated_goblinking", "Comma-separated list of global keys and player unique keys. Slot will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotGlobalKey6 = config("Progression - Global keys", "Quickslot 6", "defeated_queen", "Comma-separated list of global keys and player unique keys. Slot will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			ammoSlotsGlobalKey = config("Progression - Global keys", "Ammo slots", "", "Comma-separated list of global keys and player unique keys. Slots will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			foodSlotsGlobalKey = config("Progression - Global keys", "Food slots", "", "Comma-separated list of global keys and player unique keys. Slots will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			miscSlotsGlobalKey = config("Progression - Global keys", "Misc slots", "", "Comma-separated list of global keys and player unique keys. Slots will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			utilitySlotGlobalKey1 = config("Progression - Global keys", "Extra utility slot 1", "defeated_bonemass", "Comma-separated list of global keys and player unique keys. Slot will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			utilitySlotGlobalKey2 = config("Progression - Global keys", "Extra utility slot 2", "defeated_goblinking", "Comma-separated list of global keys and player unique keys. Slot will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			utilitySlotGlobalKey3 = config("Progression - Global keys", "Extra utility slot 3", "defeated_queen", "Comma-separated list of global keys and player unique keys. Slot will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			utilitySlotGlobalKey4 = config("Progression - Global keys", "Extra utility slot 4", "defeated_queen", "Comma-separated list of global keys and player unique keys. Slot will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			ammoSlotsAvailableAfterDiscovery = config("Progression - Discovery", "Ammo slots", defaultValue: true, "Ammo slots will be active after acquiring first ammo item [Synced with Server]", synchronizedSetting: true);
			utilitySlotAvailableAfterDiscovery = config("Progression - Discovery", "Utility slots", defaultValue: true, "Utility slots will be active after acquiring first utility item [Synced with Server]", synchronizedSetting: true);
			foodSlotsAvailableAfterDiscovery = config("Progression - Discovery", "Food slots", defaultValue: true, "Food slots will be active after acquiring first food item [Synced with Server]", synchronizedSetting: true);
			equipmentSlotsAvailableAfterDiscovery = config("Progression - Discovery", "Equipment slots", defaultValue: true, "Corresponding equipment slot will be active after acquiring first item [Synced with Server]", synchronizedSetting: true);
			quickSlotGlobalKey1.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotGlobalKey2.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotGlobalKey3.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotGlobalKey4.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotGlobalKey5.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotGlobalKey6.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			ammoSlotsGlobalKey.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			foodSlotsGlobalKey.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			miscSlotsGlobalKey.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			utilitySlotGlobalKey1.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			utilitySlotGlobalKey2.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			utilitySlotGlobalKey3.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			utilitySlotGlobalKey4.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			ammoSlotsAvailableAfterDiscovery.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			utilitySlotAvailableAfterDiscovery.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			foodSlotsAvailableAfterDiscovery.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			equipmentSlotsAvailableAfterDiscovery.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			utilitySlotItemDiscovered1 = config("Progression - Items", "Extra utility slot 1", "Wishbone", "Comma-separated list of items. Slot will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			utilitySlotItemDiscovered2 = config("Progression - Items", "Extra utility slot 2", "Demister,GoldRubyRing,SilverRing", "Comma-separated list of items. Slot will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			utilitySlotItemDiscovered3 = config("Progression - Items", "Extra utility slot 3", "", "Comma-separated list of items. Slot will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			utilitySlotItemDiscovered4 = config("Progression - Items", "Extra utility slot 4", "", "Comma-separated list of items. Slot will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			utilitySlotItemDiscovered1.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			utilitySlotItemDiscovered2.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			utilitySlotItemDiscovered3.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			utilitySlotItemDiscovered4.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotItemDiscovered1 = config("Progression - Items", "Quickslot 1", "CryptKey", "Comma-separated list of items. Slot will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotItemDiscovered2 = config("Progression - Items", "Quickslot 2", "CryptKey", "Comma-separated list of items. Slot will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotItemDiscovered3 = config("Progression - Items", "Quickslot 3", "Wishbone", "Comma-separated list of items. Slot will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotItemDiscovered4 = config("Progression - Items", "Quickslot 4", "", "Comma-separated list of items. Slot will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotItemDiscovered5 = config("Progression - Items", "Quickslot 5", "", "Comma-separated list of items. Slot will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotItemDiscovered6 = config("Progression - Items", "Quickslot 6", "", "Comma-separated list of items. Slot will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			quickSlotItemDiscovered1.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotItemDiscovered2.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotItemDiscovered3.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotItemDiscovered4.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotItemDiscovered5.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			quickSlotItemDiscovered6.SettingChanged += delegate
			{
				EquipmentPanel.UpdatePanel();
			};
			extraRowPlayerKey1 = config("Progression - Inventory - Player keys", "Extra row 1", "GP_Bonemass", "Comma-separated list of Player unique keys. Extra inventory row will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowPlayerKey2 = config("Progression - Inventory - Player keys", "Extra row 2", "GP_Moder", "Comma-separated list of Player unique keys. Extra inventory row will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowPlayerKey3 = config("Progression - Inventory - Player keys", "Extra row 3", "GP_Yagluth", "Comma-separated list of Player unique keys. Extra inventory row will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowPlayerKey4 = config("Progression - Inventory - Player keys", "Extra row 4", "GP_Queen", "Comma-separated list of Player unique keys. Extra inventory row will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowPlayerKey5 = config("Progression - Inventory - Player keys", "Extra row 5", "GP_Fader", "Comma-separated list of Player unique keys. Extra inventory row will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowPlayerKeyMinus2 = config("Progression - Inventory - Player keys", "Regular row 2", "", "Comma-separated list of Player unique keys. Regular inventory row will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowPlayerKeyMinus1 = config("Progression - Inventory - Player keys", "Regular row 3", "GP_Eikthyr", "Comma-separated list of Player unique keys. Regular inventory row will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowPlayerKeyVanilla = config("Progression - Inventory - Player keys", "Regular row 4", "GP_TheElder", "Comma-separated list of Player unique keys. Regular inventory row will be active only if any key is enabled or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowPlayerKey1.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowPlayerKey2.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowPlayerKey3.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowPlayerKey4.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowPlayerKey5.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowPlayerKeyMinus2.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowPlayerKeyMinus1.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowPlayerKeyVanilla.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowItemDiscovered1 = config("Progression - Inventory - Items", "Extra row 1", "Wishbone", "Comma-separated list of items. Extra inventory row will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowItemDiscovered2 = config("Progression - Inventory - Items", "Extra row 2", "DragonTear", "Comma-separated list of items. Extra inventory row will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowItemDiscovered3 = config("Progression - Inventory - Items", "Extra row 3", "YagluthDrop", "Comma-separated list of items. Extra inventory row will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowItemDiscovered4 = config("Progression - Inventory - Items", "Extra row 4", "QueenDrop", "Comma-separated list of items. Extra inventory row will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowItemDiscovered5 = config("Progression - Inventory - Items", "Extra row 5", "FaderDrop", "Comma-separated list of items. Extra inventory row will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowItemDiscoveredMinus2 = config("Progression - Inventory - Items", "Regular row 2", "", "Comma-separated list of items. Regular inventory row will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowItemDiscoveredMinus1 = config("Progression - Inventory - Items", "Regular row 3", "HardAntler", "Comma-separated list of items. Regular inventory row will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowItemDiscoveredVanilla = config("Progression - Inventory - Items", "Regular row 4", "CryptKey", "Comma-separated list of items. Regular inventory row will be active only if any item is discovered or list is not set. [Synced with Server]", synchronizedSetting: true);
			extraRowItemDiscovered1.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowItemDiscovered2.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowItemDiscovered3.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowItemDiscovered4.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowItemDiscovered5.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowItemDiscoveredMinus2.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowItemDiscoveredMinus1.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			extraRowItemDiscoveredVanilla.SettingChanged += delegate
			{
				API.UpdateSlots();
			};
			epicLootMagicItemUnequippedAlpha = config("Mods compatibility", "EpicLoot unequipped item alpha", 0.2f, "Make unequipped enchanted item more visible in equipment panel by making its background image more transparent.");
			epicLootExcludeMiscItemsFromSacrifice = config("Mods compatibility", "EpicLoot exclude misc items from sacrifice", defaultValue: true, "If EpicLoot config ShowEquippedAndHotbarItemsInSacrificeTab is enabled then items in misc slots will be excluded from sacrifice.");
			bbhArrowsFindingAndCounting = config("Mods compatibility", "Fix best fit arrows finding when using BowsBeforeHoes Quiver", defaultValue: true, "Make BBH quiver respect item type and ammo type when game tries to find ammo and count it. Game restart is required after change.");
			recycle_N_ReclaimExcludeExtraSlots = config("Mods compatibility", "Prevent Recycle_N_Reclaim from recycling items in extra slots", defaultValue: true, "Recycle_N_Reclaim ignores items in hotbar only. Make it ignore items in extra slots");
			rebindConnectPanel = config<KeyCode>("Mods compatibility", "Rebind Connect Panel", (KeyCode)283, "Change the key which used to open Connect Panel with current data");
			reducedInventoryPanel1 = config("Mods compatibility - Reduced inventory size", "Side panels group 1", "Armor", "Names of transforms, comma-separated, which should be positioned in top group ");
			reducedInventoryPanel2 = config("Mods compatibility - Reduced inventory size", "Side panels group 2", "Jewelcrafting Synergy,Trash", "Names of transforms, comma-separated, which should be positioned in middle group");
			reducedInventoryPanel3 = config("Mods compatibility - Reduced inventory size", "Side panels group 3", "Weight", "Names of transforms, comma-separated, which should be positioned in bottom group");
			reducedInventoryPanelVisibility1 = config("Mods compatibility - Reduced inventory size", "Panels to show with 1 row", "Weight", "Names of transforms, comma-separated, which should be shown with given inventory size");
			reducedInventoryPanelVisibility2 = config("Mods compatibility - Reduced inventory size", "Panels to show with 2 rows", "Armor,Weight", "Names of transforms, comma-separated, which should be shown with given inventory size");
			reducedInventoryPanelVisibility3 = config("Mods compatibility - Reduced inventory size", "Panels to show with 3 rows", "Armor,Weight,Jewelcrafting Synergy,Trash", "Names of transforms, comma-separated, which should be shown with given inventory size");
			reducedInventoryPanel1.SettingChanged += delegate
			{
				EquipmentPanel.UpdateSidePanels();
			};
			reducedInventoryPanel2.SettingChanged += delegate
			{
				EquipmentPanel.UpdateSidePanels();
			};
			reducedInventoryPanel3.SettingChanged += delegate
			{
				EquipmentPanel.UpdateSidePanels();
			};
			reducedInventoryPanelVisibility1.SettingChanged += delegate
			{
				EquipmentPanel.UpdateSidePanels();
			};
			reducedInventoryPanelVisibility2.SettingChanged += delegate
			{
				EquipmentPanel.UpdateSidePanels();
			};
			reducedInventoryPanelVisibility3.SettingChanged += delegate
			{
				EquipmentPanel.UpdateSidePanels();
			};
			valheimRadialAddQuickSlots = config("Mods compatibility - Valheim Radial", "Add items from quick slots", defaultValue: true, "Add items from slots to valheim radial panel");
			valheimRadialAddFoodSlots = config("Mods compatibility - Valheim Radial", "Add items from food slots", defaultValue: true, "Add items from slots to valheim radial panel");
			valheimRadialAddAmmoSlots = config("Mods compatibility - Valheim Radial", "Add items from ammo slots", defaultValue: true, "Add items from slots to valheim radial panel");
			if (ammoSlotsHotBarOffset.Value == new Vector2(230f, 850f) && ammoSlotsHotBarAnchor.Value == RectTransformExtensions.ElementAnchor.BottomLeft)
			{
				ammoSlotsHotBarOffset.Value = (Vector2)((ConfigEntryBase)ammoSlotsHotBarOffset).DefaultValue;
			}
			if (foodSlotsHotBarOffset.Value == new Vector2(230f, 996f) && foodSlotsHotBarAnchor.Value == RectTransformExtensions.ElementAnchor.BottomLeft)
			{
				foodSlotsHotBarOffset.Value = (Vector2)((ConfigEntryBase)foodSlotsHotBarOffset).DefaultValue;
			}
			if (quickSlotsHotBarOffset.Value == new Vector2(230f, 923f) && quickSlotsHotBarAnchor.Value == RectTransformExtensions.ElementAnchor.BottomLeft)
			{
				quickSlotsHotBarOffset.Value = (Vector2)((ConfigEntryBase)quickSlotsHotBarOffset).DefaultValue;
			}
			CollectionExtensions.Do<ConfigEntry<KeyboardShortcut>>(GetHotkeysConfigs(), (Action<ConfigEntry<KeyboardShortcut>>)delegate(ConfigEntry<KeyboardShortcut> cfg)
			{
				cfg.SettingChanged += delegate
				{
					PreventSimilarHotkeys.FillSimilarHotkey();
				};
			});
		}

		internal static IEnumerable<ConfigEntry<KeyboardShortcut>> GetHotkeysConfigs()
		{
			return from kvp in (IEnumerable<KeyValuePair<ConfigDefinition, ConfigEntryBase>>)((BaseUnityPlugin)instance).Config
				where kvp.Value.SettingType == typeof(KeyboardShortcut)
				select kvp.Value as ConfigEntry<KeyboardShortcut>;
		}

		public static void LogDebug(object data)
		{
			if (loggingDebugEnabled.Value)
			{
				((BaseUnityPlugin)instance).Logger.LogInfo(data);
			}
		}

		public static void LogInfo(object data)
		{
			if (loggingEnabled.Value)
			{
				((BaseUnityPlugin)instance).Logger.LogInfo(data);
			}
		}

		public static void LogMessage(object data)
		{
			((BaseUnityPlugin)instance).Logger.LogMessage(data);
		}

		public static void LogWarning(object data)
		{
			((BaseUnityPlugin)instance).Logger.LogWarning(data);
		}

		public static void LogCurrentLogLevel()
		{
			LogInfo($"Logging: Info {loggingEnabled.Value}, Debug {loggingDebugEnabled.Value}");
		}

		private ConfigEntry<T> config<T>(string group, string name, T defaultValue, ConfigDescription description, bool synchronizedSetting = false)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, defaultValue, description);
			SyncedConfigEntry<T> syncedConfigEntry = configSync.AddConfigEntry<T>(val);
			syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
			return val;
		}

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

		private void LoadIcons()
		{
			LoadIcon("ammoslot.png", ref EquipmentPanel.ammoSlot);
			LoadIcon("miscslot.png", ref EquipmentPanel.miscSlot);
			LoadIcon("quickslot.png", ref EquipmentPanel.quickSlot);
			LoadIcon("lightenedslot.png", ref EquipmentPanel.lightenedSlot);
			LoadIcon("background.png", ref EquipmentPanel.background);
		}

		internal static void LoadIcon(string filename, ref Sprite icon)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			//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)
			Texture2D tex = new Texture2D(2, 2);
			if (LoadTexture(filename, ref tex))
			{
				icon = Sprite.Create(tex, new Rect(0f, 0f, (float)((Texture)tex).width, (float)((Texture)tex).height), Vector2.zero);
			}
			else
			{
				Object.Destroy((Object)(object)tex);
			}
		}

		internal static bool LoadTextureFromConfigDirectory(string filename, ref Texture2D tex)
		{
			string path = Path.Combine(configDirectory, filename);
			if (!File.Exists(path))
			{
				return false;
			}
			LogInfo("Loaded image from config folder: " + filename);
			return ImageConversion.LoadImage(tex, File.ReadAllBytes(path));
		}

		internal static bool LoadTexture(string filename, ref Texture2D tex)
		{
			if (LoadTextureFromConfigDirectory(filename, ref tex))
			{
				return true;
			}
			((Object)tex).name = Path.GetFileNameWithoutExtension(filename);
			return ImageConversion.LoadImage(tex, GetEmbeddedFileData(filename), true);
		}

		internal static byte[] GetEmbeddedFileData(string filename)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string text = executingAssembly.GetManifestResourceNames().SingleOrDefault((string str) => str.EndsWith(filename));
			if (Utility.IsNullOrWhiteSpace(text))
			{
				return null;
			}
			Stream manifestResourceStream = executingAssembly.GetManifestResourceStream(text);
			byte[] array = new byte[manifestResourceStream.Length];
			manifestResourceStream.Read(array, 0, array.Length);
			return array;
		}

		internal static bool IsAwaitingForSlotsUpdate()
		{
			return instance.slotsUpdater != null;
		}

		internal void StartSlotsUpdateNextFrame()
		{
			if (!IsAwaitingForSlotsUpdate())
			{
				slotsUpdater = UpdateSlotsNextFrame();
				((MonoBehaviour)instance).StartCoroutine(slotsUpdater);
			}
		}

		[IteratorStateMachine(typeof(<UpdateSlotsNextFrame>d__235))]
		private IEnumerator UpdateSlotsNextFrame()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateSlotsNextFrame>d__235(0)
			{
				<>4__this = this
			};
		}
	}
	public static class Slots
	{
		public class Slot
		{
			private readonly string _id;

			private readonly Func<string> _getName;

			private readonly Func<KeyboardShortcut> _getShortcut;

			private readonly Func<string> _getShortcutText;

			private readonly Func<ItemData, bool> _itemIsValid;

			private readonly Func<bool> _isActive;

			private int _index = -1;

			private Vector2 _position;

			private Vector2i _gridPos = emptyPosition;

			public string ID => _id;

			public string Name => (_getName != null) ? Localization.instance.Localize(_getName()) : "";

			public bool IsActive => _isActive == null || _isActive();

			public Vector2 Position => _position;

			public Vector2i GridPosition => _gridPos;

			public int Index => _index;

			public int EquipmentIndex => IsCustomSlot ? (_index + 200) : ((IsTrinketSlot || IsVanillaSlot) ? _index : (_index + 100));

			public bool IsHotkeySlot => _getShortcut != null;

			public bool IsQuickSlot => _index < 6;

			public bool IsMiscSlot => 6 <= _index && _index <= 7;

			public bool IsAmmoSlot => 8 <= _index && _index <= 10;

			public bool IsFoodSlot => 11 <= _index && _index <= 13;

			public bool IsVanillaSlot => 16 <= _index && _index <= 20;

			public bool IsTrinketSlot => _index == 23;

			public bool IsEquipmentSlot => _index > 13;

			public bool IsCustomSlot => _index >= CustomSlot.customSlotStartingIndex;

			public bool IsEmptySlot => _id == "Empty";

			public ItemData Item
			{
				get
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					if (PlayerInventory == null || _gridPos == emptyPosition)
					{
						return null;
					}
					if (cachedItems.TryGetValue(_gridPos, out var value))
					{
						return value;
					}
					return CacheItem();
				}
			}

			public bool IsFree => Item == null;

			internal void SetPosition(Vector2 newPosition)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if (_position != (_position = newPosition))
				{
					EquipmentPanel.MarkDirty();
				}
			}

			internal void UpdateGridPosition()
			{
				//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_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)
				ItemData item = Item;
				_gridPos = new Vector2i(_index % InventoryWidth, _index / InventoryWidth + InventoryHeightPlayer);
				if (item != null)
				{
					item.m_gridPos = _gridPos;
				}
			}

			internal void SwapIndexWith(Slot slot)
			{
				CacheItem();
				slot.CacheItem();
				int index = slot._index;
				int index2 = _index;
				_index = index;
				slot._index = index2;
				UpdateGridPosition();
				slot.UpdateGridPosition();
			}

			internal void SetSlotIndex(int index)
			{
				_index = index;
			}

			public bool IsVanillaEquipment()
			{
				return IsVanillaSlotID(_id);
			}

			public bool IsShortcutDown()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				int result;
				if (IsActive && _getShortcut != null)
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null && ((Character)localPlayer).TakeInput())
					{
						result = (IsShortcutDown(_getShortcut()) ? 1 : 0);
						goto IL_0036;
					}
				}
				result = 0;
				goto IL_0036;
				IL_0036:
				return (byte)result != 0;
			}

			public bool IsShortcutDownWithItem()
			{
				return IsShortcutDown() && Item != null;
			}

			public KeyboardShortcut GetShortcut()
			{
				//IL_0015: 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)
				return (_getShortcut == null) ? KeyboardShortcut.Empty : _getShortcut();
			}

			public string GetShortcutText()
			{
				return (_getShortcutText == null) ? Name : Localization.instance.Localize(_getShortcutText());
			}

			internal ItemData CacheItem()
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				if (PlayerInventory == null)
				{
					return null;
				}
				ItemData itemAt = PlayerInventory.GetItemAt(_gridPos.x, _gridPos.y);
				cachedItems[_gridPos] = itemAt;
				return itemAt;
			}

			public bool ItemFits(ItemData item)
			{
				return item != null && IsActive && (_itemIsValid == null || _itemIsValid(item));
			}

			public bool IsFreeQuickSlot()
			{
				return IsQuickSlot && IsActive && IsFree;
			}

			public void ClearItemCache()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				cachedItems.Remove(_gridPos);
			}

			public Slot(string slotID, int slotIndex, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive)
			{
				//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)
				_id = slotID;
				_index = slotIndex;
				_getName = getName;
				_itemIsValid = itemIsValid;
				_isActive = isActive;
			}

			public Slot(string slotID, int slotIndex, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive, Func<KeyboardShortcut> getShortcut, Func<string> getShortcutText)
			{
				//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)
				_id = slotID;
				_index = slotIndex;
				_getName = getName;
				_itemIsValid = itemIsValid;
				_getShortcut = getShortcut;
				_getShortcutText = getShortcutText;
				_isActive = isActive;
			}

			public override string ToString()
			{
				return ((Name == "") ? ID : Name) + (IsActive ? "" : " (inactive)");
			}

			public static bool IsShortcutDown(KeyboardShortcut shortcut)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return PreventSimilarHotkeys.IsShortcutDown(shortcut);
			}

			public static bool IsVanillaSlotID(string id)
			{
				return vanillaSlots.Contains(id);
			}
		}

		internal static class CustomSlot
		{
			internal static int customSlotStartingIndex = 24;

			internal static bool TryAddNewSlotAfter(string[] slotIDs, string slotID, Func<string> getName = null, Func<ItemData, bool> itemIsValid = null, Func<bool> isActive = null)
			{
				Slot slot2 = slots.LastOrDefault((Slot slot) => slot.IsCustomSlot && slotIDs.Contains(slot.ID));
				if (slot2 != null)
				{
					return TryAddNewSlotWithIndex(slotID, slot2.Index, getName, itemIsValid, isActive);
				}
				return TryAddNewSlotWithIndex(slotID, -1, getName, itemIsValid, isActive);
			}

			internal static bool TryAddNewSlotWithIndex(string slotID, int slotIndex = -1, Func<string> getName = null, Func<ItemData, bool> itemIsValid = null, Func<bool> isActive = null)
			{
				if (slots.Any((Slot slot) => slot.ID == GetSlotID(slotID)))
				{
					return true;
				}
				int index = ((slotIndex < 0) ? Array.FindIndex(slots, (Slot slot) => slot.IsCustomSlot && slot.IsEmptySlot) : Mathf.Clamp(slotIndex + customSlotStartingIndex, customSlotStartingIndex, slots.Length - 1));
				if (index < 0)
				{
					ExtraSlots.LogWarning("Error adding new slot " + slotID + ". Too many custom slots.");
					return false;
				}
				if (index == slots.Length - 1 && !slots[index].IsEmptySlot)
				{
					ExtraSlots.LogWarning($"Error adding new slot {slotID} with index {index}. Last available custom slot is taken.");
					return false;
				}
				if (!slots.Any((Slot slot) => slot.Index >= index && slot.IsEmptySlot))
				{
					ExtraSlots.LogWarning($"Error adding new slot {slotID} with index {index}. All following slots are taken.");
					return false;
				}
				if (slots[index].IsEmptySlot)
				{
					slots[index] = new Slot(GetSlotID(slotID), index, getName, itemIsValid, isActive);
				}
				else
				{
					InsertSlot(index, GetSlotID(slotID), getName, itemIsValid, isActive);
				}
				API.UpdateSlots();
				return slots[index] != null && !slots[index].IsEmptySlot;
			}

			internal static bool TryRemoveSlot(string slotID)
			{
				//IL_0179: 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_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				int num = Array.FindIndex(slots, (Slot slot) => slot.IsCustomSlot && slot.ID == GetSlotID(slotID));
				if (num == -1)
				{
					return false;
				}
				for (int i = num; i < slots.Length; i++)
				{
					slots[i].CacheItem();
				}
				ItemData item2 = slots[num].Item;
				for (int j = num + 1; j < slots.Length; j++)
				{
					slots[j - 1] = slots[j];
					slots[j - 1].SetSlotIndex(j - 1);
				}
				slots[slots.Length - 1] = new Slot("Empty", slots.Length - 1, null, (ItemData item) => false, () => false);
				for (int k = num; k < slots.Length; k++)
				{
					slots[k].UpdateGridPosition();
				}
				if (item2 != null && TryFindFreeSlotForItem(item2, out var slot2))
				{
					ExtraSlots.LogInfo($"While removing slot {slotID} item {item2.m_shared.m_name} from {item2.m_gridPos} was moved into first empty slot {slot2} {slot2.GridPosition}");
					item2.m_gridPos = slot2.GridPosition;
				}
				API.UpdateSlots();
				return true;
			}

			internal static void InsertSlot(int startIndex, string slotID, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive)
			{
				int num = Array.FindIndex(slots, (Slot slot) => slot.Index >= startIndex && slot.IsEmptySlot);
				ExtraSlots.LogInfo($"InsertSlot {slotID} at {startIndex} empty slot found {num}");
				if (num == -1)
				{
					ExtraSlots.LogWarning("Error trying to find empty slot to stop slots shifting after " + startIndex);
					return;
				}
				for (int i = startIndex; i < num; i++)
				{
					slots[i].CacheItem();
				}
				for (int num2 = num; num2 > startIndex; num2--)
				{
					slots[num2] = slots[num2 - 1];
					slots[num2].SetSlotIndex(num2);
				}
				slots[startIndex] = new Slot(GetSlotID(slotID), startIndex, getName, itemIsValid, isActive);
				for (int num3 = num; num3 >= startIndex; num3--)
				{
					slots[num3].UpdateGridPosition();
				}
			}

			internal static string GetSlotID(string slotID)
			{
				return "Custom" + slotID;
			}
		}

		public const string helmetSlotID = "Helmet";

		public const string legsSlotID = "Legs";

		public const string utilitySlotID = "Utility";

		public const string chestSlotID = "Chest";

		public const string shoulderSlotID = "Shoulder";

		public const string extraUtilitySlotID = "ExtraUtility";

		public const string quickSlotID = "Quick";

		public const string foodSlotID = "Food";

		public const string ammoSlotID = "Ammo";

		public const string miscSlotID = "Misc";

		public const string customSlotID = "Custom";

		public const string emptySlotID = "Empty";

		public const string trinketSlotID = "Trinket";

		public static readonly Vector2i emptyPosition = new Vector2i(-1, -1);

		public static readonly string VanillaOrder = "Helmet,Chest,Legs,Shoulder,Utility,Trinket";

		public static readonly HashSet<string> vanillaSlots = new HashSet<string>(VanillaOrder.Split(','));

		public static readonly HashSet<string> miscItemsList = new HashSet<string>();

		public static readonly HashSet<string> ammoItemsList = new HashSet<string>();

		public static readonly HashSet<string> foodItemsList = new HashSet<string>();

		public static readonly HashSet<string> miscItemsBlackList = new HashSet<string>();

		public static readonly HashSet<string> ammoItemsBlackList = new HashSet<string>();

		public static readonly HashSet<string> foodItemsBlackList = new HashSet<string>();

		public const string customKeyPlayerID = "ExtraSlotsEquippedBy";

		public const string customKeySlotID = "ExtraSlotsEquippedSlot";

		internal const string customKeyWeaponShield = "ExtraSlotsEquippedWeaponShield";

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

		public static readonly Slot[] slots = new Slot[40];

		public static readonly Dictionary<Vector2i, ItemData> cachedItems = new Dictionary<Vector2i, ItemData>();

		public const int VanillaInventoryHeight = 4;

		public const int VanillaInventoryWidth = 8;

		public const int minAmountOfExtraRows = -3;

		public static Player loadedPlayer;

		public static PlayerProfile CurrentPlayerProfile
		{
			get
			{
				Game instance = Game.instance;
				return ((instance != null) ? instance.GetPlayerProfile() : null) ?? FejdStartup.instance?.m_profiles[FejdStartup.instance.m_profileIndex];
			}
		}

		public static Player CurrentPlayer
		{
			get
			{
				object obj = Player.m_localPlayer;
				if (obj == null)
				{
					obj = EquipmentAndQuickSlotsCompat.playerToLoad;
					if (obj == null)
					{
						obj = loadedPlayer;
						if (obj == null)
						{
							FejdStartup instance = FejdStartup.instance;
							obj = ((instance != null) ? instance.GetPreviewPlayer() : null);
						}
					}
				}
				return (Player)obj;
			}
		}

		public static Inventory PlayerInventory
		{
			get
			{
				Player currentPlayer = CurrentPlayer;
				return (currentPlayer != null) ? ((Humanoid)currentPlayer).GetInventory() : null;
			}
		}

		public static int ExtraRowsPlayer => GetExtraRows();

		public static int InventoryWidth => (PlayerInventory != null) ? PlayerInventory.GetWidth() : 8;

		public static int InventoryHeightPlayer => 4 + ExtraRowsPlayer;

		public static int InventoryHeightFull => InventoryHeightPlayer + GetTargetInventoryHeight(slots.Length, InventoryWidth);

		public static int InventorySizeVanilla => 4 * InventoryWidth;

		public static int InventorySizePlayer => InventoryHeightPlayer * InventoryWidth;

		public static int InventorySizeFull => InventoryHeightFull * InventoryWidth;

		public static int InventorySizeActive => InventorySizePlayer + slots.Count((Slot slot) => slot.IsActive);

		public static int GetTargetInventoryHeight(int inventorySize, int inventoryWidth)
		{
			return GetExtraRowsForItemsToFit(inventorySize, inventoryWidth);
		}

		public static int GetExtraRowsForItemsToFit(int itemsAmount, int rowWidth)
		{
			return (itemsAmount - 1) / rowWidth + 1;
		}

		public static bool IsValidPlayer(Character character)
		{
			return (Object)(object)character != (Object)null && character.IsPlayer() && (Object)(object)Player.m_localPlayer == (Object)(object)character && Object.op_Implicit((Object)(object)character.m_nview) && character.m_nview.IsValid() && character.m_nview.IsOwner();
		}

		public static int GetEquipmentSlotsCount()
		{
			return slots.Count((Slot slot) => slot.IsEquipmentSlot && slot.IsActive);
		}

		public static int GetQuickSlotsCount()
		{
			return slots.Count((Slot slot) => slot.IsQuickSlot && slot.IsActive);
		}

		public static Slot[] GetEquipmentSlots(bool onlyActive = true)
		{
			return (from slot in slots
				where slot.IsEquipmentSlot && (!onlyActive || slot.IsActive)
				orderby slot.EquipmentIndex
				select slot).ToArray();
		}

		public static Slot[] GetQuickSlots()
		{
			return Array.FindAll(slots, (Slot slot) => slot.IsQuickSlot);
		}

		public static Slot[] GetFoodSlots()
		{
			return Array.FindAll(slots, (Slot slot) => slot.IsFoodSlot);
		}

		public static Slot[] GetAmmoSlots()
		{
			return Array.FindAll(slots, (Slot slot) => slot.IsAmmoSlot);
		}

		public static Slot[] GetMiscSlots()
		{
			return Array.FindAll(slots, (Slot slot) => slot.IsMiscSlot);
		}

		public static Slot[] GetCustomSlots(bool onlyActive = true)
		{
			return Array.FindAll(slots, (Slot slot) => slot.IsCustomSlot && (!onlyActive || slot.IsActive));
		}

		public static Slot[] GetInactiveSlots()
		{
			return Array.FindAll(slots, (Slot slot) => !slot.IsActive);
		}

		public static bool TryGetSavedPlayerSlot(ItemData item, out Slot slot)
		{
			slot = null;
			if (item.m_customData.TryGetValue("ExtraSlotsEquippedBy", out var value) && item.m_customData.TryGetValue("ExtraSlotsEquippedSlot", out var value2))
			{
				string text = value;
				PlayerProfile currentPlayerProfile = CurrentPlayerProfile;
				if (text == ((currentPlayerProfile != null) ? currentPlayerProfile.GetPlayerID().ToString() : null) && (slot = API.FindSlot(value2)) != null)
				{
					ExtraSlots.LogDebug($"Previous slot {slot} found for item {item.m_shared.m_name}");
					return true;
				}
			}
			return false;
		}

		public static bool TryFindFreeSlotForItem(ItemData item, out Slot slot)
		{
			slot = null;
			if (item == null)
			{
				return false;
			}
			if (TryGetSavedPlayerSlot(item, out var slot2) && slot2.IsActive && slot2.ItemFits(item) && (slot2.IsFree || item == slot2.Item))
			{
				slot = slot2;
				return true;
			}
			int num = Array.FindIndex(slots, (Slot slot) => slot.IsCustomSlot && slot.IsActive && slot.IsFree && slot.ItemFits(item));
			if (num == -1)
			{
				num = Array.FindIndex(slots, (Slot slot) => slot.IsActive && slot.IsFree && slot.ItemFits(item));
			}
			if (num == -1)
			{
				return false;
			}
			slot = slots[num];
			return true;
		}

		public static bool TryFindFreeEquipmentSlotForItem(ItemData item, out Slot slot)
		{
			slot = null;
			if (item == null)
			{
				return false;
			}
			if (TryGetSavedPlayerSlot(item, out var slot2) && slot2.IsActive && slot2.IsEquipmentSlot && slot2.ItemFits(item) && (slot2.IsFree || item == slot2.Item))
			{
				slot = slot2;
				return true;
			}
			bool isCustomSlotItem = IsCustomSlotItem(item);
			slot = GetEquipmentSlots().FirstOrDefault((Slot slot) => (!isCustomSlotItem || slot.IsCustomSlot) && slot.IsFree && slot.ItemFits(item));
			return slot != null;
		}

		public static bool TryFindFirstUnequippedSlotForItem(ItemData item, out Slot slot)
		{
			slot = null;
			if (item == null)
			{
				return false;
			}
			if (TryGetSavedPlayerSlot(item, out var slot2) && slot2.IsActive && slot2.IsEquipmentSlot && slot2.ItemFits(item) && ((slot2.Item != null && !((Humanoid)CurrentPlayer).IsItemEquiped(slot2.Item)) || item == slot2.Item))
			{
				slot = slot2;
				return true;
			}
			bool isCustomSlotItem = IsCustomSlotItem(item);
			slot = GetEquipmentSlots().FirstOrDefault((Slot slot) => (!isCustomSlotItem || slot.IsCustomSlot) && !slot.IsFree && slot.ItemFits(item) && !((Humanoid)CurrentPlayer).IsItemEquiped(slot.Item));
			return slot != null;
		}

		public static bool TryMakeFreeSpaceInPlayerInventory(bool tryFindRegularInventorySlot, out Vector2i gridPos)
		{
			//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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0174: 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_01a1: 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_01af: 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_01ef: 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_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			gridPos = emptyPosition;
			itemsInGridOrder.Clear();
			if (tryFindRegularInventorySlot)
			{
				for (int num = InventoryHeightPlayer - 1; num >= 0; num--)
				{
					for (int num2 = InventoryWidth - 1; num2 >= 0; num2--)
					{
						ItemData itemAt = PlayerInventory.GetItemAt(num2, num);
						if (itemAt == null)
						{
							return (gridPos = new Vector2i(num2, num)) != emptyPosition;
						}
						itemsInGridOrder.Add(itemAt);
					}
				}
			}
			else
			{
				itemsInGridOrder.AddRange(from item in PlayerInventory.GetAllItemsInGridOrder()
					where item.m_gridPos.y < InventoryHeightPlayer
					orderby item.m_gridPos.y descending, item.m_gridPos.x descending
					select item);
			}
			ClearCachedItems();
			foreach (ItemData item in itemsInGridOrder)
			{
				if (TryFindFreeEquipmentSlotForItem(item, out var slot))
				{
					ExtraSlots.LogDebug($"In attempt to create free space {item.m_shared.m_name} from {item.m_gridPos} was moved into equipment slot {slot} {slot.GridPosition}");
					gridPos = item.m_gridPos;
					item.m_gridPos = slot.GridPosition;
					return true;
				}
				if (TryFindFreeSlotForItem(item, out var slot2))
				{
					ExtraSlots.LogDebug($"In attempt to create free space {item.m_shared.m_name} from {item.m_gridPos} was moved into free slot {slot2} {slot2.GridPosition}");
					gridPos = item.m_gridPos;
					item.m_gridPos = slot2.GridPosition;
					return true;
				}
			}
			return false;
		}

		public static bool HaveEmptyQuickSlot()
		{
			return slots.Any((Slot slot) => slot.IsFreeQuickSlot());
		}

		public static int GetEmptyQuickSlots()
		{
			return slots.Count((Slot slot) => slot.IsFreeQuickSlot());
		}

		public static Vector2i FindEmptyQuickSlot()
		{
			//IL_0011: 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)
			Slot slot;
			return TryFindEmptyQuickSlot(out slot) ? slot.GridPosition : emptyPosition;
		}

		public static bool TryFindEmptyQuickSlot(out Slot slot)
		{
			slot = slots.FirstOrDefault((Slot slot) => slot.IsFreeQuickSlot());
			return slot != null;
		}

		internal static void SaveLastEquippedSlotsToItems()
		{
			if (!Object.op_Implicit((Object)(object)Game.instance))
			{
				return;
			}
			long playerID = Game.instance.GetPlayerProfile().GetPlayerID();
			int num = 0;
			Slot[] array = slots;
			foreach (Slot slot in array)
			{
				ItemData item = slot.Item;
				if (item != null)
				{
					item.m_customData["ExtraSlotsEquippedBy"] = playerID.ToString();
					item.m_customData["ExtraSlotsEquippedSlot"] = slot.ID;
					num++;
				}
			}
			if (num > 0)
			{
				ExtraSlots.LogDebug($"Last slot was saved for {num} items at extra slots. Player ID: {playerID}");
			}
		}

		internal static void SaveLastEquippedWeaponShieldToItems(Player player)
		{
			long playerID = Game.instance.GetPlayerProfile().GetPlayerID();
			if (((Humanoid)player).LeftItem != null)
			{
				((Humanoid)player).LeftItem.m_customData["ExtraSlotsEquippedWeaponShield"] = playerID.ToString();
			}
			if (((Humanoid)player).RightItem != null)
			{
				((Humanoid)player).RightItem.m_customData["ExtraSlotsEquippedWeaponShield"] = playerID.ToString();
			}
			if (((Humanoid)player).LeftItem != null || ((Humanoid)player).RightItem != null)
			{
				ExtraSlots.LogDebug(string.Format("Last equpped weapon/shield was saved to {0}{1}. Player ID: {2}", (((Humanoid)player).LeftItem != null) ? (((Humanoid)player).LeftItem.m_shared.m_name + " ") : "", (((Humanoid)player).RightItem != null) ? ((Humanoid)player).RightItem.m_shared.m_name : "", playerID));
			}
		}

		internal static void PruneLastEquippedSlotFromItem(ItemData item)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			PruneLastEquippeWeaponShieldFromItem(item);
			if (item != null && item.m_customData.ContainsKey("ExtraSlotsEquippedSlot"))
			{
				item.m_customData.Remove("ExtraSlotsEquippedBy");
				item.m_customData.Remove("ExtraSlotsEquippedSlot");
				ExtraSlots.LogDebug($"{item.m_shared.m_name} {item.m_gridPos} pruned last taken slot");
			}
		}

		internal static void PruneLastEquippeWeaponShieldFromItem(ItemData item)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (item != null && item.m_customData.Remove("ExtraSlotsEquippedWeaponShield"))
			{
				ExtraSlots.LogDebug($"{item.m_shared.m_name} {item.m_gridPos} pruned last equipped weapon/shield");
			}
		}

		private static string KeyTextOr(string customText, KeyboardShortcut key, string fallbackLabel)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return (!string.IsNullOrEmpty(customText)) ? customText : (((object)(KeyboardShortcut)(ref key)).Equals((object?)KeyboardShortcut.Empty) ? fallbackLabel : ((object)(KeyboardShortcut)(ref key)).ToString());
		}

		public static string GetQuickSlot1Text()
		{
			//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)
			string? result;
			if (!string.IsNullOrEmpty(ExtraSlots.quickSlotHotKey1Text.Value))
			{
				result = ExtraSlots.quickSlotHotKey1Text.Value;
			}
			else
			{
				KeyboardShortcut value = ExtraSlots.quickSlotHotKey1.Value;
				result = ((object)(KeyboardShortcut)(ref value)).ToString();
			}
			return result;
		}

		public static string GetQuickSlot2Text()
		{
			//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)
			string? result;
			if (!string.IsNullOrEmpty(ExtraSlots.quickSlotHotKey2Text.Value))
			{
				result = ExtraSlots.quickSlotHotKey2Text.Value;
			}
			else
			{
				KeyboardShortcut value = ExtraSlots.quickSlotHotKey2.Value;
				result = ((object)(KeyboardShortcut)(ref value)).ToString();
			}
			return result;
		}

		public static string GetQuickSlot3Text()
		{
			//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)
			string? result;
			if (!string.IsNullOrEmpty(ExtraSlots.quickSlotHotKey3Text.Value))
			{
				result = ExtraSlots.quickSlotHotKey3Text.Value;
			}
			else
			{
				KeyboardShortcut value = ExtraSlots.quickSlotHotKey3.Value;
				result = ((object)(KeyboardShortcut)(ref value)).ToString();
			}
			return result;
		}

		public static string GetQuickSlot4Text()
		{
			//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)
			string? result;
			if (!string.IsNullOrEmpty(ExtraSlots.quickSlotHotKey4Text.Value))
			{
				result = ExtraSlots.quickSlotHotKey4Text.Value;
			}
			else
			{
				KeyboardShortcut value = ExtraSlots.quickSlotHotKey4.Value;
				result = ((object)(KeyboardShortcut)(ref value)).ToString();
			}
			return result;
		}

		public static string GetQuickSlot5Text()
		{
			//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)
			string? result;
			if (!string.IsNullOrEmpty(ExtraSlots.quickSlotHotKey5Text.Value))
			{
				result = ExtraSlots.quickSlotHotKey5Text.Value;
			}
			else
			{
				KeyboardShortcut value = ExtraSlots.quickSlotHotKey5.Value;
				result = ((object)(KeyboardShortcut)(ref value)).ToString();
			}
			return result;
		}

		public static string GetQuickSlot6Text()
		{
			//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)
			string? result;
			if (!string.IsNullOrEmpty(ExtraSlots.quickSlotHotKey6Text.Value))
			{
				result = ExtraSlots.quickSlotHotKey6Text.Value;
			}
			else
			{
				KeyboardShortcut value = ExtraSlots.quickSlotHotKey6.Value;
				result = ((object)(KeyboardShortcut)(ref value)).ToString();
			}
			return result;
		}

		private static string GetQuickSlot1Label()
		{
			return ExtraSlots.quickSlotsShowLabel.Value ? GetQuickSlot1Text() : "";
		}

		private static string GetQuickSlot2Label()
		{
			return ExtraSlots.quickSlotsShowLabel.Value ? GetQuickSlot2Text() : "";
		}

		private static string GetQuickSlot3Label()
		{
			return ExtraSlots.quickSlotsShowLabel.Value ? GetQuickSlot3Text() : "";
		}

		private static string GetQuickSlot4Label()
		{
			return ExtraSlots.quickSlotsShowLabel.Value ? GetQuickSlot4Text() : "";
		}

		private static string GetQuickSlot5Label()
		{
			return ExtraSlots.quickSlotsShowLabel.Value ? GetQuickSlot5Text() : "";
		}

		private static string GetQuickSlot6Label()
		{
			return ExtraSlots.quickSlotsShowLabel.Value ? GetQuickSlot6Text() : "";
		}

		private static bool IsQuickSlot1Available()
		{
			return IsQuickSlotAvailable(0);
		}

		private static bool IsQuickSlot2Available()
		{
			return IsQuickSlotAvailable(1);
		}

		private static bool IsQuickSlot3Available()
		{
			return IsQuickSlotAvailable(2);
		}

		private static bool IsQuickSlot4Available()
		{
			return IsQuickSlotAvailable(3);
		}

		private static bool IsQuickSlot5Available()
		{
			return IsQuickSlotAvailable(4);
		}

		private static bool IsQuickSlot6Available()
		{
			return IsQuickSlotAvailable(5);
		}

		private static KeyboardShortcut GetQuickSlot1Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.quickSlotHotKey1.Value;
		}

		private static KeyboardShortcut GetQuickSlot2Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.quickSlotHotKey2.Value;
		}

		private static KeyboardShortcut GetQuickSlot3Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.quickSlotHotKey3.Value;
		}

		private static KeyboardShortcut GetQuickSlot4Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.quickSlotHotKey4.Value;
		}

		private static KeyboardShortcut GetQuickSlot5Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.quickSlotHotKey5.Value;
		}

		private static KeyboardShortcut GetQuickSlot6Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.quickSlotHotKey6.Value;
		}

		public static string GetAmmoSlot1Text()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return KeyTextOr(ExtraSlots.ammoSlotHotKey1Text.Value, ExtraSlots.ammoSlotHotKey1.Value, "$exsl_slot_ammo_label");
		}

		public static string GetAmmoSlot2Text()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return KeyTextOr(ExtraSlots.ammoSlotHotKey2Text.Value, ExtraSlots.ammoSlotHotKey2.Value, "$exsl_slot_ammo_label");
		}

		public static string GetAmmoSlot3Text()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return KeyTextOr(ExtraSlots.ammoSlotHotKey3Text.Value, ExtraSlots.ammoSlotHotKey3.Value, "$exsl_slot_ammo_label");
		}

		public static string GetFoodSlot1Text()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return KeyTextOr(ExtraSlots.foodSlotHotKey1Text.Value, ExtraSlots.foodSlotHotKey1.Value, "$exsl_slot_food_label");
		}

		public static string GetFoodSlot2Text()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return KeyTextOr(ExtraSlots.foodSlotHotKey2Text.Value, ExtraSlots.foodSlotHotKey2.Value, "$exsl_slot_food_label");
		}

		public static string GetFoodSlot3Text()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return KeyTextOr(ExtraSlots.foodSlotHotKey3Text.Value, ExtraSlots.foodSlotHotKey3.Value, "$exsl_slot_food_label");
		}

		private static string GetMiscSlotLabel()
		{
			return ExtraSlots.miscSlotsShowLabel.Value ? "$exsl_slot_misc_label" : "";
		}

		private static string GetAmmoSlot1Label()
		{
			return ExtraSlots.ammoSlotsShowLabel.Value ? GetAmmoSlot1Text() : "";
		}

		private static string GetAmmoSlot2Label()
		{
			return ExtraSlots.ammoSlotsShowLabel.Value ? GetAmmoSlot2Text() : "";
		}

		private static string GetAmmoSlot3Label()
		{
			return ExtraSlots.ammoSlotsShowLabel.Value ? GetAmmoSlot3Text() : "";
		}

		private static KeyboardShortcut GetAmmoSlot1Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.ammoSlotHotKey1.Value;
		}

		private static KeyboardShortcut GetAmmoSlot2Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.ammoSlotHotKey2.Value;
		}

		private static KeyboardShortcut GetAmmoSlot3Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.ammoSlotHotKey3.Value;
		}

		private static string GetFoodSlot1Label()
		{
			return ExtraSlots.foodSlotsShowLabel.Value ? GetFoodSlot1Text() : "";
		}

		private static string GetFoodSlot2Label()
		{
			return ExtraSlots.foodSlotsShowLabel.Value ? GetFoodSlot2Text() : "";
		}

		private static string GetFoodSlot3Label()
		{
			return ExtraSlots.foodSlotsShowLabel.Value ? GetFoodSlot3Text() : "";
		}

		private static KeyboardShortcut GetFoodSlot1Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.foodSlotHotKey1.Value;
		}

		private static KeyboardShortcut GetFoodSlot2Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.foodSlotHotKey2.Value;
		}

		private static KeyboardShortcut GetFoodSlot3Key()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return ExtraSlots.foodSlotHotKey3.Value;
		}

		private static bool IsUtilitySlot1Available()
		{
			return IsExtraUtilitySlotAvailable(0);
		}

		private static bool IsUtilitySlot2Available()
		{
			return IsExtraUtilitySlotAvailable(1);
		}

		private static bool IsUtilitySlot3Available()
		{
			return IsExtraUtilitySlotAvailable(2);
		}

		private static bool IsUtilitySlot4Available()
		{
			return IsExtraUtilitySlotAvailable(3);
		}

		internal static void InitializeSlots()
		{
			int index = 0;
			AddHotkeySlot("Quick1", GetQuickSlot1Label, null, IsQuickSlot1Available, GetQuickSlot1Key, GetQuickSlot1Text);
			AddHotkeySlot("Quick2", GetQuickSlot2Label, null, IsQuickSlot2Available, GetQuickSlot2Key, GetQuickSlot2Text);
			AddHotkeySlot("Quick3", GetQuickSlot3Label, null, IsQuickSlot3Available, GetQuickSlot3Key, GetQuickSlot3Text);
			AddHotkeySlot("Quick4", GetQuickSlot4Label, null, IsQuickSlot4Available, GetQuickSlot4Key, GetQuickSlot4Text);
			AddHotkeySlot("Quick5", GetQuickSlot5Label, null, IsQuickSlot5Available, GetQuickSlot5Key, GetQuickSlot5Text);
			AddHotkeySlot("Quick6", GetQuickSlot6Label, null, IsQuickSlot6Available, GetQuickSlot6Key, GetQuickSlot6Text);
			AddSlot("Misc1", GetMiscSlotLabel, IsMiscSlotItem, IsFirstMiscSlotAvailable);
			AddSlot("Misc2", GetMiscSlotLabel, IsMiscSlotItem, IsSecondMiscSlotAvailable);
			AddHotkeySlot("Ammo1", GetAmmoSlot1Label, IsAmmoSlotItem, IsAmmoSlotAvailable, GetAmmoSlot1Key, GetAmmoSlot1Text);
			AddHotkeySlot("Ammo2", GetAmmoSlot2Label, IsAmmoSlotItem, IsAmmoSlotAvailable, GetAmmoSlot2Key, GetAmmoSlot2Text);
			AddHotkeySlot("Ammo3", GetAmmoSlot3Label, IsAmmoSlotItem, IsAmmoSlotAvailable, GetAmmoSlot3Key, GetAmmoSlot3Text);
			AddHotkeySlot("Food1", GetFoodSlot1Label, IsFoodSlotItem, IsFoodSlotAvailable, GetFoodSlot1Key, GetFoodSlot1Text);
			AddHotkeySlot("Food2", GetFoodSlot2Label, IsFoodSlotItem, IsFoodSlotAvailable, GetFoodSlot2Key, GetFoodSlot2Text);
			AddHotkeySlot("Food3", GetFoodSlot3Label, IsFoodSlotItem, IsFoodSlotAvailable, GetFoodSlot3Key, GetFoodSlot3Text);
			AddSlot("ExtraUtility1", () => "$exsl_slot_equipment_utility_label", IsUtilitySlotItem, IsUtilitySlot1Available);
			AddSlot("ExtraUtility2", () => "$exsl_slot_equipment_utility_label", IsUtilitySlotItem, IsUtilitySlot2Available);
			AddSlot("Helmet", () => "$exsl_slot_equipment_helmet_label", IsHelmetSlotItem, SlotsProgression.IsHelmetSlotKnown);
			AddSlot("Chest", () => "$exsl_slot_equipment_chest_label", IsChestSlotItem, SlotsProgression.IsChestSlotKnown);
			AddSlot("Legs", () => "$exsl_slot_equipment_legs_label", IsLegsSlotItem, SlotsProgression.IsLegsSlotKnown);
			AddSlot("Shoulder", () => "$exsl_slot_equipment_shoulders_label", IsShoulderSlotItem, SlotsProgression.IsShoulderSlotKnown);
			AddSlot("Utility", () => "$exsl_slot_equipment_utility_label", IsUtilitySlotItem, SlotsProgression.IsUtilitySlotKnown);
			AddSlot("ExtraUtility3", () => "$exsl_slot_equipment_utility_label", IsUtilitySlotItem, IsUtilitySlot3Available);
			AddSlot("ExtraUtility4", () => "$exsl_slot_equipment_utility_label", IsUtilitySlotItem, IsUtilitySlot4Available);
			AddSlot("Trinket", () => "$exsl_slot_equipment_trinket_label", IsTrinketSlotItem, SlotsProgression.IsTrinketSlotKnown);
			CustomSlot.customSlotStartingIndex = index;
			for (int i = index; i < slots.Length; i++)
			{
				AddSlot("Empty", () => "", (ItemData item) => false, () => false);
			}
			UpdateSlotsGridPosition();
			UpdateCustomItemLists();
			QuickSlotsHotBar.UpdateSlots();
			AmmoSlotsHotBar.UpdateSlots();
			FoodSlotsHotBar.UpdateSlots();
			EquipmentPanel.UpdateSlotsCount();
			void AddHotkeySlot(string id, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive, Func<KeyboardShortcut> getShortcut, Func<string> getShortcutText)
			{
				slots[index] = new Slot(id, index, getName, itemIsValid, isActive, getShortcut, getShortcutText);
				index++;
			}
			void AddSlot(string id, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive)
			{
				slots[index] = new Slot(id, index, getName, itemIsValid, isActive);
				index++;
			}
		}

		internal static void UpdateCustomItemLists()
		{
			UpdateMiscSlotCustomItemList();
			UpdateAmmoSlotCustomItemList();
			UpdateFoodSlotCustomItemList();
		}

		internal static bool IsQuickSlotAvailable(int index)
		{
			return ExtraSlots.quickSlotsAmount.Value > index && SlotsProgression.IsQuickSlotKnown(index) && (index == 0 || IsQuickSlotAvailable(index - 1));
		}

		internal static bool IsExtraUtilitySlotAvailable(int index)
		{
			return ExtraSlots.extraUtilitySlotsAmount.Value > index && SlotsProgression.IsUtilitySlotKnown() && SlotsProgression.IsExtraUtilitySlotKnown(index) && (index == 0 || IsExtraUtilitySlotAvailable(index - 1));
		}

		internal static bool IsFirstMiscSlotAvailable()
		{
			return EquipmentPanel.quickSlotsCount > 0 && ExtraSlots.miscSlotsEnabled.Value && (IsFoodSlotAvailable() || IsAmmoSlotAvailable()) && SlotsProgression.IsAnyGlobalKeyActive(ExtraSlots.miscSlotsGlobalKey.Value);
		}

		internal static bool IsSecondMiscSlotAvailable()
		{
			return EquipmentPanel.quickSlotsCount > 0 && ExtraSlots.miscSlotsEnabled.Value && IsFoodSlotAvailable() && IsAmmoSlotAvailable() && SlotsProgression.IsAnyGlobalKeyActive(ExtraSlots.miscSlotsGlobalKey.Value);
		}

		internal static bool IsFoodSlotAvailable()
		{
			return ExtraSlots.foodSlotsEnabled.Value && SlotsProgression.IsAnyGlobalKeyActive(ExtraSlots.foodSlotsGlobalKey.Value) && SlotsProgression.IsFoodSlotKnown();
		}

		internal static bool IsAmmoSlotAvailable()
		{
			return ExtraSlots.ammoSlotsEnabled.Value && SlotsProgression.IsAnyGlobalKeyActive(ExtraSlots.ammoSlotsGlobalKey.Value) && SlotsProgression.IsAmmoSlotKnown();
		}

		internal static bool IsExtraRowAvailable(int index)
		{
			return ExtraSlots.extraRows.Value > index && SlotsProgression.IsExtraRowKnown(index) && (index == -3 || IsExtraRowAvailable(index - 1));
		}

		internal static int GetExtraRows()
		{
			for (int num = ExtraSlots.extraRows.Value - 1; num >= -3; num--)
			{
				if (IsExtraRowAvailable(num))
				{
					return num + 1;
				}
			}
			return -3;
		}

		internal static void UpdateSlotsGridPosition()
		{
			ClearCachedItems();
			Dictionary<Slot, ItemData> dictionary = slots.ToDictionary((Slot slot) => slot, (Slot slot) => slot.CacheItem());
			CollectionExtensions.Do<Slot>((IEnumerable<Slot>)slots, (Action<Slot>)delegate(Slot slot)
			{
				slot.UpdateGridPosition();
			});
			ClearCachedItems();
			InventoryInteraction.UpdatePlayerInventorySize();
		}

		internal static void UpdateMiscSlotCustomItemList()
		{
			AddItemsToList(ExtraSlots.miscSlotsItemList, miscItemsList);
			miscItemsList.Add("$item_coins");
			AddItemsToList(ExtraSlots.miscSlotsItemBlackList, miscItemsBlackList);
		}

		internal static void UpdateAmmoSlotCustomItemList()
		{
			AddItemsToList(ExtraSlots.ammoSlotsItemList, ammoItemsList);
			AddItemsToList(ExtraSlots.ammoSlotsItemBlackList, ammoItemsBlackList);
		}

		internal static void UpdateFoodSlotCustomItemList()
		{
			AddItemsToList(ExtraSlots.foodSlotsItemList, foodItemsList);
			AddItemsToList(ExtraSlots.foodSlotsItemBlackList, foodItemsBlackList);
		}

		internal static void AddItemsToList(ConfigEntry<string> configEntry, HashSet<string> strings)
		{
			strings.Clear();
			CollectionExtensions.Do<string>((IEnumerable<string>)configEntry.Value.Split(',', StringSplitOptions.RemoveEmptyEntries), (Action<string>)delegate(string item)
			{
				strings.Add(item.GetItemName());
			});
		}

		public static bool IsEquipmentSlotItem(ItemData item)
		{
			return slots.Any((Slot slot) => slot.IsEquipmentSlot && slot.IsActive && slot.ItemFits(item));
		}

		public static bool IsAmmoSlotItem(ItemData item)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			return item != null && !ammoItemsBlackList.Contains(item.m_shared.m_name) && ((int)item.m_shared.m_itemType == 9 || ammoItemsList.Contains(item.m_shared.m_name) || (ExtraSlots.ammoSlotsAllowThrowables.Value && IsThrowable(item.m_shared)));
			static bool IsThrowable(SharedData item)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Invalid comparison between Unknown and I4
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return (int)item.m_itemType == 3 && (int)item.m_animationState == 0 && item.m_attack?.m_attackAnimation == "throw_bomb";
			}
		}

		public static bool IsMiscSlotItem(ItemData item)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			return item != null && !miscItemsBlackList.Contains(item.m_shared.m_name) && (item.m_shared.m_questItem || (int)item.m_shared.m_itemType == 13 || (int)item.m_shared.m_itemType == 16 || (int)item.m_shared.m_itemType == 21 || miscItemsList.Contains(item.m_shared.m_name));
		}

		public static bool IsFoodSlotItem(ItemData item)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			int result;
			if (item != null && !foodItemsBlackList.Contains(item.m_shared.m_name))
			{
				if ((int)item.m_shared.m_itemType != 2)
				{
					goto IL_00a1;
				}
				if (!(item.m_shared.m_food > 0f) && !(item.m_shared.m_foodStamina > 0f) && !(item.m_shared.m_foodEitr > 0f) && !item.m_shared.m_isDrink)
				{
					StatusEffect consumeStatusEffect = item.m_shared.m_consumeStatusEffect;
					SE_Stats val = (SE_Stats)(object)((consumeStatusEffect is SE_Stats) ? consumeStatusEffect : null);
					if (val == null || !(val.m_healthOverTime + val.m_staminaOverTime + val.m_eitrOverTime > 0f))
					{
						goto IL_00a1;
					}
				}
				result = 1;
			}
			else
			{
				result = 0;
			}
			goto IL_00bc;
			IL_00bc:
			return (byte)result != 0;
			IL_00a1:
			result = (foodItemsList.Contains(item.m_shared.m_name) ? 1 : 0);
			goto IL_00bc;
		}

		public static bool IsHelmetSlotItem(ItemData item)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			return item != null && (int)item.m_shared.m_itemType == 6;
		}

		public static bool IsChestSlotItem(ItemData item)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			return item != null && (int)item.m_shared.m_itemType == 7;
		}

		public static bool IsLegsSlotItem(ItemData item)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			return item != null && (int)item.m_shared.m_itemType == 11;
		}

		public static bool IsShoulderSlotItem(ItemData item)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			return item != null && (int)item.m_shared.m_itemType == 17;
		}

		public static bool IsUtilitySlotItem(ItemData item)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			return item != null && (int)item.m_shared.m_itemType == 18;
		}

		public static bool IsCustomSlotItem(ItemData item)
		{
			return item != null && GetCustomSlots().Any((Slot slot) => slot.ItemFits(item));
		}

		public static bool IsTrinketSlotItem(ItemData item)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			return item != null && (int)item.m_shared.m_itemType == 24;
		}

		public static bool IsGridPositionASlot(Vector2i gridPos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return gridPos.y >= InventoryHeightPlayer;
		}

		public static bool IsItemInSlot(ItemData item)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return item != null && IsGridPositionASlot(item.m_gridPos);
		}

		public static bool IsItemInEquipmentSlot(ItemData item)
		{
			return GetItemSlot(item)?.IsEquipmentSlot ?? false;
		}

		public static Slot GetSlotInGrid(Vector2i pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!IsGridPositionASlot(pos))
			{
				return null;
			}
			Slot[] array = slots;
			foreach (Slot slot in array)
			{
				if (slot.GridPosition == pos)
				{
					return slot;
				}
			}
			return null;
		}

		public static Slot GetItemSlot(ItemData item)
		{
			//IL_0046: 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 (!IsItemInSlot(item))
			{
				return null;
			}
			if (PlayerInventory == null || !PlayerInventory.ContainsItem(item))
			{
				return null;
			}
			Slot[] array = slots;
			foreach (Slot slot in array)
			{
				if (slot.GridPosition == item.m_gridPos)
				{
					return slot;
				}
			}
			return null;
		}

		public static bool IsSameSlotType(Slot a, Slot b)
		{
			return a.IsEquipmentSlot == b.IsEquipmentSlot && a.IsFoodSlot == b.IsFoodSlot && a.IsQuickSlot == b.IsQuickSlot && a.IsAmmoSlot == b.IsAmmoSlot && a.IsMiscSlot == b.IsMiscSlot;
		}

		internal static void ClearCachedItems()
		{
			cachedItems.Clear();
		}
	}
	public static class ItemsSlotsValidation
	{
		internal static class SlotsValidation
		{
			[HarmonyPatch(typeof(Humanoid), "SetupEquipment")]
			private static class Humanoid_SetupEquipment_MarkSlotsDirty
			{
				private static void Postfix(Humanoid __instance)
				{
					Player val = (Player)(object)((__instance is Player) ? __instance : null);
					if (val != null && Slots.IsValidPlayer((Character)(object)val) && !val.m_isLoading)
					{
						MarkDirty();
					}
				}
			}

			[HarmonyPatch(typeof(Player), "OnInventoryChanged")]
			private static class Player_OnInventoryChanged_ValidateInventory
			{
				private static void Postfix(Player __instance)
				{
					Slots.ClearCachedItems();
					if (Slots.IsValidPlayer((Character)(object)__instance) && !__instance.m_isLoading)
					{
						MarkDirty();
					}
				}
			}

			private static bool isDirty;

			internal static void MarkDirty()
			{
				isDirty = true;
			}

			internal static void Validate()
			{
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: 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_01d6: 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_01f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: 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_014e: 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)
				if (!isDirty || !Object.op_Implicit((Object)(object)Player.m_localPlayer) || Player.m_localPlayer.m_isLoading)
				{
					return;
				}
				isDirty = false;
				for (int i = 0; i < Slots.slots.Length; i++)
				{
					Slots.Slot slot = Slots.slots[i];
					ItemData item = slot.Item;
					if (item == null || slot.ItemFits(item))
					{
						continue;
					}
					ExtraSlots.LogInfo($"SlotValidation: Item {item.m_shared.m_name} unfits slot {slot}");
					if (slot.IsEquipmentSlot && (item.m_equipped || ((Humanoid)Player.m_localPlayer).IsItemEquiped(item)))
					{
						slot.ClearItemCache();
						if (Slots.TryFindFreeEquipmentSlotForItem(item, out var slot2))
						{
							ExtraSlots.LogDebug($"SlotValidation: Equipped item {item.m_shared.m_name} {item.m_gridPos} was moved into first free equipment slot {slot2}");
							item.m_gridPos = slot2.GridPosition;
							slot2.ClearItemCache();
							continue;
						}
						if (Slots.TryFindFirstUnequippedSlotForItem(item, out var slot3))
						{
							if (slot3.IsFree)
							{
								ExtraSlots.LogDebug($"SlotValidation: Equipped item {item.m_shared.m_name} {item.m_gridPos} was moved into unequipped slot {slot3} {slot3.GridPosition}");
								item.m_gridPos = slot3.GridPosition;
								slot3.ClearItemCache();
								continue;
							}
							ItemData item2 = slot3.Item;
							ExtraSlots.LogDebug($"SlotValidation: Equipped item {item.m_shared.m_name} {item.m_gridPos} was swapped with unequipped {item2.m_shared.m_name} {item2.m_gridPos} into slot {slot3} {slot3.GridPosition}");
							item2.m_gridPos = item.m_gridPos;
							item.m_gridPos = slot3.GridPosition;
							slot3.ClearItemCache();
							if (slot.ItemFits(item = slot.Item))
							{
								continue;
							}
						}
					}
					PutIntoFirstEmptySlot(item);
				}
			}
		}

		internal static class ItemsValidation
		{
			[HarmonyPatch(typeof(Inventory), "MoveAll")]
			internal static class Inventory_MoveAll_ValidateItemPositions
			{
				private static void Postfix(Inventory __instance, Inventory fromInventory)
				{
					if (__instance == Slots.PlayerInventory || fromInventory == Slots.PlayerInventory)
					{
						MarkDirty();
					}
				}
			}

			[HarmonyPatch(typeof(TombStone), "EasyFitInInventory")]
			internal static class TombStone_EasyFitInInventory_ValidateItemPositions
			{
				private static void Postfix(Player player)
				{
					if (Slots.IsValidPlayer((Character)(object)player))
					{
						MarkDirty();
					}
				}
			}

			[HarmonyPatch]
			public static class Humanoid_OnEquipUnequip
			{
				[CompilerGenerated]
				private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
				{
					private int <>1__state;

					private MethodBase <>2__current;

					private int <>l__initialThreadId;

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

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

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

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

					private bool MoveNext()
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<>2__current = AccessTools.Method(typeof(Humanoid), "EquipItem", (Type[])null, (Type[])null);
							<>1__state = 1;
							return true;
						case 1:
							<>1__state = -1;
							<>2__current = AccessTools.Method(typeof(Humanoid), "UnequipItem", (Type[])null, (Type[])null);
							<>1__state = 2;
							return true;
						case 2:
							<>1__state = -1;
							return false;
						}
					}

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

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

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

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

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

				private static void Prefix(Humanoid __instance)
				{
					if (Slots.IsValidPlayer((Character)(object)__instance))
					{
						MarkDirty();
					}
				}
			}

			private static readonly HashSet<Vector2i> occupiedPositions = new HashSet<Vector2i>();

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

			private static bool isDirty = false;

			internal static void Validate()
			{
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: 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_0328: Unknown result type (might be due to invalid IL or missing references)
				//IL_0346: Unknown result type (might be due to invalid IL or missing references)
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_0230: Unknown result type (might be due to invalid IL or missing references)
				//IL_0244: Unknown result type (might be due to invalid IL or missing references)
				//IL_025d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0262: Unknown result type (might be due to invalid IL or missing references)
				//IL_026a: Unknown result type (might be due to invalid IL or missing references)
				//IL_026f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0290: 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_01af: 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_01dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0389: Unknown result type (might be due to invalid IL or missing references)
				if (!isDirty || !Object.op_Implicit((Object)(object)Player.m_localPlayer) || Player.m_localPlayer.m_isLoading)
				{
					return;
				}
				isDirty = false;
				if (Slots.PlayerInventory == null || Slots.PlayerInventory.m_inventory == null)
				{
					return;
				}
				occupiedPositions.Clear();
				tempItems.Clear();
				for (int i = 0; i < Slots.PlayerInventory.m_inventory.Count; i++)
				{
					ItemData val = Slots.PlayerInventory.m_inventory[i];
					if (val == null)
					{
						continue;
					}
					if (((Humanoid)Player.m_localPlayer).IsItemEquiped(val) && Slots.IsEquipmentSlotItem(val))
					{
						Slots.Slot itemSlot = Slots.GetItemSlot(val);
						if (itemSlot == null || !itemSlot.IsEquipmentSlot || (!itemSlot.IsCustomSlot && Slots.IsCustomSlotItem(val)))
						{
							ExtraSlots.LogInfo($"ItemsValidation: Equipped item {val.m_shared.m_name} {val.m_gridPos} is not in equipment slot");
							Slots.Slot slot2;
							if (Slots.TryFindFreeEquipmentSlotForItem(val, out var slot))
							{
								ExtraSlots.LogDebug($"ItemsValidation: Equipped item {val.m_shared.m_name} {val.m_gridPos} was moved into free equipment slot {slot} {slot.GridPosition}");
								val.m_gridPos = slot.GridPosition;
								Slots.PlayerInventory.Changed();
							}
							else if (Slots.TryFindFirstUnequippedSlotForItem(val, out slot2))
							{
								if (slot2.IsFree)
								{
									ExtraSlots.LogDebug($"ItemsValidation: Equipped item {val.m_shared.m_name} {val.m_gridPos} was moved into unequipped slot {slot2} {slot2.GridPosition}");
									val.m_gridPos = slot2.GridPosition;
								}
								else
								{
									ItemData item = slot2.Item;
									ExtraSlots.LogDebug($"ItemsValidation: Equipped item {val.m_shared.m_name} {val.m_gridPos} was swapped with unequipped {item.m_shared.m_name} {item.m_gridPos} into slot {slot2} {slot2.GridPosition}");
									item.m_gridPos = val.m_gridPos;
									val.m_gridPos = slot2.GridPosition;
									ExtraSlots.LogDebug($"ItemsValidation: swap result {val.m_shared.m_name} {val.m_gridPos} {item.m_shared.m_name} {item.m_gridPos}");
								}
								Slots.PlayerInventory.Changed();
							}
						}
					}
					if (ItemIsOverlapping(val))
					{
						ItemData otherItemAt = Slots.PlayerInventory.GetOtherItemAt(val.m_gridPos.x, val.m_gridPos.y, val);
						if (otherItemAt != null)
						{
							ExtraSlots.LogWarning($"ItemsValidation: Item {val.m_shared.m_name} {val.m_gridPos} is overlapping other item {otherItemAt.m_shared.m_name} {otherItemAt.m_gridPos}");
							tempItems.Add(val);
							goto IL_03ab;
						}
					}
					if (ItemIsOutOfGrid(val))
					{
						ExtraSlots.LogWarning($"ItemsValidation: Item {val.m_shared.m_name} {val.m_gridPos} is out of inventory grid");
						tempItems.Add(val);
					}
					goto IL_03ab;
					IL_03ab:
					occupiedPositions.Add(val.m_gridPos);
				}
				if (tempItems.Count(PutIntoFirstEmptySlot) > 0)
				{
					Slots.PlayerInventory.Changed();
				}
				CollectionExtensions.Do<ItemData>((IEnumerable<ItemData>)API.GetAllExtraSlotsItems(), (Action<ItemData>)Slots.PruneLastEquippedSlotFromItem);
			}

			private static bool ItemIsOverlapping(ItemData itemData)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return occupiedPositions.Contains(itemData.m_gridPos);
			}

			private static bool ItemIsOutOfGrid(ItemData itemData)
			{
				return itemData.m_gridPos.x < 0 || itemData.m_gridPos.x >= Slots.InventoryWidth || itemData.m_gridPos.y < 0 || itemData.m_gridPos.y >= Slots.InventoryHeightFull;
			}

			internal static void MarkDirty()
			{
				isDirty = true;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		public static class InventoryGui_Show_ValidateItems
		{
			private static void Postfix()
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null))
				{
					ValidateSlots();
					ValidateItems();
				}
			}
		}

		private static bool PutIntoFirstEmptySlot(ItemData item)
		{
			//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_009e: 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_0068: 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_00a7: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_0195: 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)
			if (Slots.TryGetSavedPlayerSlot(item, out var slot) && slot.IsActive && slot.ItemFits(item) && (slot.IsFree || item == slot.Item))
			{
				ExtraSlots.LogDebug($"Item {item.m_shared.m_name} {item.m_gridPos} was put into previous slot {slot} {slot.GridPosition}");
				item.m_gridPos = slot.GridPosition;
				return true;
			}
			Vector2i val = Slots.PlayerInventory.FindEmptySlot(true);
			if (val.x > -1 && val.y > -1)
			{
				ExtraSlots.LogDebug($"Item {item.m_shared.m_name} {item.m_gridPos} was put into first free slot {val}");
				item.m_gridPos = val;
				return true;
			}
			if (Slots.TryFindFreeSlotForItem(item, out var slot2))
			{
				ExtraSlots.LogDebug($"Item {item.m_shared.m_name} {item.m_gridPos} was put into first free valid slot {slot2} {slot2.GridPosition}");
				item.m_gridPos = slot2.GridPosition;
				return true;
			}
			if (Slots.TryMakeFreeSpaceInPlayerInventory(tryFindRegularInventorySlot: true, out var gridPos))
			{
				ExtraSlots.LogDebug($"Item {item.m_shared.m_name} {item.m_gridPos} was put into created free space {gridPos}");
				item.m_gridPos = gridPos;
				return true;
			}
			return false;
		}

		public static void ValidateSlots()
		{
			SlotsValidation.MarkDirty();
		}

		public static void ValidateItems()
		{
			ItemsValidation.MarkDirty();
		}

		public static void Validate()
		{
			ItemsValidation.Validate();
			SlotsValidation.Validate();
		}
	}
	public static class InventoryBackup
	{
		[Serializable]
		public class ExtraSlotsBackup
		{
			public string date;

			public string worldName;

			public int nrOfItems;

			public int width;

			public int height;

			public int extraRows;

			public string inventoryBase64;
		}

		[HarmonyPatch(typeof(Player), "Save")]
		public static class Player_Save_CheckRegularInventoryAndQuickSlots
		{
			[HarmonyPriority(0)]
			public static void Prefix(Player __instance)
			{
				if (ExtraSlots.backupEnabled.Value && (Object)(object)__instance == (Object)(object)Slots.CurrentPlayer)
				{
					__instance.m_customData["ExtraSlotsInventoryBackup"] = JsonUtility.ToJson((object)GetExtraSlotsBackup(((Humanoid)__instance).GetInventory()));
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		public static class Player_Load_TryLoadBackup
		{
			[HarmonyPriority(500)]
			public static void Postfix(Player __instance)
			{
				if (ExtraSlots.backupEnabled.Value && PlayerCanRestoreBackup(__instance, out var extraSlotsBackup))
				{
					TryRestoreBackup(__instance, extraSlotsBackup);
				}
			}
		}

		public const string customKeyBackupID = "ExtraSlotsInventoryBackup";

		private static ExtraSlotsBackup GetExtraSlotsBackup(Inventory inventory)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			int inventoryWidth = Slots.InventoryWidth;
			int num = Slots.InventoryHeightFull - Slots.InventoryHeightPlayer;
			Inventory val = new Inventory("ExtraSlotsInventoryBackup", (Sprite)null, inventoryWidth, num);
			foreach (ItemData item in from item in inventory.GetAllItemsInGridOrder()
				where item.m_gridPos.y >= Slots.InventoryHeightPlayer
				select item)
			{
				ItemData val2 = item.Clone();
				val.AddItem(val2, new Vector2i(val2.m_gridPos.x, val2.m_gridPos.y - Slots.InventoryHeightPlayer));
			}
			ZPackage val3 = new ZPackage();
			val.Save(val3);
			ZPackage val4 = new ZPackage();
			val4.WriteCompressed(val3);
			ExtraSlotsBackup obj = new ExtraSlotsBackup
			{
				date = DateTime.Now.ToString()
			};
			ZNet instance = ZNet.instance;
			obj.worldName = ((instance != null) ? instance.GetWorldName() : null);
			obj.nrOfItems = val.NrOfItems();
			obj.width = inventoryWidth;
			obj.height = num;
			obj.extraRows = Slots.ExtraRowsPlayer;
			obj.inventoryBase64 = val4.GetBase64();
			ExtraSlotsBackup extraSlotsBackup = obj;
			ExtraSlots.LogMessage($"Extra slots backup saved {extraSlotsBackup.date}, world {extraSlotsBackup.worldName}, items {extraSlotsBackup.nrOfItems}, size {(float)val3.Size() / 1000f:f1} kb, compressed {(float)val4.Size() / 1000f:f1} kb");
			return extraSlotsBackup;
		}

		private static bool TryGetBackup(Player player, out ExtraSlotsBackup extraSlotsBackup)
		{
			extraSlotsBackup = null;
			if (!player.m_customData.TryGetValue("ExtraSlotsInventoryBackup", out var value))
			{
				return false;
			}
			try
			{
				extraSlotsBackup = JsonUtility.FromJson<ExtraSlotsBackup>(value);
			}
			catch (Exception arg)
			{
				ExtraSlots.LogWarning($"Error while checking inventory backup:\n{arg}");
				return false;
			}
			return extraSlotsBackup != null && !string.IsNullOrEmpty(extraSlotsBackup.inventoryBase64);
		}

		private static bool PlayerCanRestoreBackup(Player player, out ExtraSlotsBackup extraSlotsBackup)
		{
			extraSlotsBackup = null;
			if (ExtraSlots.HasServerCharactersActive)
			{
				return false;
			}
			if ((Object)(object)player == (Object)null || !player.m_customData.ContainsKey("ExtraSlotsInventoryBackup"))
			{
				return false;
			}
			if (((Humanoid)player).GetInventory().GetAllItems().Any((ItemData item) => Slots.IsItemInSlot(item)))
			{
				return false;
			}
			return TryGetBackup(player, out extraSlotsBackup);
		}

		private static void TryRestoreBackup(Player player, ExtraSlotsBackup extraSlotsBackup)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0036: 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_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)
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return;
			}
			try
			{
				Inventory val = new Inventory("ExtraSlotsInventoryBackup", (Sprite)null, extraSlotsBackup.width, extraSlotsBackup.height);
				val.Load(new ZPackage(extraSlotsBackup.inventoryBase64).ReadCompressedPackage());
				if (val.NrOfItems() == 0)
				{
					return;
				}
				if (inventory.m_height < Slots.InventoryHeightPlayer + val.m_height)
				{
					inventory.m_height = Slots.InventoryHeightPlayer + val.m_height;
				}
				if (Slots.ExtraRowsPlayer > extraSlotsBackup.extraRows && CheckForRowChange(inventory, val, extraSlotsBackup.extraRows))
				{
					ExtraSlots.LogMessage($"Extra slots backup skipped. Number of inventory rows was changed {extraSlotsBackup.extraRows} -> {Slots.ExtraRowsPlayer}.");
					return;
				}
				Vector2i val2 = default(Vector2i);
				foreach (ItemData item in Enumerable.Reverse(val.GetAllItemsInGridOrder()))
				{
					((Vector2i)(ref val2))..ctor(item.m_gridPos.x, item.m_gridPos.y + Slots.InventoryHeightPlayer);
					ItemData val3 = item.Clone();
					if (inventory.AddItem(val3, val2))
					{
						val3 = inventory.GetItemAt(val2.x, val2.y) ?? val3;
						if (val3.IsEquipable() && val3.m_equipped && !((Humanoid)player).EquipItem(val3, false))
						{
							val3.m_equipped = false;
						}
					}
				}
			}
			catch (Exception arg)
			{
				ExtraSlots.LogWarning($"Error while loading inventory backup from player:\n{arg}");
				return;
			}
			ExtraSlots.LogMessage($"Extra slots backup restored. Backup date {extraSlotsBackup.date}, world {extraSlotsBackup.worldName}, items {extraSlotsBackup.nrOfItems}");
		}

		private static bool CheckForRowChange(Inventory playerInventory, Inventory backup, int previousRows)
		{
			int delta = Slots.ExtraRowsPlayer - previousRows;
			return backup.GetAllItems().All(delegate(ItemData item)
			{
				ItemData itemAt = playerInventory.GetItemAt(item.m_gridPos.x, item.m_gridPos.y + Slots.InventoryHeightPlayer - delta);
				return itemAt != null && itemAt.m_shared.m_name == item.m_shared.m_name && itemAt.m_stack == item.m_stack && itemAt.m_quality == item.m_quality;
			});
		}
	}
	public static class SlotsProgression
	{
		[HarmonyPatch(typeof(Player), "AddKnownItem")]
		private static class Player_AddKnownItem_UpdateKnownItemTypes
		{
			private static void Prefix(Player __instance, ref int __state)
			{
				__state = __instance.m_knownMaterial.Count;
			}

			private static void Postfix(Player __instance, ItemData item, int __state)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (__state != __instance.m_knownMaterial.Count)
				{
					itemTypes.Add(item.m_shared.m_itemType);
					if (IsRowProgressionActive() || LightenedSlots.IsEnabled)
					{
						ExtraSlots.instance.StartSlotsUpdateNextFrame();
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class Player_OnSpawned_UpdateKnownItemTypes
		{
			private static void Prefix(Player __instance)
			{
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
				{
					UpdateItemTypes();
				}
			}
		}

		[HarmonyPatch]
		public static class Player_ClearKnownItemTypes
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Player), "OnDestroy", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Player), "ResetCharacter", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Player), "ResetCharacterKnownItems", (Type[])null, (Type[])null);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Player), "Load", (Type[])null, (Type[])null);
						<>1__state = 4;
						return true;
					case 4:
						<>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<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__0(0);
				}

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

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

			private static void Prefix(Player __instance)
			{
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
				{
					itemTypes.Clear();
				}
			}
		}

		[HarmonyPatch]
		public static class Patch_UpdateAvailableRows
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Player), "ResetCharacter", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Player), "ResetCharacterKnownItems", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Player), "AddUniqueKey", (Type[])null, (Type[])null);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Player), "RemoveUniqueKey", (Type[])null, (Type[])null);
						<>1__state = 4;
						return true;
					case 4:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZoneSystem), "RPC_GlobalKeys", (Type[])null, (Type[])null);
						<>1__state = 5;
						return true;
					case 5:
						<>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<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__0(0);
				}

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

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

			private static void Postfix()
			{
				if (IsRowProgressionActive() || LightenedSlots.IsEnabled)
				{
					ExtraSlots.instance.StartSlotsUpdateNextFrame();
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		private static class Player_Load_UpdateSlotsGridPositions
		{
			private static void Postfix(Player __instance)
			{
				Slots.loadedPlayer = __instance;
				if (IsRowProgressionActive())
				{
					Slots.UpdateSlotsGridPosition();
				}
				Slots.loadedPlayer = null;
			}
		}

		[HarmonyPatch(typeof(Player), "SetLocalPlayer")]
		private static class Player_SetLocalPlayer_ClearPlayerKeyAndKnownMaterialsCache
		{
			private static void Prefix()
			{
				m_knownMaterialCache.Clear();
				m_uniquesCache.Clear();
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "SetupCharacterPreview")]
		private static class FejdStartup_SetupCharacterPreview_CacheLastPlayer
		{
			private static void Postfix()
			{
				if ((Object)(object)Slots.CurrentPlayer != (Object)null)
				{
					CollectionExtensions.Do<string>((IEnumerable<string>)Slots.CurrentPlayer.m_knownMaterial, (Action<string>)delegate(string mat)
					{
						m_knownMaterialCache.Add(mat);
					});
					CollectionExtensions.Do<string>((IEnumerable<string>)Slots.CurrentPlayer.m_uniques, (Action<string>)delegate(string mat)
					{
						m_uniquesCache.Add(mat);
					});
				}
			}
		}

		private static readonly HashSet<ItemType> itemTypes = new HashSet<ItemType>();

		private static readonly Dictionary<string, string[]> keysCache = new Dictionary<string, string[]>();

		public static readonly HashSet<string> m_knownMaterialCache = new HashSet<string>();

		public static readonly HashSet<string> m_uniquesCache = new HashSet<string>();

		private static string[] GetKeys(string configValue)
		{
			configValue = configValue.Trim();
			if (keysCache.TryGetValue(configValue, out var value))
			{
				return value;
			}
			return keysCache[configValue] = (from s in configValue.Split(',')
				select s.Trim() into s
				where !Utility.IsNullOrWhiteSpace(s)
				select s).ToArray();
		}

		public static bool IsAnyGlobalKeyActive(string requiredKeys)
		{
			if (!ExtraSlots.slotsProgressionEnabled.Value || !Object.op_Implicit((Object)(object)Slots.CurrentPlayer) || Slots.CurrentPlayer.m_isLoading || string.IsNullOrEmpty(requiredKeys))
			{
				return true;
			}
			string[] keys = GetKeys(requiredKeys);
			if (keys.Length == 0)
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)ZoneSystem.instance))
			{
				for (int i = 0; i < keys.Length; i++)
				{
					if (ZoneSystem.instance.GetGlobalKey(keys[i]))
					{
						return true;
					}
				}
			}
			for (int j = 0; j < keys.Length; j++)
			{
				if (((Humanoid)Slots.CurrentPlayer).HaveUniqueKey(keys[j]))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsItemTypeKnown(ItemType itemType)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!ExtraSlots.slotsProgressionEnabled.Value || !Object.op_Implicit((Object)(object)Slots.CurrentPlayer) || Slots.CurrentPlayer.m_isLoading || itemTypes.Count == 0)
			{
				return true;
			}
			return itemTypes.Contains(itemType);
		}

		public static bool IsAnyMaterialDiscovered(string itemNames)
		{
			if (!ExtraSlots.slotsProgressionEnabled.Value || !Object.op_Implicit((Object)(object)Slots.CurrentPlayer) || Slots.CurrentPlayer.m_isLoading || string.IsNullOrEmpty(itemNames))
			{
				return true;
			}
			string[] keys = GetKeys(itemNames);
			if (keys.Length == 0)
			{
				return true;
			}
			for (int i = 0; i < keys.Length; i++)
			{
				if (Slots.CurrentPlayer.IsMaterialKnown(keys[i].GetItemName()))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsAmmoSlotKnown()
		{
			return !ExtraSlots.ammoSlotsAvailableAfterDiscovery.Value || IsItemTypeKnown((ItemType)9);
		}

		public static bool IsFoodSlotKnown()
		{
			return !ExtraSlots.foodSlotsAvailableAfterDiscovery.Value || IsItemTypeKnown((ItemType)2);
		}

		public static bool IsUtilitySlotKnown()
		{
			return !ExtraSlots.utilitySlotAvailableAfterDiscovery.Value || IsItemTypeKnown((ItemType)18);
		}

		public static bool IsHelmetSlotKnown()
		{
			return !ExtraSlots.equipmentSlotsAvailableAfterDiscovery.Value || IsItemTypeKnown((ItemType)6);
		}

		public static bool IsChestSlotKnown()
		{
			return !ExtraSlots.equipmentSlotsAvailableAfterDiscovery.Value || IsItemTypeKnown((ItemType)7);
		}

		public static bool IsLegsSlotKnown()
		{
			return !ExtraSlots.equipmentSlotsAvailableAfterDiscovery.Value || IsItemTypeKnown((ItemType)11);
		}

		public static bool IsShoulderSlotKnown()
		{
			return !ExtraSlots.equipmentSlotsAvailableAfterDiscovery.Value || IsItemTypeKnown((ItemType)17);
		}

		public static bool IsTrinketSlotKnown()
		{
			return !ExtraSlots.equipmentSlotsAvailableAfterDiscovery.Value || IsItemTypeKnown((ItemType)24);
		}

		private static void UpdateItemTypes()
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			itemTypes.Clear();
			if (!Object.op_Implicit((Object)(object)ObjectDB.instance) || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				ItemDrop component = item.GetComponent<ItemDrop>();
				if (component == null)
				{
					continue;
				}
				ItemData itemData = component.m_itemData;
				if (itemData != null)
				{
					SharedData shared = itemData.m_shared;
					if (shared != null && Player.m_localPlayer.m_knownMaterial.Contains(shared.m_name))
					{
						itemTypes.Add(shared.m_itemType);
					}
				}
			}
		}

		internal static bool IsQuickSlotKnown(int index)
		{
			return IsSlotActive(QuickSlotGlobalKey(index), QuickSlotItemDiscovered(index));
		}

		private static string QuickSlotGlobalKey(int index)
		{
			if (1 == 0)
			{
			}
			string result = index switch
			{
				0 => ExtraSlots.quickSlotGlobalKey1.Value, 
				1 => ExtraSlots.quickSlotGlobalKey2.Value, 
				2 => ExtraSlots.quickSlotGlobalKey3.Value, 
				3 => ExtraSlots.quickSlotGlobalKey4.Value, 
				4 => ExtraSlots.quickSlotGlobalKey5.Value, 
				5 => ExtraSlots.quickSlotGlobalKey6.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static string QuickSlotItemDiscovered(int index)
		{
			if (1 == 0)
			{
			}
			string result = index switch
			{
				0 => ExtraSlots.quickSlotItemDiscovered1.Value, 
				1 => ExtraSlots.quickSlotItemDiscovered2.Value, 
				2 => ExtraSlots.quickSlotItemDiscovered3.Value, 
				3 => ExtraSlots.quickSlotItemDiscovered4.Value, 
				4 => ExtraSlots.quickSlotItemDiscovered5.Value, 
				5 => ExtraSlots.quickSlotItemDiscovered6.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		internal static bool IsExtraUtilitySlotKnown(int index)
		{
			return IsSlotActive(UtilitySlotGlobalKey(index), UtilitySlotItemDiscovered(index));
		}

		internal static string UtilitySlotGlobalKey(int index)
		{
			if (1 == 0)
			{
			}
			string result = index switch
			{
				0 => ExtraSlots.utilitySlotGlobalKey1.Value, 
				1 => ExtraSlots.utilitySlotGlobalKey2.Value, 
				2 => ExtraSlots.utilitySlotGlobalKey3.Value, 
				3 => ExtraSlots.utilitySlotGlobalKey4.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		internal static string UtilitySlotItemDiscovered(int index)
		{
			if (1 == 0)
			{
			}
			string result = index switch
			{
				0 => ExtraSlots.utilitySlotItemDiscovered1.Value, 
				1 => ExtraSlots.utilitySlotItemDiscovered2.Value, 
				2 => ExtraSlots.utilitySlotItemDiscovered3.Value, 
				3 => ExtraSlots.utilitySlotItemDiscovered4.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static bool IsSlotActive(string globalKey, string itemDiscovered)
		{
			bool flag = !Utility.IsNullOrWhiteSpace(globalKey);
			bool flag2 = !Utility.IsNullOrWhiteSpace(itemDiscovered);
			if (!flag && !flag2)
			{
				return true;
			}
			if (flag && flag2)
			{
				return IsAnyGlobalKeyActive(globalKey) || IsAnyMaterialDiscovered(itemDiscovered);
			}
			return flag ? IsAnyGlobalKeyActive(globalKey) : IsAnyMaterialDiscovered(itemDiscovered);
		}

		public static bool IsAnyPlayerKeyActiveCached(string requiredKeys)
		{
			if (string.IsNullOrEmpty(requiredKeys))
			{
				return true;
			}
			string[] keys = GetKeys(requiredKeys);
			if (keys.Length == 0)
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)Slots.CurrentPlayer) && !Slots.CurrentPlayer.m_isLoading)
			{
				for (int i = 0; i < keys.Length; i++)
				{
					if (((Humanoid)Slots.CurrentPlayer).HaveUniqueKey(keys[i]))
					{
						return true;
					}
				}
			}
			else
			{
				for (int j = 0; j < keys.Length; j++)
				{
					if (m_uniquesCache.Contains(keys[j]))
					{
						return true;
					}
				}
			}
			return false;
		}

		public static bool IsAnyItemDiscoveredCached(string itemNames)
		{
			if (string.IsNullOrEmpty(itemNames))
			{
				return true;
			}
			string[] keys = GetKeys(itemNames);
			if (keys.Length == 0)
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)Slots.CurrentPlayer) && !Slots.CurrentPlayer.m_isLoading)
			{
				for (int i = 0; i < keys.Length; i++)
				{
					if (Slots.CurrentPlayer.IsMaterialKnown(keys[i].GetItemName()))
					{
						return true;
					}
				}
			}
			else
			{
				for (int j = 0; j < keys.Length; j++)
				{
					if (m_knownMaterialCache.Contains(keys[j].GetItemName()))
					{
						return true;
					}
				}
			}
			return false;
		}

		internal static bool IsRowProgressionActive()
		{
			return ExtraSlots.rowsProgressionEnabled.Value && ((Object.op_Implicit((Object)(object)Slots.CurrentPlayer) && !Slots.CurrentPlayer.m_isLoading) || m_knownMaterialCache.Count + m_uniquesCache.Count > 0);
		}

		internal static bool IsExtraRowKnown(int index)
		{
			if (!IsRowProgressionActive())
			{
				return true;
			}
			return IsPlayerKeyItemConditionMet(ExtraRowPlayerKey(index), ExtraRowItemDiscovered(index).GetItemName());
		}

		internal static bool IsPlayerKeyItemConditionMet(string playerKey, string itemDiscovered)
		{
			bool flag = !Utility.IsNullOrWhiteSpace(playerKey);
			bool flag2 = !Utility.IsNullOrWhiteSpace(itemDiscovered);
			if (!flag && !flag2)
			{
				return true;
			}
			if (flag && flag2)
			{
				return IsAnyPlayerKeyActiveCached(playerKey) || IsAnyItemDiscoveredCached(itemDiscovered);
			}
			return flag ? IsAnyPlayerKeyActiveCached(playerKey) : IsAnyItemDiscoveredCached(itemDiscovered);
		}

		private static string ExtraRowPlayerKey(int index)
		{
			if (1 == 0)
			{
			}
			string result = index switch
			{
				-3 => ExtraSlots.extraRowPlayerKeyMinus2.Value, 
				-2 => ExtraSlots.extraRowPlayerKeyMinus1.Value, 
				-1 => ExtraSlots.extraRowPlayerKeyVanilla.Value, 
				0 => ExtraSlots.extraRowPlayerKey1.Value, 
				1 => ExtraSlots.extraRowPlayerKey2.Value, 
				2 => ExtraSlots.extraRowPlayerKey3.Value, 
				3 => ExtraSlots.extraRowPlayerKey4.Value, 
				4 => ExtraSlots.extraRowPlayerKey5.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static string ExtraRowItemDiscovered(int index)
		{
			if (1 == 0)
			{
			}
			string result = index switch
			{
				-3 => ExtraSlots.extraRowItemDiscoveredMinus2.Value, 
				-2 => ExtraSlots.extraRowItemDiscoveredMinus1.Value, 
				-1 => ExtraSlots.extraRowItemDiscoveredVanilla.Value, 
				0 => ExtraSlots.extraRowItemDiscovered1.Value, 
				1 => ExtraSlots.extraRowItemDiscovered2.Value, 
				2 => ExtraSlots.extraRowItemDiscovered3.Value, 
				3 => ExtraSlots.extraRowItemDiscovered4.Value, 
				4 => ExtraSlots.extraRowItemDiscovered5.Value, 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public static class API
	{
		public static List<Slots.Slot> GetExtraSlots()
		{
			return Slots.slots.ToList();
		}

		public static List<Slots.Slot> GetEquipmentSlots()
		{
			return Slots.slots.Where((Slots.Slot slot) => slot.IsEquipmentSlot).ToList();
		}

		public static List<Slots.Slot> GetQuickSlots()
		{
			return Slots.slots.Where((Slots.Slot slot) => slot.IsQuickSlot).ToList();
		}

		public static List<Slots.Slot> GetFoodSlots()
		{
			return Slots.slots.Where((Slots.Slot slot) => slot.IsFoodSlot).ToList();
		}

		public static List<Slots.Slot> GetAmmoSlots()
		{
			return Slots.slots.Where((Slots.Slot slot) => slot.IsAmmoSlot).ToList();
		}

		public static List<Slots.Slot> GetMiscSlots()
		{
			return Slots.slots.Where((Slots.Slot slot) => slot.IsMiscSlot).ToList();
		}

		public static Slots.Slot FindSlot(string slotID)
		{
			return Slots.slots.FirstOrDefault((Slots.Slot slot) => slot.ID == slotID || slot.ID == Slots.CustomSlot.GetSlotID(slotID));
		}

		public static List<ItemData> GetAllExtraSlotsItems()
		{
			return (from slot in Slots.slots
				select slot.Item into item
				where item != null
				select item).ToList();
		}

		public static List<ItemData> GetEquipmentSlotsItems()
		{
			return (from slot in GetEquipmentSlots()
				select slot.Item into item
				where item != null
				select item).ToList();
		}

		public static List<ItemData> GetQuickSlotsItems()
		{
			return (from slot in GetQuickSlots()
				select slot.Item into item
				where item != null
				select item).ToList();
		}

		public static List<ItemData> GetFoodSlotsItems()
		{
			return (from slot in GetFoodSlots()
				select slot.Item into item
				where item != null
				select item).ToList();
		}

		public static List<ItemData> GetAmmoSlotsItems()
		{
			return (from slot in GetAmmoSlots()
				select slot.Item into item
				where item != null
				select item).ToList();
		}

		public static List<ItemData> GetMiscSlotsItems()
		{
			return (from slot in GetMiscSlots()
				select slot.Item into item
				where item != null
				select item).ToList();
		}

		public static int GetExtraRows()
		{
			return Slots.ExtraRowsPlayer;
		}

		public static int GetInventoryHeightFull()
		{
			return Slots.InventoryHeightFull;
		}

		public static int GetInventoryHeightPlayer()
		{
			return Slots.InventoryHeightPlayer;
		}

		public static bool IsGridPositionASlot(Vector2i gridPos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Slots.IsGridPositionASlot(gridPos);
		}

		public static bool IsItemInSlot(ItemData item)
		{
			return Slots.IsItemInSlot(item);
		}

		public static bool IsItemInEquipmentSlot(ItemData item)
		{
			return Slots.IsItemInEquipmentSlot(item);
		}

		public static bool IsAnyGlobalKeyActive(string requiredKeys)
		{
			return SlotsProgression.IsAnyGlobalKeyActive(requiredKeys);
		}

		public static bool IsItemTypeKnown(ItemType itemType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return SlotsProgression.IsItemTypeKnown(itemType);
		}

		public static bool IsAnyMaterialDiscovered(string itemNames)
		{
			return SlotsProgression.IsAnyMaterialDiscovered(itemNames);
		}

		public static bool AddSlot(string slotID, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive)
		{
			return Slots.CustomSlot.TryAddNewSlotWithIndex(slotID, -1, getName, itemIsValid, isActive);
		}

		public static bool AddSlotWithIndex(string slotID, int slotIndex, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive)
		{
			return Slots.CustomSlot.TryAddNewSlotWithIndex(slotID, slotIndex, getName, itemIsValid, isActive);
		}

		[Obsolete("Use AddSlotAfter instead.")]
		public static bool AddSlotBefore(string slotID, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive, params string[] slotIDs)
		{
			return AddSlotAfter(slotID, getName, itemIsValid, isActive, slotIDs);
		}

		public static bool AddSlotAfter(string slotID, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive, params string[] slotIDs)
		{
			return Slots.CustomSlot.TryAddNewSlotAfter(slotIDs, slotID, getName, itemIsValid, isActive);
		}

		public static bool RemoveSlot(string slotID)
		{
			return Slots.CustomSlot.TryRemoveSlot(slotID);
		}

		public static void UpdateSlots()
		{
			Slots.UpdateSlotsGridPosition();
			EquipmentPanel.UpdatePanel();
			LightenedSlots.UpdateState();
			PreventSimilarHotkeys.FillSimilarHotkey();
		}
	}
}
namespace ExtraSlots.HotBars
{
	public static class FoodSlotsHotBar
	{
		public const string barName = "ExtraSlotsFoodHotBar";

		public const int barSlotIndex = 11;

		public static bool isDirty = true;

		private static HotkeyBar hotBar = null;

		private static RectTransform hotBarRect = null;

		private static Slots.Slot[] hotBarSlots = Array.Empty<Slots.Slot>();

		private static Dictionary<ItemData, Vector2i> realPositions = new Dictionary<ItemData, Vector2i>();

		internal static void UpdateSlots()
		{
			hotBarSlots = Slots.GetFoodSlots();
		}

		public static void GetItems(List<ItemData> bound)
		{
			if (Slots.PlayerInventory != null)
			{
				bound.AddRange(GetItems());
				AdaptGridPos(bound);
			}
		}

		private static void AdaptGridPos(List<ItemData> items)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			int num = 11 % Slots.InventoryWidth;
			if (num == 0)
			{
				return;
			}
			realPositions.Clear();
			foreach (ItemData item in items)
			{
				realPositions[item] = item.m_gridPos;
				item.m_gridPos.x -= num;
			}
		}

		public static void RestoreGridPos()
		{
			CollectionExtensions.Do<KeyValuePair<ItemData, Vector2i>>((IEnumerable<KeyValuePair<ItemData, Vector2i>>)realPositions, (Action<KeyValuePair<ItemData, Vector2i>>)delegate(KeyValuePair<ItemData, Vector2i> item)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				item.Key.m_gridPos = item.Value;
			});
			realPositions.Clear();
		}

		public static List<ItemData> GetItems()
		{
			return (from slot in hotBarSlots
				where slot.IsActive
				select slot.Item into item
				where item != null
				select item).ToList();
		}

		public static ItemData GetItemInSlot(int slotIndex)
		{
			return Slots.slots[slotIndex + 11].Item;
		}

		internal static void MarkDirty()
		{
			isDirty = true;
		}

		internal static void CreateBar()
		{
			hotBarRect = QuickBars.InstantiateHotKeyBar("ExtraSlotsFoodHotBar");
			if (!Object.op_Implicit((Object)(object)(hotBar = ((Component)hotBarRect).GetComponent<HotkeyBar>())))
			{
				return;
			}
			hotBar.m_selected = -1;
			foreach (ElementData element in hotBar.m_elements)
			{
				Object.Destroy((Object)(object)element.m_go);
			}
			for (int num = ((Transform)hotBarRect).childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Transform)hotBarRect).GetChild(num)).gameObject);
			}
			hotBar.m_elements.Clear();
			hotBar.m_items.Clear();
		}

		internal static bool Refresh()
		{
			//IL_006b: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (!isDirty)
			{
				return false;
			}
			if (IsEnabled() && (Object)(object)hotBarRect == (Object)null)
			{
				CreateBar();
			}
			else if (!IsEnabled() && (Object)(object)hotBarRect != (Object)null)
			{
				ClearBar();
			}
			if ((Object)(object)hotBarRect != (Object)null)
			{
				((Transform)hotBarRect).localScale = Vector3.one * ExtraSlots.foodSlotsHotBarScale.Value;
				hotBarRect.SetAnchor(ExtraSlots.foodSlotsHotBarAnchor.Value);
				hotBarRect.anchoredPosition = ExtraSlots.foodSlotsHotBarOffset.Value;
			}
			isDirty = false;
			return true;
		}

		internal static void ClearBar()
		{
			if ((Object)(object)hotBar != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)hotBar).gameObject);
			}
			if ((Object)(object)hotBarRect != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)hotBarRect).gameObject);
			}
			hotBar = null;
			hotBarRect = null;
		}

		internal static bool IsEnabled()
		{
			return ExtraSlots.foodSlotsHotBarEnabled.Value;
		}

		internal static Slots.Slot GetSlotWithShortcutDown()
		{
			return IsEnabled() ? hotBarSlots.FirstOrDefault((Slots.Slot slot) => slot.IsShortcutDownWithItem()) : null;
		}

		internal static IEnumerable<Slots.Slot> GetSlotsWithShortcutDown()
		{
			return IsEnabled() ? hotBarSlots.Where((Slots.Slot slot) => slot.IsShortcutDownWithItem()) : null;
		}
	}
	public static class AmmoSlotsHotBar
	{
		public const string barName = "ExtraSlotsAmmoHotBar";

		public const int barSlotIndex = 8;

		public static bool isDirty = true;

		private static HotkeyBar hotBar = null;

		private static RectTransform hotBarRect = null;

		private static Slots.Slot[] hotBarSlots = Array.Empty<Slots.Slot>();

		internal static void UpdateSlots()
		{
			hotBarSlots = Slots.GetAmmoSlots();
		}

		public static void GetItems(List<ItemData> bound)
		{
			if (Slots.PlayerInventory != null)
			{
				bound.AddRange(GetItems());
			}
		}

		public static List<ItemData> GetItems()
		{
			return (from slot in hotBarSlots
				where slot.IsActive
				select slot.Item into item
				where item != null
				select item).ToList();
		}

		public static ItemData GetItemInSlot(int slotIndex)
		{
			return Slots.slots[slotIndex + 8].Item;
		}

		internal static void MarkDirty()
		{
			isDirty = true;
		}

		internal static void CreateBar()
		{
			hotBarRect = QuickBars.InstantiateHotKeyBar("ExtraSlotsAmmoHotBar");
			if (!Object.op_Implicit((Object)(object)(hotBar = ((Component)hotBarRect).GetComponent<HotkeyBar>())))
			{
				return;
			}
			hotBar.m_selected = -1;
			foreach (ElementData element in hotBar.m_elements)
			{
				Object.Destroy((Object)(object)element.m_go);
			}
			for (int num = ((Transform)hotBarRect).childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Transform)hotBarRect).GetChild(num)).gameObject);
			}
			hotBar.m_elements.Clear();
			hotBar.m_items.Clear();
		}

		internal static bool Refresh()
		{
			//IL_006b: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (!isDirty)
			{
				return false;
			}
			if (IsEnabled() && (Object)(object)hotBarRect == (Object)null)
			{
				CreateBar();
			}
			else if (!IsEnabled() && (Object)(object)hotBarRect != (Object)null)
			{
				ClearBar();
			}
			if ((Object)(object)hotBarRect != (Object)null)
			{
				((Transform)hotBarRect).localScale = Vector3.one * ExtraSlots.ammoSlotsHotBarScale.Value;
				hotBarRect.SetAnchor(ExtraSlots.ammoSlotsHotBarAnchor.Value);
				hotBarRect.anchoredPosition = ExtraSlots.ammoSlotsHotBarOffset.Value;
			}
			isDirty = false;
			return true;
		}

		internal static void ClearBar()
		{
			if ((Object)(object)hotBar != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)hotBar).gameObject);
			}
			if ((Object)(object)hotBarRect != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)hotBarRect).gameObject);
			}
			hotBar = null;
			hotBarRect = null;
		}

		internal static bool IsEnabled()
		{
			return ExtraSlots.ammoSlotsHotBarEnabled.Value;
		}

		internal static Slots.Slot GetSlotWithShortcutDown()
		{
			return IsEnabled() ? hotBarSlots.FirstOrDefault((Slots.Slot slot) => slot.IsShortcutDownWithItem()) : null;
		}

		internal static IEnumerable<Slots.Slot> GetSlotsWithShortcutDown()
		{
			return IsEnabled() ? hotBarSlots.Where((Slots.Slot slot) => slot.IsShortcutDownWithItem()) : null;
		}
	}
	public static class PreventSimilarHotkeys
	{
		[HarmonyPatch(typeof(ZInput), "TryGetButtonState")]
		private static class ZInput_TryGetButtonState_PreventSimilarHotkeys
		{
			private static void Postfix(string name, ref bool __result)
			{
				if (__result && similarName.Contains(name))
				{
					__result = !IsAnyExtraSlotsHotkeyDown();
				}
			}
		}

		[HarmonyPatch(typeof(ZInput), "TryGetKeyStateLowLevel")]
		private static class ZInput_TryGetKeyStateLowLevel_PreventSimilarHotkeys
		{
			private static void Postfix(KeyCode keyCode, ref bool __result)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if (!_skipPrevention && __result && similarKeyCode.Contains(keyCode))
				{
					__result = !IsAnyExtraSlotsHotkeyDown();
				}
			}
		}

		[HarmonyPatch]
		public static class ZInput_InternalUpdate_ResetSimilarHotkeyState
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZInput), "InternalUpdate", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZInput), "InternalUpdateFixed", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						return false;
					}
				}

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

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

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

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

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

			private static void Finalizer()
			{
				ResetHotkeyState();
			}
		}

		[HarmonyPatch]
		public static class ZInput_SimilarHotkeyOnBind
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZInput), "ResetKBMButtons", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZInput), "ResetGamepadButtonsGeneric", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZInput), "ResetGamepadToClassic", (Type[])null, (Type[])null);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZInput), "ResetGamepadToAlt1", (Type[])null, (Type[])null);
						<>1__state = 4;
						return true;
					case 4:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZInput), "ResetGamepadToAlt2", (Type[])null, (Type[])null);
						<>1__state = 5;
						return true;
					case 5:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZInput), "OnRebindComplete", (Type[])null, (Type[])null);
						<>1__state = 6;
						return true;
					case 6:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZInput), "ResetToDefault", (Type[])null, (Type[])null);
						<>1__state = 7;
						return true;
					case 7:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(ZInput), "Load", (Type[])null, (Type[])null);
						<>1__state = 8;
						return true;
					case 8:
						<>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<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__0(0);
				}

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

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

			private static void Finalizer(ZInput __instance)
			{
				FillSimilarHotkey(__instance);
			}
		}

		[HarmonyPatch(typeof(ConnectPanel), "Update")]
		public static class ConnectPanel_Update_RebindF2
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> instructions;

				public IEnumerable<CodeInstruction> <>3__instructions;

				private IEnumerator<CodeInstruction> <>s__1;

				private CodeInstruction <instr>5__2;

				private int <value>5__3;

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

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

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

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

				private bool MoveNext()
				{
					//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d8: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<>s__1 = instructions.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							goto IL_010c;
						case 2:
							{
								<>1__state = -3;
								goto IL_010c;
							}
							IL_010c:
							<instr>5__2 = null;
							break;
						}
						if (<>s__1.MoveNext())
						{
							<instr>5__2 = <>s__1.Current;
							if (<instr>5__2.opcode == OpCodes.Ldc_I4)
							{
								object operand = <instr>5__2.operand;
								if (operand is int)
								{
									<value>5__3 = (int)operand;
									if (<value>5__3 == 283)
									{
										<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ConnectPanel_Update_RebindF2), "GetCustomKey", (Type[])null, (Type[])null));
										<>1__state = 1;
										return true;
									}
								}
							}
							<>2__current = <instr>5__2;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>s__1 = 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 (<>s__1 != null)
					{
						<>s__1.Dispose();
					}
				}

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

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

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

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

			private static KeyCode GetCustomKey()
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				return ExtraSlots.rebindConnectPanel.Value;
			}
		}

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

		private static readonly HashSet<KeyCode> similarKeyCode = new HashSet<KeyCode>();

		private static bool _anyExtraSlotsHotkeyDown;

		private static int _cacheUpdatedToken = -1;

		private static bool _skipPrevention;

		public static bool IsShortcutDown(KeyboardShortcut shortcut)
		{
			//IL_0009: 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)
			_skipPrevention = true;
			bool result = (int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && ZInput.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey, true) && ((KeyboardShortcut)(ref shortcut)).Modifiers.All((KeyCode key) => ZInput.GetKey(key, true));
			_skipPrevention = false;
			return result;
		}

		private static int GetCacheToken()
		{
			return (Time.frameCount << 1) | (Time.inFixedTimeStep ? 1 : 0);
		}

		private static void ResetHotkeyState()
		{
			_cacheUpdatedToken = -1;
			_anyExtraSlotsHotkeyDown = false;
		}

		public static void FillSimilarHotkey()
		{
			FillSimilarHotkey(ZInput.instance);
		}

		internal static void FillSimilarHotkey(ZInput __instance)
		{
			//IL_0142: 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_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: 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_0173: Unknown result type (might be due to invalid IL or missing references)
			if (ExtraSlots.IsDedicated)
			{
				return;
			}
			SanitizeShortcutsKeys();
			similarName.Clear();
			similarKeyCode.Clear();
			if (__instance == null || __instance.m_buttons == null)
			{
				return;
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (KeyValuePair<string, ButtonDef> button in __instance.m_buttons)
			{
				string actionPath = button.Value.GetActionPath(true);
				if (!string.IsNullOrEmpty(actionPath) && !dictionary.ContainsKey(actionPath))
				{
					dictionary[actionPath] = button.Key;
				}
				string actionPath2 = button.Value.GetActionPath(false);
				if (!string.IsNullOrEmpty(actionPath2) && !dictionary.ContainsKey(actionPath2))
				{
					dictionary[actionPath2] = button.Key;
				}
			}
			Key val = default(Key);
			foreach (Slots.Slot item in Slots.slots.Where((Slots.Slot slot) => slot.IsHotkeySlot))
			{
				KeyboardShortcut shortcut = item.GetShortcut();
				KeyCode mainKey = ((KeyboardShortcut)(ref shortcut)).MainKey;
				similarKeyCode.Add(mainKey);
				if (ZInput.TryKeyCodeToKey(mainKey, ref val))
				{
					string key = ZInput.KeyToPath(val);
					if (dictionary.TryGetValue(key, out var value))
					{
						similarName.Add(value);
					}
				}
			}
			ResetHotkeyState();
		}

		private static void SanitizeShortcutsKeys()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_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_0041: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			foreach (ConfigEntry<KeyboardShortcut> hotkeysConfig in ExtraSlots.GetHotkeysConfigs())
			{
				KeyboardShortcut value = hotkeysConfig.Value;
				KeyCode mainKey = ((KeyboardShortcut)(ref value)).MainKey;
				if (!ZInput.IsKeyCodeValid(mainKey) || (!IsCorrectKeyboardBind(mainKey) && !IsCorrectGamepadBind(mainKey) && !IsCorrectMouseBind(mainKey)))
				{
					value = hotkeysConfig.Value;
					if (!((object)(KeyboardShortcut)(ref value)).Equals((object?)KeyboardShortcut.Empty))
					{
						ExtraSlots.LogWarning($"Wrong bind data on {((ConfigEntryBase)hotkeysConfig).Definition}: {hotkeysConfig.Value}. Hotkey cleared.");
					}
					hotkeysConfig.Value = KeyboardShortcut.Empty;
				}
				ReorderKeys(hotkeysConfig);
			}
		}

		private static bool IsCorrectKeyboardBind(KeyCode keyCode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			Key val = default(Key);
			return ZInput.TryKeyCodeToKey(keyCode, ref val) && (int)val > 0;
		}

		private static bool IsCorrectMouseBind(KeyCode keyCode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			MouseButton val = default(MouseButton);
			return ZInput.TryKeyCodeToMouseButton(keyCode, ref val) && (int)val != 0 && (int)val != 1;
		}

		private static bool IsCorrectGamepadBind(KeyCode keyCode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			GamepadButton val = default(GamepadButton);
			return ZInput.TryKeyCodeToGamepadButton(keyCode, ref val);
		}

		private static void ReorderKeys(ConfigEntry<KeyboardShortcut> keyboardShortcut)
		{
			//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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			//IL_006f: 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_0094: 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_009c: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = keyboardShortcut.Value;
			if (!IsModifier(((KeyboardShortcut)(ref value)).MainKey))
			{
				return;
			}
			value = keyboardShortcut.Value;
			KeyCode key2 = ((KeyboardShortcut)(ref value)).Modifiers.FirstOrDefault((Func<KeyCode, bool>)((KeyCode key) => !IsModifier(key)));
			if ((int)key2 != 0)
			{
				KeyCode val = key2;
				value = keyboardShortcut.Value;
				IEnumerable<KeyCode> enumerable = ((KeyboardShortcut)(ref value)).Modifiers.Where((KeyCode k) => k != key2);
				value = keyboardShortcut.Value;
				keyboardShortcut.Value = new KeyboardShortcut(val, CollectionExtensions.AddItem<KeyCode>(enumerable, ((KeyboardShortcut)(ref value)).MainKey).ToArray());
				ExtraSlots.LogWarning($"Reordered bind data on {((ConfigEntryBase)keyboardShortcut).Definition}: {keyboardShortcut.Value}.");
			}
		}

		private static bool IsModifier(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Invalid comparison between Unknown and I4
			return (int)key == 313 || (int)key == 308 || (int)key == 307 || (int)key == 304 || (int)key == 303 || (int)key == 306 || (int)key == 305 || (int)key == 310 || (int)key == 309 || (int)key == 310 || (int)key == 309 || (int)key == 311 || (int)key == 312;
		}

		internal static bool IsAnyExtraSlotsHotkeyDown()
		{
			int cacheToken = GetCacheToken();
			if (_cacheUpdatedToken == cacheToken)
			{
				return _anyExtraSlotsHotkeyDown;
			}
			_cacheUpdatedToken = cacheToken;
			_anyExtraSlotsHotkeyDown = false;
			foreach (Slots.Slot item in Slots.slots.Where((Slots.Slot slot) => slot.IsHotkeySlot))
			{
				if (!item.IsShortcutDownWithItem())
				{
					continue;
				}
				_anyExtraSlotsHotkeyDown = true;
				break;
			}
			return _anyExtraSlotsHotkeyDown;
		}
	}
	public static class QuickSlotsHotBar
	{
		public const string barName = "ExtraSlotsQuickSlotsHotBar";

		public const int barSlotIndex = 0;

		public static bool isDirty = true;

		private static HotkeyBar hotBar = null;

		private static RectTransform hotBarRect = null;

		private static Slots.Slot[] hotBarSlots = Array.Empty<Slots.Slot>();

		internal static void UpdateSlots()
		{
			hotBarSlots = Slots.GetQuickSlots();
		}

		public static void GetItems(List<ItemData> bound)
		{
			if (Slots.PlayerInventory != null)
			{
				bound.AddRange(GetItems());
			}
		}

		public static List<ItemData> GetItems()
		{
			return (from slot in hotBarSlots
				where slot.IsActive
				select slot.Item into item
				where item != null
				select item).ToList();
		}

		public static ItemData GetItemInSlot(int slotIndex)
		{
			return Slots.slots[slotIndex].Item;
		}

		internal static void MarkDirty()
		{
			isDirty = true;
		}

		internal static void CreateBar()
		{
			hotBarRect = QuickBars.InstantiateHotKeyBar("ExtraSlotsQuickSlotsHotBar");
			if (!Object.op_Implicit((Object)(object)(hotBar = ((Component)hotBarRect).GetComponent<HotkeyBar>())))
			{
				return;
			}
			hotBar.m_selected = -1;
			foreach (ElementData element in hotBar.m_elements)
			{
				Object.Destroy((Object)(object)element.m_go);
			}
			for (int num = ((Transform)hotBarRect).childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Transform)hotBarRect).GetChild(num)).gameObject);
			}
			hotBar.m_elements.Clear();
			hotBar.m_items.Clear();
		}

		internal static bool Refresh()
		{
			//IL_006b: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (!isDirty)
			{
				return false;
			}
			if (IsEnabled() && (Object)(object)hotBarRect == (Object)null)
			{
				CreateBar();
			}
			else if (!IsEnabled() && (Object)(object)hotBarRect != (Object)null)
			{
				ClearBar();
			}
			if ((Object)(object)hotBarRect != (Object)null)
			{
				((Transform)hotBarRect).localScale = Vector3.one * ExtraSlots.quickSlotsHotBarScale.Value;
				hotBarRect.SetAnchor(ExtraSlots.quickSlotsHotBarAnchor.Value);
				hotBarRect.anchoredPosition = ExtraSlots.quickSlotsHotBarOffset.Value;
			}
			isDirty = false;
			return true;
		}

		internal static void ClearBar()
		{
			if ((Object)(object)hotBar != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)hotBar).gameObject);
			}
			if ((Object)(object)hotBarRect != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)hotBarRect).gameObject);
			}
			hotBar = null;
			hotBarRect = null;
		}

		internal static bool IsEnabled()
		{
			return ExtraSlots.quickSlotsHotBarEnabled.Value;
		}

		internal static Slots.Slot GetSlotWithShortcutDown()
		{
			return IsEnabled() ? hotBarSlots.FirstOrDefault((Slots.Slot slot) => slot.IsShortcutDownWithItem()) : null;
		}

		internal static IEnumerable<Slots.Slot> GetSlotsWithShortcutDown()
		{
			return IsEnabled() ? hotBarSlots.Where((Slots.Slot slot) => slot.IsShortcutDownWithItem()) : null;
		}
	}
	public static class QuickBars
	{
		[HarmonyPatch(typeof(Hud), "Update")]
		public static class Hud_Update_BarController
		{
			public static void Postfix()
			{
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return;
				}
				if (QuickSlotsHotBar.Refresh() || AmmoSlotsHotBar.Refresh() || FoodSlotsHotBar.Refresh())
				{
					ResetBars();
				}
				if (bars == null)
				{
					bars = GetHotKeyBarsToControl();
				}
				if (NoBarsToControl())
				{
					return;
				}
				bool joyButtonDown = GetJoyButtonDown("JoyHotbarLeft");
				bool joyButtonDown2 = GetJoyButtonDown("JoyHotbarRight");
				bool joyButtonDown3 = GetJoyButtonDown("JoyHotbarUse");
				if (!UpdateCurrentHotkeyBar(joyButtonDown, joyButtonDown2, joyButtonDown3) && (joyButtonDown || joyButtonDown2 || joyButtonDown3))
				{
					ChangeActiveHotkeyBar();
				}
				bool flag = false;
				for (int num = bars.Count - 1; num >= 0; num--)
				{
					if ((Object)(object)bars[num] == (Object)null)
					{
						bars.RemoveAt(num);
						flag = true;
					}
					else
					{
						HotkeyBar val = bars[num];
						val.m_selected = ((_currentBarIndex != num) ? (-1) : Mathf.Clamp(val.m_selected, -1, val.m_elements.Count - 1));
						val.UpdateIcons(Player.m_localPlayer);
					}
				}
				if (!flag)
				{
					return;
				}
				for (int i = 0; i < bars.Count; i++)
				{
					HotkeyBar val2 = bars[i];
					if (Object.op_Implicit((Object)(object)val2))
					{
						val2.m_items.Clear();
						val2.UpdateIcons((Player)null);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "OnDestroy")]
		public static class Hud_OnDestroy_ResetBars
		{
			public static void Postfix()
			{
				ResetBars();
			}
		}

		[HarmonyPatch(typeof(HotkeyBar), "Update")]
		public static class HotkeyBar_Update_PreventCall
		{
			[HarmonyPriority(800)]
			public static bool Prefix()
			{
				return NoBarsToControl();
			}
		}

		[HarmonyPatch(typeof(HotkeyBar), "UpdateIcons")]
		public static class HotkeyBar_UpdateIcons_QuickBarsUpdate
		{
			public static bool inCall;

			public static string barName;

			public static void Prefix(HotkeyBar __instance)
			{
				if (!(((Object)__instance).name != "ExtraSlotsQuickSlotsHotBar") || !(((Object)__instance).name != "ExtraSlotsAmmoHotBar") || !(((Object)__instance).name != "ExtraSlotsFoodHotBar"))
				{
					barName = ((Object)__instance).name;
					inCall = true;
				}
			}

			public static void Postfix(HotkeyBar __instance)
			{
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: Invalid comparison between Unknown and I4
				//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
				if (!inCall)
				{
					return;
				}
				inCall = false;
				if (((Object)__instance).name == "ExtraSlotsQuickSlotsHotBar" || ((Object)__instance).name == "ExtraSlotsAmmoHotBar" || ((Object)__instance).name == "ExtraSlotsFoodHotBar")
				{
					for (int i = 0; i < __instance.m_elements.Count; i++)
					{
						ElementData val = __instance.m_elements[i];
						if (!elementsExtraData.ContainsKey(val.m_go))
						{
							Transform val2 = val.m_go.transform.Find("binding");
							elementsExtraData[val.m_go] = Tuple.Create<RectTransform, TMP_Text>(((Component)val2).GetComponent<RectTransform>(), ((Component)val2).GetComponent<TMP_Text>());
						}
						Tuple<RectTransform, TMP_Text> tuple = elementsExtraData[val.m_go];
						Slots.Slot slot = Slots.slots[i + ((((Object)__instance).name == "ExtraSlotsFoodHotBar") ? 11 : ((((Object)__instance).name == "ExtraSlotsAmmoHotBar") ? 8 : 0))];
						EquipmentPanel.SetSlotLabel(tuple.Item1, tuple.Item2, slot, hotbarElement: true);
						if (((((Object)__instance).name == "ExtraSlotsQuickSlotsHotBar") ? ExtraSlots.quickSlotsHideStackSize.Value : ((((Object)__instance).name == "ExtraSlotsAmmoHotBar") ? ExtraSlots.ammoSlotsHideStackSize.Value : ExtraSlots.foodSlotsHideStackSize.Value)) && ((Component)val.m_amount).gameObject.activeInHierarchy)
						{
							ItemData item = slot.Item;
							if (item != null && (item.IsEquipable() || (int)item.m_shared.m_itemType == 2))
							{
								val.m_amount.SetText(StringExtensionMethods.ToFastString(val.m_stackText));
							}
						}
						int num = ((((Object)__instance).name == "ExtraSlotsQuickSlotsHotBar") ? ExtraSlots.quickSlotsWidthInElements.Value : ((((Object)__instance).name == "ExtraSlotsAmmoHotBar") ? ExtraSlots.ammoSlotsWidthInElements.Value : ExtraSlots.foodSlotsWidthInElements.Value));
						bool flag = ((((Object)__instance).name == "ExtraSlotsQuickSlotsHotBar") ? ExtraSlots.quickSlotsFillDirectionUp.Value : ((((Object)__instance).name == "ExtraSlotsAmmoHotBar") ? ExtraSlots.ammoSlotsFillDirectionUp.Value : ExtraSlots.foodSlotsFillDirectionUp.Value));
						float num2 = ((((Object)__instance).name == "ExtraSlotsQuickSlotsHotBar") ? ExtraSlots.quickSlotsElementSpace.Value : ((((Object)__instance).name == "ExtraSlotsAmmoHotBar") ? ExtraSlots.ammoSlotsElementSpace.Value : ExtraSlots.foodSlotsElementSpace.Value));
						val.m_go.transform.localPosition = new Vector3((float)(i % num), (float)((flag ? 1 : (-1)) * i / num), 0f) * num2;
					}
				}
				if (((Object)__instance).name == "ExtraSlotsFoodHotBar")
				{
					FoodSlotsHotBar.RestoreGridPos();
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "GetBoundItems")]
		public static class Inventory_GetBoundItems_QuickBarsItems
		{
			public static void Postfix(Inventory __instance, List<ItemData> bound)
			{
				if (__instance == Slots.PlayerInventory && HotkeyBar_UpdateIcons_QuickBarsUpdate.inCall)
				{
					bound.Clear();
					if (HotkeyBar_UpdateIcons_QuickBarsUpdate.barName == "ExtraSlotsQuickSlotsHotBar")
					{
						QuickSlotsHotBar.GetItems(bound);
					}
					else if (HotkeyBar_UpdateIcons_QuickBarsUpdate.barName == "ExtraSlotsAmmoHotBar")
					{
						AmmoSlotsHotBar.GetItems(bound);
					}
					else if (HotkeyBar_UpdateIcons_QuickBarsUpdate.barName == "ExtraSlotsFoodHotBar")
					{
						FoodSlotsHotBar.GetItems(bound);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "Awake")]
		public static class Hud_Awake_CreateQuickBars
		{
			public static void Postfix()
			{
				QuickSlotsHotBar.MarkDirty();
				AmmoSlotsHotBar.MarkDirty();
				FoodSlotsHotBar.MarkDirty();
			}
		}

		[HarmonyPatch(typeof(Hud), "OnDestroy")]
		public static class Hud_OnDestroy_ClearQuickBars
		{
			public static void Postfix()
			{
				QuickSlotsHotBar.ClearBar();
				AmmoSlotsHotBar.ClearBar();
				FoodSlotsHotBar.ClearBar();
			}
		}

		[HarmonyPatch(typeof(Player), "Update")]
		private static class Player_Update_SlotsUse
		{
			private static void Postfix(Player __instance)
			{
				if (Slots.IsValidPlayer((Character)(object)__instance))
				{
					UpdateItemUse();
				}
			}
		}

		public const string vanillaBarName = "HotKeyBar";

		private static List<HotkeyBar> bars;

		private static int _currentBarIndex = -1;

		private static readonly HashSet<string> barNames = new HashSet<string> { "HotKeyBar", "ExtraSlotsQuickSlotsHotBar", "ExtraSlotsAmmoHotBar", "ExtraSlotsFoodHotBar" };

		private static readonly Dictionary<GameObject, Tuple<RectTransform, TMP_Text>> elementsExtraData = new Dictionary<GameObject, Tuple<RectTransform, TMP_Text>>();

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

		private static Vector3 LeftTopPoint => Object.op_Implicit((Object)(object)Hud.instance) ? new Vector3(0f - Hud.instance.m_rootObject.transform.position.x, Hud.instance.m_rootObject.transform.position.y, 0f) : new Vector3(-1280f, 720f, 0f);

		public static RectTransform InstantiateHotKeyBar(string barName)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)Hud.instance.m_rootObject.transform.Find("HotKeyBar")).GetComponent<RectTransform>();
			RectTransform val = Object.Instantiate<RectTransform>(component, Hud.instance.m_rootObject.transform, true);
			((Object)val).name = barName;
			((Transform)val).localPosition = Vector3.zero;
			((Transform)val).SetSiblingIndex(((Transform)component).GetSiblingIndex() + 1);
			return val;
		}

		public static void ResetBars()
		{
			elementsExtraData.Clear();
			_currentBarIndex = -1;
			bars = null;
		}

		public static bool IsBarToControl(HotkeyBar bar)
		{
			return (Object)(object)bar != (Object)null && barNames.Contains(((Object)bar).name);
		}

		public static void UseCustomBarItem(HotkeyBar bar)
		{
		}

		private static List<HotkeyBar> GetHotKeyBarsToControl()
		{
			return Object.op_Implicit((Object)(object)Hud.instance) ? (from bar in Hud.instance.m_rootObject.GetComponentsInChildren<HotkeyBar>().Where(IsBarToControl)
				orderby Vector3.Distance(((Component)bar).transform.localPosition, LeftTopPoint)
				select bar).ToList() : null;
		}

		private static bool UpdateCurrentHotkeyBar(bool joyHotbarLeft, bool joyHotbarRight, bool joyHotbarUse)
		{
			if (_currentBarIndex < 0 || _currentBarIndex > bars.Count - 1)
			{
				return false;
			}
			HotkeyBar val = bars[_currentBarIndex];
			bool flag = IsHotkeyBarsActive();
			if (val.m_selected < 0 || val.m_selected > val.m_elements.Count - 1 || !flag)
			{
				return !flag;
			}
			if (joyHotbarLeft)
			{
				if (--val.m_selected < 0)
				{
					ChangeActiveHotkeyBar(next: false);
					goto IL_01c9;
				}
			}
			if (joyHotbarRight)
			{
				if (++val.m_selected > val.m_elements.Count - 1)
				{
					ChangeActiveHotkeyBar();
					goto IL_01c9;
				}
			}
			if (joyHotbarUse)
			{
				if (((Object)val).name == "ExtraSlotsQuickSlotsHotBar")
				{
					((Humanoid)Player.m_localPlayer).UseItem(((Humanoid)Player.m_localPlayer).GetInventory(), QuickSlotsHotBar.GetItemInSlot(val.m_selected), false);
				}
				else if (((Object)val).name == "ExtraSlotsAmmoHotBar")
				{
					((Humanoid)Player.m_localPlayer).UseItem(((Humanoid)Player.m_localPlayer).GetInventory(), AmmoSlotsHotBar.GetItemInSlot(val.m_selected), false);
				}
				else if (((Object)val).name == "ExtraSlotsFoodHotBar")
				{
					((Humanoid)Player.m_localPlayer).UseItem(((Humanoid)Player.m_localPlayer).GetInventory(), FoodSlotsHotBar.GetItemInSlot(val.m_selected), false);
				}
				else if (((Object)val).name == "HotKeyBar")
				{
					Player.m_localPlayer.UseHotbarItem(val.m_selected + 1);
				}
				else
				{
					UseCustomBarItem(val);
				}
			}
			goto IL_01c9;
			IL_01c9:
			return true;
		}

		private static void ChangeActiveHotkeyBar(bool next = true)
		{
			int[] array = (from bar in bars
				where bar.m_elements.Count > 0
				select bars.IndexOf(bar)).ToArray();
			if (array.Length == 0)
			{
				_currentBarIndex = -1;
				return;
			}
			int num = Array.IndexOf(array, _currentBarIndex);
			num = ((num != -1) ? (num + (next ? 1 : (-1))) : 0);
			_currentBarIndex = array[(num + array.Length) % array.Length];
			bars[_currentBarIndex].m_selected = ((!next) ? (bars[_currentBarIndex].m_elements.Count - 1) : 0);
		}

		private static bool IsHotkeyBarsActive()
		{
			return !InventoryGui.IsVisible() && !Menu.IsVisible() && !GameCamera.InFreeFly() && !Minimap.IsOpen() && !Hud.IsPieceSelectionVisible() && !StoreGui.IsVisible() && !Console.IsVisible() && !Chat.instance.HasFocus() && !PlayerCustomizaton.IsBarberGuiVisible() && !Hud.InRadial();
		}

		internal static void UpdateItemUse()
		{
			if (!((Character)Player.m_localPlayer).TakeInput() || !PreventSimilarHotkeys.IsAnyExtraSlotsHotkeyDown())
			{
				return;
			}
			if (!ExtraSlots.useSingleHotbarItem.Value)
			{
				CollectionExtensions.Do<ItemData>(GetItemsToUse(), (Action<ItemData>)delegate(ItemData item)
				{
					((Humanoid)Player.m_localPlayer).UseItem(Slots.PlayerInventory, item, false);
				});
				return;
			}
			ItemData itemToUse = GetItemToUse();
			if (itemToUse != null)
			{
				((Humanoid)Player.m_localPlayer).UseItem(Slots.PlayerInventory, itemToUse, false);
			}
		}

		private static ItemData GetItemToUse()
		{
			//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_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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			Slots.Slot slotWithShortcutDown = QuickSlotsHotBar.GetSlotWithShortcutDown();
			Slots.Slot slotWithShortcutDown2 = AmmoSlotsHotBar.GetSlotWithShortcutDown();
			Slots.Slot slotWithShortcutDown3 = FoodSlotsHotBar.GetSlotWithShortcutDown();
			KeyboardShortcut shortcut;
			if (slotWithShortcutDown != null && slotWithShortcutDown2 != null && slotWithShortcutDown3 != null)
			{
				shortcut = slotWithShortcutDown.GetShortcut();
				int num = ((KeyboardShortcut)(ref shortcut)).Modifiers.Count();
				shortcut = slotWithShortcutDown2.GetShortcut();
				int num2 = ((KeyboardShortcut)(ref shortcut)).Modifiers.Count();
				shortcut = slotWithShortcutDown3.GetShortcut();
				int num3 = ((KeyboardShortcut)(ref shortcut)).Modifiers.Count();
				if (num >= num2 && num >= num3)
				{
					return slotWithShortcutDown.Item;
				}
				if (num2 >= num && num2 >= num3)
				{
					return slotWithShortcutDown2.Item;
				}
				return slotWithShortcutDown3.Item;
			}
			if (slotWithShortcutDown != null && slotWithShortcutDown2 != null)
			{
				shortcut = slotWithShortcutDown.GetShortcut();
				int num4 = ((KeyboardShortcut)(ref shortcut)).Modifiers.Count();
				shortcut = slotWithShortcutDown2.GetShortcut();
				if (num4 >= ((KeyboardShortcut)(ref shortcut)).Modifiers.Count())
				{
					return slotWithShortcutDown.Item;
				}
				return slotWithShortcutDown2.Item;
			}
			if (slotWithShortcutDown != null && slotWithShortcutDown3 != null)
			{
				shortcut = slotWithShortcutDown.GetShortcut();
				int num5 = ((KeyboardShortcut)(ref shortcut)).Modifiers.Count();
				shortcut = slotWithShortcutDown3.GetShortcut();
				if (num5 >= ((KeyboardShortcut)(ref shortcut)).Modifiers.Count())
				{
					return slotWithShortcutDown.Item;
				}
				return slotWithShortcutDown3.Item;
			}
			if (slotWithShortcutDown2 != null && slotWithShortcutDown3 != null)
			{
				shortcut = slotWithShortcutDown2.GetShortcut();
				int num6 = ((KeyboardShortcut)(ref shortcut)).Modifiers.Count();
				shortcut = slotWithShortcutDown3.GetShortcut();
				if (num6 >= ((KeyboardShortcut)(ref shortcut)).Modifiers.Count())
				{
					return slotWithShortcutDown2.Item;
				}
				return slotWithShortcutDown3.Item;
			}
			if (slotWithShortcutDown != null)
			{
				return slotWithShortcutDown.Item;
			}
			if (slotWithShortcutDown2 != null)
			{
				return slotWithShortcutDown2.Item;
			}
			return slotWithShortcutDown3?.Item;
		}

		private static IEnumerable<ItemData> GetItemsToUse()
		{
			itemsToUse.Clear();
			IEnumerable<Slots.Slot> slotsWithShortcutDown = QuickSlotsHotBar.GetSlotsWithShortcutDown();
			if (slotsWithShortcutDown != null)
			{
				foreach (Slots.Slot item in slotsWithShortcutDown)
				{
					itemsToUse.Add(item.Item);
				}
			}
			IEnumerable<Slots.Slot> slotsWithShortcutDown2 = AmmoSlotsHotBar.GetSlotsWithShortcutDown();
			if (slotsWithShortcutDown2 != null)
			{
				foreach (Slots.Slot item2 in slotsWithShortcutDown2)
				{
					itemsToUse.Add(item2.Item);
				}
			}
			IEnumerable<Slots.Slot> slotsWithShortcutDown3 = FoodSlotsHotBar.GetSlotsWithShortcutDown();
			if (slotsWithShortcutDown3 != null)
			{
				foreach (Slots.Slot item3 in slotsWithShortcutDown3)
				{
					itemsToUse.Add(item3.Item);
				}
			}
			return itemsToUse;
		}

		private static bool GetJoyButtonDown(string name)
		{
			return !PlantEasilyCompat.DisableGamepadInput && ZInput.GetButtonDown(name) && !ZInput.GetButton("JoyAltKeys");
		}

		private static bool NoBarsToControl()
		{
			return bars == null || bars.Count == 0 || (bars.Count == 1 && ((Object)bars[0]).name == "HotKeyBar");
		}
	}
}
namespace ExtraSlots.Compatibility
{
	public static class ValheimRadial
	{
		[HarmonyPatch]
		public static class ValheimRadial_InventoryRowGroupConfig_GetConfiguredInventoryItems_ReturnExtraSlotsItems
		{
			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!Chainloader.PluginInfos.TryGetValue("PerspectiveBroad4501.ValheimRadial", out var value))
				{
					return false;
				}
				if ((object)target == null)
				{
					target = AccessTools.Method(Assembly.GetAssembly(((object)value.Instance).GetType()).GetType("ValheimRadial.InventoryRowGroupConfig"), "GetConfiguredInventoryItems", (Type[])null, (Type[])null);
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("ValheimRadial.InventoryRowGroupConfig.InventoryRowGroupConfig:GetConfiguredInventoryItems method is patched to return items in extra slots");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			public static void Postfix(ref List<ItemData> __result)
			{
				if (ExtraSlots.valheimRadialAddQuickSlots.Value)
				{
					__result.AddRange(API.GetQuickSlotsItems());
				}
				if (ExtraSlots.valheimRadialAddAmmoSlots.Value)
				{
					__result.AddRange(API.GetAmmoSlotsItems());
				}
				if (ExtraSlots.valheimRadialAddFoodSlots.Value)
				{
					__result.AddRange(API.GetFoodSlotsItems());
				}
			}
		}

		public const string GUID = "PerspectiveBroad4501.ValheimRadial";
	}
	public static class BBHCompat
	{
		[HarmonyPatch(typeof(Inventory), "GetAmmoItem")]
		internal static class Inventory_GetAmmoItem_BBHFix
		{
			private static void Postfix(Inventory __instance, string ammoName, string matchPrefabName, ref ItemData __result)
			{
				if (!isEnabled)
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (__instance != ((localPlayer != null) ? ((Humanoid)localPlayer).GetInventory() : null) || __result == ((Humanoid)Player.m_localPlayer).GetAmmoItem())
				{
					return;
				}
				Inventory quiverBarInventory = GetQuiverBarInventory(Player.m_localPlayer);
				if (quiverBarInventory == null || quiverBarInventory.m_inventory == null)
				{
					return;
				}
				ItemData val = null;
				foreach (ItemData item in quiverBarInventory.m_inventory.Where((ItemData itemData) => IsItemFitsFilter(itemData, ammoName, matchPrefabName)))
				{
					if (val == null)
					{
						val = item;
					}
					if (item.m_equipped)
					{
						__result = item;
						return;
					}
				}
				if (val != null)
				{
					__result = val;
				}
			}

			private static bool IsItemFitsFilter(ItemData item, string ammoName, string matchPrefabName = null)
			{
				//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_002a: Invalid comparison between Unknown and I4
				int result;
				if (((int)item.m_shared.m_itemType == 9 || (int)item.m_shared.m_itemType == 23 || (int)item.m_shared.m_itemType == 2) && item.m_shared.m_ammoType == ammoName)
				{
					if (matchPrefabName != null)
					{
						GameObject dropPrefab = item.m_dropPrefab;
						result = ((((dropPrefab != null) ? ((Object)dropPrefab).name : null) == matchPrefabName) ? 1 : 0);
					}
					else
					{
						result = 1;
					}
				}
				else
				{
					result = 0;
				}
				return (byte)result != 0;
			}
		}

		[HarmonyPatch(typeof(Inventory), "CountItems")]
		internal static class Inventory_CountItems_BBHFix
		{
			private static void Postfix(Inventory __instance, string name, ref int __result, int quality = -1, bool matchWorldLevel = true)
			{
				if (!isEnabled)
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (__instance != ((localPlayer != null) ? ((Humanoid)localPlayer).GetInventory() : null))
				{
					return;
				}
				Inventory quiverBarInventory = GetQuiverBarInventory(Player.m_localPlayer);
				if (quiverBarInventory != null && quiverBarInventory.m_inventory != null)
				{
					__result += quiverBarInventory.m_inventory.Where((ItemData itemData) => IsItemFitsFilter(itemData, name, quality, matchWorldLevel)).Sum((ItemData itemData) => itemData.m_stack);
				}
			}

			private static bool IsItemFitsFilter(ItemData item, string name, int quality = -1, bool matchWorldLevel = true)
			{
				return (name == null || item.m_shared.m_name == name) && (quality < 0 || quality == item.m_quality) && (!matchWorldLevel || item.m_worldLevel >= Game.m_worldLevel);
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
		public static class Humanoid_UnequipItem_QuiverInventoryCache
		{
			private static void Postfix(Humanoid __instance)
			{
				if (isEnabled && (Object)(object)__instance == (Object)(object)Player.m_localPlayer)
				{
					quiverInventoryCached = false;
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "EquipItem")]
		public static class Humanoid_EquipItem_QuiverInventoryCache
		{
			private static void Postfix(Humanoid __instance)
			{
				if (isEnabled && (Object)(object)__instance == (Object)(object)Player.m_localPlayer)
				{
					quiverInventoryCached = false;
				}
			}
		}

		public const string GUID = "Azumatt.BowsBeforeHoes";

		public static PluginInfo BBHPlugin;

		public static Assembly assembly;

		public static bool isEnabled;

		private static Func<Player, Inventory> _getQuiverBarInventory;

		private static bool quiverInventoryCached;

		private static int quiverInventoryCachedSecond;

		private static Inventory quiverInventoryFromCache;

		public static Inventory GetQuiverBarInventory(Player player)
		{
			if (!isEnabled || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return null;
			}
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return (_getQuiverBarInventory != null) ? _getQuiverBarInventory(player) : null;
			}
			if (quiverInventoryCachedSecond != (quiverInventoryCachedSecond = (int)ZNet.instance.GetTimeSeconds()) && quiverInventoryCachedSecond % 5 == 0)
			{
				quiverInventoryCached = false;
			}
			if (!quiverInventoryCached)
			{
				quiverInventoryCached = true;
				quiverInventoryFromCache = ((_getQuiverBarInventory != null) ? _getQuiverBarInventory(player) : null);
			}
			return quiverInventoryFromCache;
		}

		public static void CheckForCompatibility()
		{
			if (isEnabled = ExtraSlots.bbhArrowsFindingAndCounting.Value && Chainloader.PluginInfos.TryGetValue("Azumatt.BowsBeforeHoes", out BBHPlugin))
			{
				if ((object)assembly == null)
				{
					assembly = Assembly.GetAssembly(((object)BBHPlugin.Instance).GetType());
				}
				MethodInfo methodInfo = AccessTools.Method(assembly.GetType("BowsBeforeHoes.Extensions.PlayerExtensions"), "GetQuiverBarInventory", new Type[1] { typeof(Player) }, (Type[])null);
				if (methodInfo != null)
				{
					_getQuiverBarInventory = (Func<Player, Inventory>)Delegate.CreateDelegate(typeof(Func<Player, Inventory>), methodInfo);
					assembly.RemoveHarmonyPatch(typeof(Inventory), "GetAmmoItem", "BowsBeforeHoes.QuiverDisplay.InventoryGetAmmoItemPatch", "Postfix", "prevent ammo finding and counting mess");
					assembly.RemoveHarmonyPatch(typeof(Attack), "HaveAmmo", "BowsBeforeHoes.QuiverFunctionality.AttackHaveAmmoPatch", "Postfix", "prevent ammo finding and counting mess");
				}
				else
				{
					ExtraSlots.LogInfo("BowsBeforeHoes mod is loaded but BowsBeforeHoes.Extensions.PlayerExtensions:GetQuiverBarInventory is not found");
					isEnabled = false;
				}
			}
		}
	}
	public static class ZenUICompat
	{
		public const string GUID = "ZenDragon.ZenUI";

		public static Assembly assembly;

		public static PluginInfo plugin;

		public static void CheckForCompatibility()
		{
			if (Chainloader.PluginInfos.TryGetValue("ZenDragon.ZenUI", out plugin))
			{
				if ((object)assembly == null)
				{
					assembly = Assembly.GetAssembly(((object)plugin.Instance).GetType());
				}
				assembly.RemoveHarmonyPatch(typeof(Humanoid), "EquipItem", "ZenUI.Section.InventoryEquip", "Humanoid_EquipItem", "prevent item from going into assigned slot on equip");
				assembly.RemoveHarmonyPatch(typeof(InventoryGrid), "DropItem", "ZenUI.Section.InventoryEquip", "InventoryGrid_DropItem", "disable check if item in assigned slot");
			}
		}
	}
	public static class RequipMeCompat
	{
		public const string GUID = "neobotics.valheim_mod.requipme";

		public static Assembly assembly;

		public static PluginInfo plugin;

		public static void CheckForCompatibility()
		{
			if (Chainloader.PluginInfos.TryGetValue("neobotics.valheim_mod.requipme", out plugin))
			{
				if ((object)assembly == null)
				{
					assembly = Assembly.GetAssembly(((object)plugin.Instance).GetType());
				}
				assembly.RemoveHarmonyPatch(typeof(TombStone), "OnTakeAllSuccess", "neobotics.ValheimMods.RequipMe+On_Take_All_Success_Patch", "Postfix", "prevent inventory mess on tombstone equip");
				assembly.RemoveHarmonyPatch(typeof(TombStone), "EasyFitInInventory", "neobotics.ValheimMods.RequipMe+EasyFitInInventory_Patch", "Postfix", "prevent inventory mess on tombstone equip");
			}
		}
	}
	internal static class CompatibilityHelper
	{
		internal static void CheckForCompatibility()
		{
			EpicLootCompat.CheckForCompatibility();
			BetterArcheryCompat.CheckForCompatibility();
			PlantEasilyCompat.CheckForCompatibility();
			ValheimPlusCompat.CheckForCompatibility();
			BetterProgressionCompat.CheckForCompatibility();
			ZenBeehiveCompat.CheckForCompatibility();
			BBHCompat.CheckForCompatibility();
			Recycle_N_Reclaim.CheckForCompatibility();
			RequipMeCompat.CheckForCompatibility();
			ZenUICompat.CheckForCompatibility();
		}

		internal static void RemoveHarmonyPatch(this Assembly assembly, Type patchedType, string patchedMethod, string patcherClassName, string patcherClassMethod, string reason)
		{
			Type type = assembly.GetType(patcherClassName);
			if (type == null)
			{
				ExtraSlots.LogInfo(patcherClassName + " is not found.");
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(patchedType, patchedMethod, (Type[])null, (Type[])null);
			if ((object)methodInfo == null)
			{
				ExtraSlots.LogInfo("Method " + patchedType.Name + "." + patchedMethod + " is not found.");
				return;
			}
			MethodInfo methodInfo2 = AccessTools.Method(type, patcherClassMethod, (Type[])null, (Type[])null);
			if ((object)methodInfo2 == null)
			{
				ExtraSlots.LogInfo("Patch " + type.Name + "." + patcherClassMethod + " is not found.");
			}
			else
			{
				ExtraSlots.instance.harmony.Unpatch((MethodBase)methodInfo, methodInfo2);
				ExtraSlots.LogInfo(patcherClassName + ":" + patcherClassMethod + " was unpatched to " + reason + ".");
			}
		}

		internal static void RemoveHarmonyPatch(this Assembly assembly, MethodBase method, string patcherClassName, string patcherClassMethod, string reason)
		{
			Type type = assembly.GetType(patcherClassName);
			if (type == null)
			{
				ExtraSlots.LogInfo(patcherClassName + " is not found.");
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(type, patcherClassMethod, (Type[])null, (Type[])null);
			if ((object)methodInfo == null)
			{
				ExtraSlots.LogInfo("Patch " + type.Name + "." + patcherClassMethod + " is not found.");
			}
			else
			{
				ExtraSlots.instance.harmony.Unpatch(method, methodInfo);
				ExtraSlots.LogInfo(patcherClassName + ":" + patcherClassMethod + " was unpatched to " + reason + ".");
			}
		}

		internal static void TryAddMethodToPatch(this Assembly assembly, List<MethodBase> list, string methodClassName, string methodName, string reason)
		{
			Type type = assembly.GetType(methodClassName);
			if (type == null)
			{
				ExtraSlots.LogInfo(methodClassName + " is not found.");
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(type, methodName, (Type[])null, (Type[])null);
			if ((object)methodInfo == null)
			{
				ExtraSlots.LogInfo("Method " + type.Name + "." + methodName + " is not found.");
			}
			else
			{
				list.Add(methodInfo);
				ExtraSlots.LogInfo(methodClassName + ":" + methodName + " is patched to " + reason + ".");
			}
		}
	}
	public static class Recycle_N_Reclaim
	{
		[HarmonyPatch]
		public static class AdventureBackpacks_PlayerExtensions_CustomSlotItem
		{
			public static List<MethodBase> targets;

			public static List<MethodBase> GetTargets()
			{
				List<MethodBase> list = new List<MethodBase>();
				if (assembly == null)
				{
					return list;
				}
				assembly.TryAddMethodToPatch(list, "Recycle_N_Reclaim.GamePatches.Recycling.Reclaimer", "RecycleInventoryForAllRecipes", "ignore items in extra slots");
				assembly.TryAddMethodToPatch(list, "Recycle_N_Reclaim.GamePatches.Recycling.Reclaimer", "GetRecyclingAnalysisForInventory", "ignore items in extra slots");
				assembly.TryAddMethodToPatch(list, "Recycle_N_Reclaim.GamePatches.Recycling.Reclaimer", "RecycleOneItemInInventory", "ignore items in extra slots");
				return list;
			}

			public static bool Prepare()
			{
				return isEnabled && (targets ?? (targets = GetTargets())).Count > 0;
			}

			private static IEnumerable<MethodBase> TargetMethods()
			{
				return targets;
			}

			public static void Prefix(MethodBase __originalMethod, Inventory inventory)
			{
				if (ExtraSlots.recycle_N_ReclaimExcludeExtraSlots.Value && inventory == Slots.PlayerInventory)
				{
					itemsToIgnore.Clear();
					CollectionExtensions.DoIf<Slots.Slot>((IEnumerable<Slots.Slot>)Slots.slots, (Func<Slots.Slot, bool>)((Slots.Slot slot) => !slot.IsFree), (Action<Slots.Slot>)KeepItem);
				}
				void KeepItem(Slots.Slot slot)
				{
					//IL_000f: 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)
					ItemData item = slot.Item;
					itemsToIgnore.Add(item, item.m_gridPos);
					item.m_gridPos.y = 0;
					ExtraSlots.LogDebug($"{__originalMethod.Name}.Prefix: Recycling prevented for {item.m_shared.m_name} from slot {slot}. Item temporary moved into hotbar {item.m_gridPos}.");
				}
			}

			public static void Finalizer(MethodBase __originalMethod, Inventory inventory)
			{
				//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_0064: Unknown result type (might be due to invalid IL or missing references)
				if (itemsToIgnore.Count == 0)
				{
					return;
				}
				foreach (KeyValuePair<ItemData, Vector2i> item in itemsToIgnore)
				{
					item.Key.m_gridPos = item.Value;
					ExtraSlots.LogDebug($"{__originalMethod.Name}.Finalizer: {item.Key.m_shared.m_name} moved back to {item.Key.m_gridPos} after recycling preventing.");
				}
				itemsToIgnore.Clear();
			}
		}

		public const string GUID = "Azumatt.Recycle_N_Reclaim";

		private static readonly Dictionary<ItemData, Vector2i> itemsToIgnore = new Dictionary<ItemData, Vector2i>();

		public static PluginInfo plugin;

		public static Assembly assembly;

		public static bool isEnabled;

		public static void CheckForCompatibility()
		{
			if ((isEnabled = Chainloader.PluginInfos.TryGetValue("Azumatt.Recycle_N_Reclaim", out plugin)) && (object)assembly == null)
			{
				assembly = Assembly.GetAssembly(((object)plugin.Instance).GetType());
			}
		}
	}
	public static class SimpleSort
	{
		[HarmonyPatch]
		public static class SimpleSort_InternalIsEquipOrQuickSlot_IgnoreExtraSlots
		{
			[HarmonyPatch(typeof(Inventory), "Changed")]
			private static class Inventory_Changed_BringItemsBack
			{
				[HarmonyPriority(800)]
				private static void Prefix(Inventory __instance)
				{
					if (__instance == sortedInventory && itemsToKeep.Count != 0)
					{
						__instance.m_inventory.AddRange(itemsToKeep);
						ExtraSlots.LogDebug($"SimpleSort.SortByType.Postfix: {itemsToKeep.Count} item(s) returned to player inventory after sorting preventing.");
						itemsToKeep.Clear();
					}
				}
			}

			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!Chainloader.PluginInfos.TryGetValue("aedenthorn.SimpleSort", out var value))
				{
					return false;
				}
				if ((object)target == null)
				{
					target = AccessTools.Method(Assembly.GetAssembly(((object)value.Instance).GetType()).GetType("SimpleSort.BepInExPlugin"), "SortByType", (Type[])null, (Type[])null);
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("SimpleSort.BepInExPlugin:SortByType method is patched to ignore items in extra slots");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			public static void Prefix(Inventory inventory)
			{
				if (inventory == Slots.PlayerInventory)
				{
					sortedInventory = inventory;
					itemsToKeep.Clear();
					CollectionExtensions.DoIf<Slots.Slot>((IEnumerable<Slots.Slot>)Slots.slots, (Func<Slots.Slot, bool>)((Slots.Slot slot) => !slot.IsFree), (Action<Slots.Slot>)KeepItem);
				}
				void KeepItem(Slots.Slot slot)
				{
					ItemData item = slot.Item;
					itemsToKeep.Add(item);
					inventory.m_inventory.Remove(item);
					ExtraSlots.LogDebug($"SimpleSort.SortByType.Prefix: Sorting prevented for item {item.m_shared.m_name} from slot {slot}. Item temporary removed from player inventory.");
				}
			}

			public static void Finalizer()
			{
				sortedInventory = null;
			}
		}

		public const string GUID = "aedenthorn.SimpleSort";

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

		private static Inventory sortedInventory;
	}
	internal static class ZenBeehiveCompat
	{
		public const string GUID = "ZenDragon.ZenBeehive";

		public static Assembly assembly;

		public static bool isEnabled;

		public static ConfigEntry<bool> holdToTakeAll;

		private static Func<bool> isHoneyOpen;

		public static bool IsHoneyOpen => isEnabled && isHoneyOpen != null && (holdToTakeAll == null || holdToTakeAll.Value) && isHoneyOpen();

		public static void CheckForCompatibility()
		{
			isEnabled = Chainloader.PluginInfos.TryGetValue("ZenDragon.ZenBeehive", out var value);
			if (!isEnabled)
			{
				return;
			}
			value.Instance.Config.TryGetEntry<bool>("Beehive", "Hold To Take All", ref holdToTakeAll);
			if ((object)assembly == null)
			{
				assembly = Assembly.GetAssembly(((object)value.Instance).GetType());
			}
			Type type = assembly.GetType("ZenBeehive.BeehiveUI");
			if (!(type == null))
			{
				MethodInfo methodInfo = AccessTools.Method(type, "IsHoneyOpen", Type.EmptyTypes, (Type[])null);
				if (methodInfo != null)
				{
					isHoneyOpen = (Func<bool>)methodInfo.CreateDelegate(typeof(Func<bool>));
					ExtraSlots.LogInfo("ZenBeehive beehive take all compatibility enabled");
				}
			}
		}
	}
	public static class QuickStackStore
	{
		[HarmonyPatch]
		public static class QuickStackStore_InternalIsEquipOrQuickSlot_IgnoreExtraSlots
		{
			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!Chainloader.PluginInfos.TryGetValue("goldenrevolver.quick_stack_store", out var value))
				{
					return false;
				}
				if ((object)target == null)
				{
					target = AccessTools.Method(Assembly.GetAssembly(((object)value.Instance).GetType()).GetType("QuickStackStore.CompatibilitySupport"), "InternalIsEquipOrQuickSlot", (Type[])null, (Type[])null);
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("QuickStackStore.CompatibilitySupport:InternalIsEquipOrQuickSlot method is patched to ignore items in equipment slots and restock other slots");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			public static void Postfix(Vector2i itemPos, bool includeRestockableSlots, ref bool __result)
			{
				//IL_001c: 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)
				__result = __result || (includeRestockableSlots ? (Slots.GetSlotInGrid(itemPos) != null) : (Slots.GetSlotInGrid(itemPos)?.IsEquipmentSlot ?? false));
			}
		}

		public const string GUID = "goldenrevolver.quick_stack_store";
	}
	public static class AzuAutoStore
	{
		[HarmonyPatch]
		public static class AzuAutoStore_AzuEPI_IsLoaded_Impersonate
		{
			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!Chainloader.PluginInfos.TryGetValue("Azumatt.AzuAutoStore", out var value))
				{
					return false;
				}
				if ((object)target == null)
				{
					target = AccessTools.Method(Assembly.GetAssembly(((object)value.Instance).GetType()).GetType("AzuExtendedPlayerInventory.API"), "IsLoaded", (Type[])null, (Type[])null);
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("AzuAutoStore.AzuExtendedPlayerInventory.API:IsLoaded method is patched to return true as if AzuEPI is used");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			public static void Postfix(ref bool __result)
			{
				__result = true;
			}
		}

		[HarmonyPatch]
		public static class AzuAutoStore_AzuEPI_GetQuickSlotsItems_ReturnExtraSlots
		{
			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!Chainloader.PluginInfos.TryGetValue("Azumatt.AzuAutoStore", out var value))
				{
					return false;
				}
				if ((object)target == null)
				{
					target = AccessTools.Method(Assembly.GetAssembly(((object)value.Instance).GetType()).GetType("AzuExtendedPlayerInventory.API"), "GetQuickSlotsItems", (Type[])null, (Type[])null);
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("AzuAutoStore.AzuExtendedPlayerInventory.API:GetQuickSlotsItems method is patched to return items in extra slots");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			public static void Postfix(ref List<ItemData> __result)
			{
				__result.AddRange(API.GetAllExtraSlotsItems());
			}
		}

		public const string GUID = "Azumatt.AzuAutoStore";
	}
	public static class BetterProgressionCompat
	{
		[HarmonyPatch(typeof(FejdStartup), "Start")]
		private static class FejdStartup_Start_DisableBetterProgressionQuiver
		{
			private static void Postfix()
			{
				ClearInventoryRowList();
				DisableInventoryRows(toggleInventoryRowFeature);
			}
		}

		public const string GUID = "Revel.BetterProgression";

		public static PluginInfo betterProgressionPlugin;

		public static object toggleOff;

		public static object toggleOn;

		public static Assembly assembly;

		public static ConfigEntryBase toggleInventoryRowFeature;

		public static ConfigDefinition definitionInventoryRowFeature = new ConfigDefinition("1 - General", "Enable Inventory Row Feature");

		public static ConfigEntry<string> addInventoryRowList;

		public static void CheckForCompatibility()
		{
			if (!Chainloader.PluginInfos.TryGetValue("Revel.BetterProgression", out betterProgressionPlugin))
			{
				return;
			}
			if ((object)assembly == null)
			{
				assembly = Assembly.GetAssembly(((object)betterProgressionPlugin.Instance).GetType());
			}
			Type type = assembly.GetType("BetterProgression.BetterProgressionPlugin+Toggle");
			toggleOff = type.GetEnumValues().GetValue(0);
			toggleOn = type.GetEnumValues().GetValue(1);
			toggleInventoryRowFeature = betterProgressionPlugin.Instance.Config[definitionInventoryRowFeature];
			betterProgressionPlugin.Instance.Config.SettingChanged += delegate(object s, SettingChangedEventArgs e)
			{
				DisableInventoryRows(e.ChangedSetting);
			};
			if (betterProgressionPlugin.Instance.Config.TryGetEntry<string>("4 - Inventory", "Add Inventory Row", ref addInventoryRowList))
			{
				addInventoryRowList.SettingChanged += delegate
				{
					ClearInventoryRowList();
				};
			}
			AccessTools.Field(assembly.GetType("BetterProgression.InventoryUpdate"), "isAzuEPILoaded").SetValue(null, true);
			assembly.RemoveHarmonyPatch(typeof(InventoryGui), "Update", "BetterProgression.InventoryUpdate+InventoryGui_Update_Patch", "Postfix", "prevent inventory mess");
			assembly.RemoveHarmonyPatch(typeof(Container), "RPC_TakeAllRespons", "BetterProgression.InventoryUpdate+ContainerRPCRequestTakeAllPatch", "Postfix", "prevent inventory mess");
			assembly.RemoveHarmonyPatch(typeof(Inventory), "MoveAll", "BetterProgression.InventoryUpdate+MoveAllToPatch", "Postfix", "prevent inventory mess");
		}

		private static void ClearInventoryRowList()
		{
			if (betterProgressionPlugin != null && addInventoryRowList != null && !Utility.IsNullOrWhiteSpace(addInventoryRowList.Value))
			{
				addInventoryRowList.Value = "";
				ExtraSlots.LogWarning("BetterProgression's Add Inventory Row was cleared to prevent issues with inventory grid.");
			}
		}

		private static void DisableInventoryRows(ConfigEntryBase configEntryBase)
		{
			if (configEntryBase != null && configEntryBase == toggleInventoryRowFeature && configEntryBase.BoxedValue.Equals(toggleOn))
			{
				configEntryBase.BoxedValue = toggleOff;
				ExtraSlots.LogWarning("BetterProgression's Inventory Row Feature was disabled to prevent issues with inventory grid.");
			}
		}
	}
	public static class BetterArcheryCompat
	{
		[HarmonyPatch(typeof(FejdStartup), "Start")]
		private static class FejdStartup_Start_DisableBetterArcheryQuiver
		{
			private static void Postfix()
			{
				DisableQuiver();
			}
		}

		public const string GUID = "ishid4.mods.betterarchery";

		public static Assembly assembly;

		public static PluginInfo betterArcheryPlugin;

		public static ConfigEntry<bool> baEnableQuiver;

		public static void CheckForCompatibility()
		{
			if (!Chainloader.PluginInfos.TryGetValue("ishid4.mods.betterarchery", out betterArcheryPlugin))
			{
				return;
			}
			if (betterArcheryPlugin.Instance.Config.TryGetEntry<bool>("Quiver", "Enable Quiver", ref baEnableQuiver))
			{
				baEnableQuiver.SettingChanged += delegate
				{
					DisableQuiver();
				};
			}
			if ((object)assembly == null)
			{
				assembly = Assembly.GetAssembly(((object)betterArcheryPlugin.Instance).GetType());
			}
			assembly.RemoveHarmonyPatch(typeof(TombStone), "OnTakeAllSuccess", "BetterArchery.Tombstone+TombStone_OnTakeAllSuccess_Patch", "Postfix", "prevent inventory mess");
		}

		private static void DisableQuiver()
		{
			if (betterArcheryPlugin != null && baEnableQuiver != null && baEnableQuiver.Value)
			{
				baEnableQuiver.Value = false;
				ExtraSlots.LogWarning("BetterArchery's Quiver was disabled to prevent issues with inventory grid. You will not lose arrows if you had Quiver enabled in your previous session." + $"\nThis logic is designed for BetterArchery version 1.9.8, current version is {betterArcheryPlugin.Metadata.Version}. If quiver implementation was changed pls contact me at any platform.");
			}
		}
	}
	internal class EquipmentAndQuickSlotsCompat
	{
		[HarmonyPatch(typeof(Player), "Load")]
		public static class Player_Load_TryLoadEaQSData
		{
			[HarmonyPriority(300)]
			public static void Postfix(Player __instance)
			{
				if (__instance.m_customData.ContainsKey("EquipmentSlotInventory") && (Object.op_Implicit((Object)(object)FejdStartup.instance) || Slots.IsValidPlayer((Character)(object)__instance)))
				{
					playerToLoad = __instance;
					Load();
					playerToLoad = null;
				}
			}
		}

		public const int QuickSlotCount = 3;

		public const int EquipSlotCount = 5;

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

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

		internal static Player playerToLoad;

		public const string Sentinel = "<|>";

		public static void Load()
		{
			if (!((Object)(object)playerToLoad == (Object)null))
			{
				LoadInventory(EquipmentSlotInventory, equipItem: true, (Object)(object)Player.m_localPlayer == (Object)null);
				LoadInventory(QuickSlotInventory, equipItem: false, (Object)(object)Player.m_localPlayer == (Object)null);
			}
		}

		private static void LoadInventory(Inventory inventory, bool equipItem, bool loadOnly)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			if (LoadValue(playerToLoad, inventory.m_name, out var value))
			{
				ZPackage val = new ZPackage(value);
				inventory.Load(val);
				TransferItemsToPlayerInventory(inventory, equipItem);
				if (!loadOnly)
				{
					val = new ZPackage();
					inventory.Save(val);
					SaveValue(playerToLoad, inventory.m_name, val.GetBase64());
				}
			}
		}

		private static void TransferItemsToPlayerInventory(Inventory fromInventory, bool equipItem)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			foreach (ItemData item in from item in fromInventory.GetAllItemsInGridOrder()
				where item != null
				select item)
			{
				if (!(TryFindSlotForItem(item, out var slot) ? Slots.PlayerInventory.AddItem(item, slot.GridPosition) : Slots.PlayerInventory.AddItem(item)))
				{
					if (Slots.TryMakeFreeSpaceInPlayerInventory(tryFindRegularInventorySlot: true, out var gridPos))
					{
						ExtraSlots.LogInfo($"Item {item.m_shared.m_name} from EaQS was put to created free space {gridPos}");
						item.m_gridPos = gridPos;
					}
					else
					{
						ExtraSlots.LogWarning("Item " + item.m_shared.m_name + " was temporary put out of grid. It will return to inventory first free slot.");
						item.m_gridPos = new Vector2i(0, Slots.InventoryHeightFull);
					}
					Slots.PlayerInventory.m_inventory.Add(item);
				}
				ExtraSlots.LogMessage("Item " + item.m_shared.m_name + " was loaded from EquipmentAndQuickSlots " + fromInventory.m_name);
				if (equipItem)
				{
					((Humanoid)playerToLoad).UseItem(((Humanoid)playerToLoad).GetInventory(), item, false);
				}
			}
			fromInventory.m_inventory.Clear();
		}

		private static bool TryFindSlotForItem(ItemData item, out Slots.Slot slot)
		{
			return Slots.TryFindFreeEquipmentSlotForItem(item, out slot) || Slots.TryFindFreeSlotForItem(item, out slot);
		}

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

		private static void SaveValue(Player player, string key, string value)
		{
			if (player.m_knownTexts.ContainsKey(key))
			{
				ExtraSlots.LogWarning("Found KnownText for save data, converting to customData");
				player.m_knownTexts.Remove(key);
			}
			if (player.m_customData.ContainsKey(key))
			{
				player.m_customData[key] = value;
			}
			else
			{
				player.m_customData.Add(key, value);
			}
		}
	}
	internal static class PlantEasilyCompat
	{
		public const string GUID = "advize.PlantEasily";

		public static Assembly assembly;

		public static bool isEnabled;

		private static Func<bool> _overrideGamepadInput;

		public static bool DisableGamepadInput => _overrideGamepadInput != null && _overrideGamepadInput();

		public static void CheckForCompatibility()
		{
			isEnabled = Chainloader.PluginInfos.TryGetValue("advize.PlantEasily", out var value);
			if (!isEnabled)
			{
				return;
			}
			if ((object)assembly == null)
			{
				assembly = Assembly.GetAssembly(((object)value.Instance).GetType());
			}
			Type type = assembly.GetType("Advize_PlantEasily.InputPatches");
			if (!(type == null))
			{
				PropertyInfo propertyInfo = AccessTools.Property(type, "OverrideGamepadInput");
				if (propertyInfo != null)
				{
					_overrideGamepadInput = (Func<bool>)Delegate.CreateDelegate(typeof(Func<bool>), propertyInfo.GetGetMethod(nonPublic: true));
					ExtraSlots.LogInfo("PlantEasily gamepad compatibility enabled");
				}
				MethodInfo methodInfo = AccessTools.Method(typeof(HotkeyBar), "Update", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					ExtraSlots.instance.harmony.Unpatch((MethodBase)methodInfo, (HarmonyPatchType)1, "advize.PlantEasily");
					ExtraSlots.LogInfo("Advize_PlantEasily.InputPatches:Prefix for HotkeyBar.Update was unpatched to prevent double selection.");
				}
			}
		}
	}
	public static class EpicLootCompat
	{
		[HarmonyPatch]
		public static class EpicLoot_Player_GetEquipment_AddItemsFromExtraUtilityAndCustomSlots
		{
			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!isEnabled)
				{
					return false;
				}
				if ((object)target == null)
				{
					target = AccessTools.Method(assembly.GetType("EpicLoot.PlayerExtensions"), "GetEquipment", (Type[])null, (Type[])null);
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("EpicLoot.PlayerExtensions:GetEquipment method is patched to add extra utility and custom slot items");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			[HarmonyPriority(0)]
			public static void Postfix(Player player, List<ItemData> __result)
			{
				if (Slots.IsValidPlayer((Character)(object)player))
				{
					CollectionExtensions.DoIf<ItemData>(ExtraUtilitySlots.GetEquippedItems().Union(from slot in Slots.GetEquipmentSlots()
						where slot.IsCustomSlot && !slot.IsFree && ((Humanoid)player).IsItemEquiped(slot.Item)
						select slot.Item), (Func<ItemData, bool>)((ItemData item) => !__result.Contains(item)), (Action<ItemData>)__result.Add);
				}
			}
		}

		[HarmonyPatch]
		public static class EpicLoot_EnchantCostsHelper_GetSacrificeProducts_ExcludeItemsFromSacrifice
		{
			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!isEnabled)
				{
					return false;
				}
				if ((object)target == null)
				{
					target = AccessTools.Method(assembly.GetType("EpicLoot.Crafting.EnchantCostsHelper"), "GetSacrificeProducts", new Type[1] { typeof(ItemData) }, (Type[])null);
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("EpicLoot.Crafting.EnchantCostsHelper:GetSacrificeProducts method is patched to optionally exclude quick and misc slots");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			[HarmonyPriority(0)]
			public static bool Prefix(ItemData item)
			{
				if (ShowEquippedAndHotbarItemsInSacrificeTab != null && ShowEquippedAndHotbarItemsInSacrificeTab.Value)
				{
					return true;
				}
				Slots.Slot itemSlot = Slots.GetItemSlot(item);
				if (itemSlot == null)
				{
					return true;
				}
				return !itemSlot.IsQuickSlot && (!itemSlot.IsMiscSlot || !ExtraSlots.epicLootExcludeMiscItemsFromSacrifice.Value);
			}
		}

		public const string GUID = "randyknapp.mods.epicloot";

		public static PluginInfo epicLootPlugin;

		public static Assembly assembly;

		public static bool isEnabled;

		public static ConfigEntry<bool> ShowEquippedAndHotbarItemsInSacrificeTab;

		public static void CheckForCompatibility()
		{
			if (isEnabled = Chainloader.PluginInfos.TryGetValue("randyknapp.mods.epicloot", out epicLootPlugin))
			{
				if ((object)assembly == null)
				{
					assembly = Assembly.GetAssembly(((object)epicLootPlugin.Instance).GetType());
				}
				epicLootPlugin.Instance.Config.TryGetEntry<bool>("Crafting UI", "ShowEquippedAndHotbarItemsInSacrificeTab", ref ShowEquippedAndHotbarItemsInSacrificeTab);
			}
		}
	}
	internal static class ValheimPlusCompat
	{
		[HarmonyPatch]
		public static class ValheimPlus_ValheimPlusPlugin_PatchAll_Unpatch
		{
			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.valheim_plus", out var value))
				{
					return false;
				}
				if ((object)assembly == null)
				{
					assembly = Assembly.GetAssembly(((object)value.Instance).GetType());
				}
				if ((object)target == null)
				{
					target = AccessTools.Method(assembly.GetType("ValheimPlus.ValheimPlusPlugin"), "PatchAll", (Type[])null, (Type[])null);
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("ValheimPlus.ValheimPlusPlugin:PatchAll method is patched to unpatch inventory related patches");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			public static void Finalizer()
			{
				CheckForCompatibility();
			}
		}

		[HarmonyPatch]
		public static class ValheimPlus_ValheimPlusPlugin_InventoryHeightOverride
		{
			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.valheim_plus", out var value))
				{
					return false;
				}
				if ((object)assembly == null)
				{
					assembly = Assembly.GetAssembly(((object)value.Instance).GetType());
				}
				if ((object)target == null)
				{
					target = AccessTools.PropertyGetter(assembly.GetType("ValheimPlus.Configurations.Sections.InventoryConfiguration"), "playerInventoryRows");
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("ValheimPlus.Configurations.Sections.InventoryConfiguration:playerInventoryRows property getter is patched to return current rows");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			public static void Finalizer(ref int __result)
			{
				__result = Slots.InventoryHeightFull;
			}
		}

		[HarmonyPatch]
		public static class ValheimPlus_Configuration_LoadFromIni_Stream_InventoryHeightOverride
		{
			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.valheim_plus", out var _))
				{
					return false;
				}
				if ((object)target == null)
				{
					target = AccessTools.Method(assembly.GetType("ValheimPlus.Configurations.ConfigurationExtra"), "LoadFromIni", new Type[1] { typeof(Stream) }, (Type[])null);
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("ValheimPlus.Configurations.ConfigurationExtra:LoadFromIni (Stream) method is patched to override current inventory rows");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			public static void Finalizer(object __result)
			{
				OverridePlayerInventoryRows(__result);
			}
		}

		[HarmonyPatch]
		public static class ValheimPlus_Configuration_LoadFromIni_File_InventoryHeightOverride
		{
			public static MethodBase target;

			public static bool Prepare(MethodBase original)
			{
				if (!Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.valheim_plus", out var _))
				{
					return false;
				}
				if ((object)target == null)
				{
					target = AccessTools.Method(assembly.GetType("ValheimPlus.Configurations.ConfigurationExtra"), "LoadFromIni", new Type[2]
					{
						typeof(string),
						typeof(bool)
					}, (Type[])null);
				}
				if (target == null)
				{
					return false;
				}
				if (original == null)
				{
					ExtraSlots.LogInfo("ValheimPlus.Configurations.ConfigurationExtra:LoadFromIni (File) method is patched to override current inventory rows");
				}
				return true;
			}

			public static MethodBase TargetMethod()
			{
				return target;
			}

			public static void Finalizer(object __result)
			{
				OverridePlayerInventoryRows(__result);
			}
		}

		public const string GUID = "org.bepinex.plugins.valheim_plus";

		public static Assembly assembly;

		internal static void CheckForCompatibility()
		{
			if (Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.valheim_plus", out var value))
			{
				if ((object)assembly == null)
				{
					assembly = Assembly.GetAssembly(((object)value.Instance).GetType());
				}
				assembly.RemoveHarmonyPatch(typeof(InventoryGui), "Show", "ValheimPlus.GameClasses.InventoryGui_Show_Patch", "Postfix", "prevent inventory GUI mess");
				assembly.RemoveHarmonyPatch(typeof(InventoryGrid), "UpdateGui", "ValheimPlus.GameClasses.InventoryGrid_UpdateGui_Patch", "Prefix", "prevent inventory GUI mess");
				assembly.RemoveHarmonyPatch(AccessTools.Constructor(typeof(Inventory), (Type[])null, false), "ValheimPlus.GameClasses.Inventory_Constructor_Patch", "Prefix", "prevent inventory GUI mess");
			}
		}

		internal static void OverridePlayerInventoryRows(object configuration)
		{
			PropertyInfo property = configuration.GetType().GetProperty("Inventory", BindingFlags.Instance | BindingFlags.Public);
			if (property == null)
			{
				ExtraSlots.LogInfo("Property Inventory is not found in V+ Configuration");
				return;
			}
			object value = property.GetValue(configuration);
			if (value == null)
			{
				ExtraSlots.LogInfo("Property Inventory is not set in V+ Configuration");
				return;
			}
			PropertyInfo property2 = value.GetType().GetProperty("playerInventoryRows", BindingFlags.Instance | BindingFlags.Public);
			if (property2 == null)
			{
				ExtraSlots.LogInfo("Property Inventory.playerInventoryRows is not found in V+ Configuration");
				return;
			}
			int inventoryHeightFull = Slots.InventoryHeightFull;
			if (!property2.CanWrite)
			{
				MethodInfo setMethod = property2.GetSetMethod(nonPublic: true);
				if (setMethod == null)
				{
					ExtraSlots.LogInfo("Set method for Inventory.playerInventoryRows is not found in V+ Configuration");
					return;
				}
				setMethod.Invoke(value, new object[1] { inventoryHeightFull });
			}
			else
			{
				property2.SetValue(value, inventoryHeightFull);
			}
			ExtraSlots.LogInfo($"ValheimPlus Configuration.Current.Inventory.playerInventoryRows set to {inventoryHeightFull}");
		}

		internal static void UpdatePlayerInventoryRows()
		{
			if (assembly == null)
			{
				return;
			}
			Type type = assembly.GetType("ValheimPlus.Configurations.Configuration");
			if (!(type == null))
			{
				PropertyInfo propertyInfo = AccessTools.Property(type, "Current");
				if (propertyInfo != null)
				{
					OverridePlayerInventoryRows(propertyInfo.GetValue(propertyInfo));
				}
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace 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 Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new Version(CurrentVersion) >= new 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;
			}
		}
	}
}