using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Peak;
using Peak.Network;
using Photon.Pun;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyTitle("PEAK Luggage Items")]
[assembly: AssemblyDescription("Live luggage loot editor for PEAK")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PEAK Luggage Items")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("2ee823ee-81d0-43ba-91f7-a88355d316cf")]
[assembly: AssemblyFileVersion("3.0.0.0")]
[assembly: AssemblyInformationalVersion("3.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("3.0.0.0")]
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace PEAKLuggageItems
{
	[BepInPlugin("tony4twentys.PEAK_Luggage_Items", "PEAK Luggage Items", "3.0.0")]
	[BepInProcess("PEAK.exe")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "tony4twentys.PEAK_Luggage_Items";

		public const string PluginName = "PEAK Luggage Items";

		public const string PluginVersion = "3.0.0";

		public static Plugin Instance;

		public ConfigEntry<bool> DebugLogs;

		public ConfigEntry<bool> ShowPauseMenuButton;

		public ConfigEntry<KeyCode> MenuKey;

		public ConfigEntry<KeyCode> MenuModifier;

		private Harmony _harmony;

		private Coroutine _catalogCoroutine;

		public ManualLogSource Logger => ((BaseUnityPlugin)this).Logger;

		public static bool IsDebug => (Object)(object)Instance != (Object)null && Instance.DebugLogs != null && Instance.DebugLogs.Value;

		private void Awake()
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			Instance = this;
			DebugLogs = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "DebugLogs", false, "Verbose loot apply logging. Leave off unless you are diagnosing a problem.");
			ShowPauseMenuButton = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowPauseMenuButton", true, "Show the Luggage Items button on the pause menu. The hotkey still works if this is off.");
			MenuKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "MenuKey", (KeyCode)108, "Open the in-game luggage loot menu (used with MenuModifier). Also available from the pause menu.");
			MenuModifier = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "MenuModifier", (KeyCode)306, "Optional modifier for the loot menu. Default LeftControl (Ctrl+L). Set to None to use MenuKey alone. LeftControl also accepts RightControl.");
			LuggageCatalog.Refresh();
			LootStore.Initialize();
			PresetStore.Initialize();
			PresetStore.TryLoadDefault();
			LuggageMenu.EnsureCreated();
			DebugDump.Initialize();
			_harmony = new Harmony("tony4twentys.PEAK_Luggage_Items");
			_harmony.PatchAll(typeof(Plugin).Assembly);
			SceneManager.sceneLoaded += OnSceneLoaded;
			_catalogCoroutine = ((MonoBehaviour)this).StartCoroutine(WaitForItemCatalog());
			Logger.LogInfo((object)string.Format("{0} v{1} loaded ({2} live luggage pools). Open with Ctrl+L or the pause menu. Old Item Weights / Item Spawn Pools config keys are unused now — loot is edited in the menu.", "PEAK Luggage Items", "3.0.0", LuggageCatalog.Count));
		}

		private void Update()
		{
			if (IsMenuHotkeyDown())
			{
				LuggageMenu.Toggle();
			}
		}

		internal bool IsMenuHotkeyDown()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Invalid comparison between Unknown and I4
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Invalid comparison between Unknown and I4
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Invalid comparison between Unknown and I4
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Invalid comparison between Unknown and I4
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			if (LuggageMenu.IsListeningForHotkey)
			{
				return false;
			}
			KeyCode val = (KeyCode)((MenuKey == null) ? 108 : ((int)MenuKey.Value));
			if ((int)val == 0)
			{
				return false;
			}
			KeyCode val2 = (KeyCode)((MenuModifier == null) ? 306 : ((int)MenuModifier.Value));
			if ((int)val2 == 0)
			{
				return Input.GetKeyDown(val);
			}
			bool flag = Input.GetKey(val2);
			if ((int)val2 == 306 || (int)val2 == 305)
			{
				flag = Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
			}
			else if ((int)val2 == 308 || (int)val2 == 307)
			{
				flag = Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307);
			}
			else if ((int)val2 == 304 || (int)val2 == 303)
			{
				flag = Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
			}
			return flag && Input.GetKeyDown(val);
		}

		private void OnApplicationQuit()
		{
			try
			{
				PresetStore.SaveDefault();
			}
			catch
			{
			}
		}

		private void OnDestroy()
		{
			try
			{
				PresetStore.SaveDefault();
			}
			catch
			{
			}
			try
			{
				SceneManager.sceneLoaded -= OnSceneLoaded;
			}
			catch
			{
			}
			try
			{
				DebugDump.Shutdown();
			}
			catch
			{
			}
			try
			{
				LuggageMenu.DestroyInstance();
			}
			catch
			{
			}
			try
			{
				Harmony harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch
			{
			}
			if (_catalogCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_catalogCoroutine);
			}
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		private IEnumerator WaitForItemCatalog()
		{
			if (ItemCatalog.TryRefresh())
			{
				OnCatalogReady();
				yield break;
			}
			float elapsed = 0f;
			while (!ItemCatalog.TryRefresh())
			{
				elapsed += 0.25f;
				if (elapsed > 120f)
				{
					Logger.LogWarning((object)"Item database never loaded. The loot picker cannot list items.");
					yield break;
				}
				yield return (object)new WaitForSeconds(0.25f);
			}
			OnCatalogReady();
		}

		private void OnCatalogReady()
		{
			LuggageMenu.OnCatalogReady();
			Logger.LogInfo((object)($"Loaded {ItemCatalog.Count} live items for the luggage loot menu." + (LootStore.HasVanillaSnapshot ? " Saved luggage defaults are ready." : " Vanilla defaults load in the Airport or after the first climb, then persist.")));
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			if ((int)mode != 1)
			{
				LuggageMenu.OnAfterSceneLoad();
				LuggageSpawnPatches.ClearOpenState();
				if (IsAirportOrLevel(((Scene)(ref scene)).name))
				{
					LootStore.TryEnsureDefaults();
				}
				int count = ItemCatalog.Count;
				try
				{
					ItemCatalog.TryRefresh();
				}
				catch
				{
				}
				if (ItemCatalog.Count > count)
				{
					Logger.LogInfo((object)("Found " + (ItemCatalog.Count - count) + " more item(s) after scene load (" + ItemCatalog.Count + " total)."));
				}
				LuggageMenu.OnCatalogReady();
			}
		}

		private static bool IsAirportOrLevel(string sceneName)
		{
			if (string.IsNullOrEmpty(sceneName))
			{
				return false;
			}
			return sceneName.Equals("Airport", StringComparison.OrdinalIgnoreCase) || sceneName.IndexOf("Level_", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		public static void SetDebug(bool enabled)
		{
			if (!((Object)(object)Instance == (Object)null) && Instance.DebugLogs != null)
			{
				Instance.DebugLogs.Value = enabled;
				((BaseUnityPlugin)Instance).Config.Save();
				LogInfo("[PLI] Debug logs " + (enabled ? "ON — open a luggage, then read BepInEx/LogOutput.log" : "OFF"));
				if (enabled)
				{
					DebugDump.DumpEverything("debug enabled");
				}
			}
		}

		public static KeyCode GetMenuKey()
		{
			//IL_002d: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			return (KeyCode)((!((Object)(object)Instance != (Object)null) || Instance.MenuKey == null) ? 108 : ((int)Instance.MenuKey.Value));
		}

		public static KeyCode GetMenuModifier()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			return (KeyCode)((!((Object)(object)Instance != (Object)null) || Instance.MenuModifier == null) ? 306 : ((int)Instance.MenuModifier.Value));
		}

		public static bool GetShowPauseMenuButton()
		{
			return (Object)(object)Instance == (Object)null || Instance.ShowPauseMenuButton == null || Instance.ShowPauseMenuButton.Value;
		}

		public static void SetShowPauseMenuButton(bool enabled)
		{
			if (!((Object)(object)Instance == (Object)null) && Instance.ShowPauseMenuButton != null)
			{
				Instance.ShowPauseMenuButton.Value = enabled;
				((BaseUnityPlugin)Instance).Config.Save();
				LogInfo("[PLI] Pause menu button " + (enabled ? "ON" : "OFF"));
			}
		}

		public static void SetMenuKey(KeyCode key)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Instance == (Object)null) && Instance.MenuKey != null && (int)key != 0)
			{
				Instance.MenuKey.Value = key;
				((BaseUnityPlugin)Instance).Config.Save();
				LogInfo("[PLI] Menu key set to " + FormatHotkey());
			}
		}

		public static void SetMenuModifier(KeyCode key)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Instance == (Object)null) && Instance.MenuModifier != null)
			{
				Instance.MenuModifier.Value = key;
				((BaseUnityPlugin)Instance).Config.Save();
				LogInfo("[PLI] Menu key set to " + FormatHotkey());
			}
		}

		public static string FormatHotkey()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			KeyCode menuKey = GetMenuKey();
			KeyCode menuModifier = GetMenuModifier();
			if ((int)menuModifier == 0)
			{
				return PrettyKey(menuKey);
			}
			return PrettyKey(menuModifier) + " + " + PrettyKey(menuKey);
		}

		public unsafe static string PrettyKey(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected I4, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected I4, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			KeyCode val = key;
			KeyCode val2 = val;
			if ((int)val2 <= 27)
			{
				if ((int)val2 <= 8)
				{
					if ((int)val2 == 0)
					{
						return "None";
					}
					if ((int)val2 == 8)
					{
						return "Backspace";
					}
				}
				else
				{
					if ((int)val2 == 13)
					{
						return "Enter";
					}
					if ((int)val2 == 27)
					{
						return "Esc";
					}
				}
			}
			else if ((int)val2 <= 127)
			{
				if ((int)val2 == 32)
				{
					return "Space";
				}
				if ((int)val2 == 127)
				{
					return "Delete";
				}
			}
			else
			{
				switch (val2 - 277)
				{
				case 0:
					return "Insert";
				case 1:
					return "Home";
				case 2:
					return "End";
				case 3:
					return "Page Up";
				case 4:
					return "Page Down";
				}
				switch (val2 - 303)
				{
				case 3:
					return "Left Ctrl";
				case 2:
					return "Right Ctrl";
				case 5:
					return "Left Alt";
				case 4:
					return "Right Alt";
				case 1:
					return "Left Shift";
				case 0:
					return "Right Shift";
				case 7:
					return "Left Cmd";
				case 6:
					return "Right Cmd";
				}
			}
			string text = ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString();
			if (text.StartsWith("Alpha", StringComparison.Ordinal) && text.Length == 6)
			{
				return text.Substring(5);
			}
			if (text.StartsWith("Keypad", StringComparison.Ordinal))
			{
				return "Num " + text.Substring("Keypad".Length);
			}
			return text;
		}

		public static void LogTrace(string message)
		{
			if (IsDebug)
			{
				LogInfo("[PLI] " + message);
			}
		}

		public static void LogInfo(string message)
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Instance.Logger.LogInfo((object)message);
			}
			else
			{
				Debug.Log((object)("[PEAK Luggage Items] " + message));
			}
		}

		public static void LogDebug(string message)
		{
			if ((Object)(object)Instance != (Object)null && Instance.DebugLogs != null && Instance.DebugLogs.Value)
			{
				Instance.Logger.LogInfo((object)message);
			}
		}

		public static void LogError(string message)
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Instance.Logger.LogError((object)message);
			}
			else
			{
				Debug.LogError((object)("[PEAK Luggage Items] " + message));
			}
		}
	}
	internal static class GameAccess
	{
		private static readonly PropertyInfo WindowBlockingProp = AccessTools.Property(typeof(GUIManager), "windowBlockingInput");

		private static readonly PropertyInfo WindowCursorProp = AccessTools.Property(typeof(GUIManager), "windowShowingCursor");

		private static readonly FieldInfo LootCacheCopy = AccessTools.Field(typeof(LootData), "cachedSpawnPoolCopy");

		private static readonly FieldInfo LootCacheWorking = AccessTools.Field(typeof(LootData), "cachedSpawnPoolWorking");

		private static readonly FieldInfo LootCacheInvalid = AccessTools.Field(typeof(LootData), "cachedInvalidSpawns");

		private static readonly FieldInfo TrackerHistory = AccessTools.Field(typeof(SpawnedItemTracker), "_historyFromSave");

		private static readonly FieldInfo TrackerSpawned = AccessTools.Field(typeof(SpawnedItemTracker), "_spawnedItems");

		private static readonly FieldInfo SpawnerPool = AccessTools.Field(typeof(Spawner), "spawnPool");

		private static readonly FieldInfo SpawnerSpots = AccessTools.Field(typeof(Spawner), "spawnSpots");

		private static readonly FieldInfo SpawnerWeighted = AccessTools.Field(typeof(Spawner), "weightedSpawnSpots");

		private static readonly FieldInfo LuggageState = AccessTools.Field(typeof(Luggage), "state");

		private static readonly MethodInfo GetSpawnPoolMethod = AccessTools.Method(typeof(Spawner), "GetSpawnPool", (Type[])null, (Type[])null);

		private static readonly MethodInfo GetObjectsToSpawnMethod = AccessTools.Method(typeof(Spawner), "GetObjectsToSpawn", new Type[2]
		{
			typeof(int),
			typeof(bool)
		}, (Type[])null);

		private static readonly MethodInfo OffsetSpawnMethod = AccessTools.Method(typeof(Spawner), "OffsetSpawn", new Type[1] { typeof(Item) }, (Type[])null);

		private static readonly MethodInfo InitializePhysicsMethod = AccessTools.Method(typeof(Spawner), "InitializePhysics", new Type[1] { typeof(Item) }, (Type[])null);

		public static Button GetPauseMenuButton(PauseMenuMainPage page, string fieldName)
		{
			if ((Object)(object)page == (Object)null)
			{
				return null;
			}
			object? obj = AccessTools.Field(typeof(PauseMenuMainPage), fieldName)?.GetValue(page);
			return (Button)((obj is Button) ? obj : null);
		}

		public static void SetMenuWindowFlags(GUIManager gui, bool blocking, bool showingCursor)
		{
			if (!((Object)(object)gui == (Object)null))
			{
				WindowBlockingProp?.SetValue(gui, blocking, null);
				WindowCursorProp?.SetValue(gui, showingCursor, null);
			}
		}

		public static void ClearLootCaches()
		{
			ClearFieldCollection(LootCacheCopy);
			ClearFieldCollection(LootCacheWorking);
			ClearFieldCollection(LootCacheInvalid);
		}

		public static int GetHistoryCount(SpawnedItemTracker tracker)
		{
			return CountFieldCollection(TrackerHistory, tracker);
		}

		public static int GetTrackedSpawnCount(SpawnedItemTracker tracker)
		{
			return CountFieldCollection(TrackerSpawned, tracker);
		}

		public static SpawnPool GetSpawnerPool(Spawner spawner)
		{
			//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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)spawner == (Object)null || SpawnerPool == null)
			{
				return (SpawnPool)0;
			}
			try
			{
				if (SpawnerPool.GetValue(spawner) is SpawnPool result)
				{
					return result;
				}
			}
			catch
			{
			}
			return (SpawnPool)0;
		}

		public static SpawnPool InvokeGetSpawnPool(Spawner spawner)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)spawner == (Object)null || GetSpawnPoolMethod == null)
			{
				return (SpawnPool)0;
			}
			try
			{
				if (GetSpawnPoolMethod.Invoke(spawner, null) is SpawnPool result)
				{
					return result;
				}
			}
			catch (Exception ex)
			{
				Plugin.LogTrace("InvokeGetSpawnPool: " + (ex.InnerException ?? ex).Message);
			}
			return (SpawnPool)0;
		}

		public static List<GameObject> InvokeGetObjectsToSpawn(Spawner spawner, int count, bool canRepeat)
		{
			if ((Object)(object)spawner == (Object)null || GetObjectsToSpawnMethod == null)
			{
				return null;
			}
			try
			{
				return GetObjectsToSpawnMethod.Invoke(spawner, new object[2] { count, canRepeat }) as List<GameObject>;
			}
			catch (Exception ex)
			{
				Plugin.LogTrace("InvokeGetObjectsToSpawn: " + (ex.InnerException ?? ex).Message);
				return null;
			}
		}

		public static void InvokeOffsetSpawn(Spawner spawner, Item item)
		{
			if ((Object)(object)spawner == (Object)null || (Object)(object)item == (Object)null || OffsetSpawnMethod == null)
			{
				return;
			}
			try
			{
				OffsetSpawnMethod.Invoke(spawner, new object[1] { item });
			}
			catch
			{
			}
		}

		public static void InvokeInitializePhysics(Spawner spawner, Item item)
		{
			if ((Object)(object)spawner == (Object)null || (Object)(object)item == (Object)null || InitializePhysicsMethod == null)
			{
				return;
			}
			try
			{
				InitializePhysicsMethod.Invoke(spawner, new object[1] { item });
			}
			catch
			{
			}
		}

		public static List<Transform> GetSpawnSpotList(Spawner spawner)
		{
			return GetFieldValue<List<Transform>>(SpawnerSpots, spawner);
		}

		public static IList GetWeightedSpotLists(Spawner spawner)
		{
			return GetFieldValue<IList>(SpawnerWeighted, spawner);
		}

		public static List<Transform> GetEntrySpawnSpots(object entry)
		{
			if (entry == null)
			{
				return null;
			}
			try
			{
				return AccessTools.Field(entry.GetType(), "spawnSpots")?.GetValue(entry) as List<Transform>;
			}
			catch
			{
				return null;
			}
		}

		public static string GetLuggageState(Luggage luggage)
		{
			if ((Object)(object)luggage == (Object)null || LuggageState == null)
			{
				return "?";
			}
			try
			{
				object value = LuggageState.GetValue(luggage);
				return (value != null) ? value.ToString() : "?";
			}
			catch
			{
				return "?";
			}
		}

		private static T GetFieldValue<T>(FieldInfo field, object instance) where T : class
		{
			if (field == null || instance == null)
			{
				return null;
			}
			try
			{
				return field.GetValue(instance) as T;
			}
			catch
			{
				return null;
			}
		}

		private static void ClearFieldCollection(FieldInfo field)
		{
			if (field == null)
			{
				return;
			}
			try
			{
				object value = field.GetValue(null);
				if (value is IDictionary dictionary)
				{
					dictionary.Clear();
				}
				else if (value is IList list)
				{
					list.Clear();
				}
			}
			catch
			{
			}
		}

		private static int CountFieldCollection(FieldInfo field, object instance)
		{
			if (field == null || instance == null)
			{
				return 0;
			}
			try
			{
				object value = field.GetValue(instance);
				if (value is ICollection { Count: var count })
				{
					return count;
				}
			}
			catch
			{
			}
			return 0;
		}
	}
	internal sealed class CatalogItem
	{
		public ushort Id;

		public string DisplayName;

		public string DropdownName;

		public string PrefabName;

		public Item Prefab;
	}
	internal static class ItemCatalog
	{
		public const string EmptyLabel = "(empty)";

		private static readonly List<CatalogItem> _items = new List<CatalogItem>();

		private static readonly Dictionary<ushort, CatalogItem> _byId = new Dictionary<ushort, CatalogItem>();

		private static readonly Dictionary<string, CatalogItem> _byName = new Dictionary<string, CatalogItem>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, CatalogItem> _byFold = new Dictionary<string, CatalogItem>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<int> _seenInstances = new HashSet<int>();

		private static string[] _dropdownNames = new string[1] { "(empty)" };

		public static bool IsReady { get; private set; }

		public static int Count => _items.Count;

		public static IReadOnlyList<CatalogItem> Items => _items;

		public static string[] DropdownNames => _dropdownNames;

		public static bool TryRefresh()
		{
			ItemDatabase val = null;
			try
			{
				val = SingletonAsset<ItemDatabase>.Instance;
			}
			catch
			{
				return false;
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			List<Item> list = new List<Item>();
			HashSet<int> seen = new HashSet<int>();
			if (val.itemLookup != null)
			{
				foreach (KeyValuePair<ushort, Item> item in val.itemLookup)
				{
					ConsiderItem(list, seen, item.Value);
				}
			}
			if (((DatabaseAsset<ItemDatabase, Item>)(object)val).Objects != null)
			{
				for (int i = 0; i < ((DatabaseAsset<ItemDatabase, Item>)(object)val).Objects.Count; i++)
				{
					ConsiderItem(list, seen, ((DatabaseAsset<ItemDatabase, Item>)(object)val).Objects[i]);
				}
			}
			if (list.Count == 0)
			{
				return IsReady;
			}
			if (!IsReady)
			{
				_items.Clear();
				_byId.Clear();
				_byName.Clear();
				_byFold.Clear();
				_seenInstances.Clear();
			}
			int num = 0;
			for (int j = 0; j < list.Count; j++)
			{
				Item val2 = list[j];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				int instanceID = ((Object)val2).GetInstanceID();
				if (_seenInstances.Add(instanceID))
				{
					CatalogItem catalogItem = new CatalogItem
					{
						Id = val2.itemID,
						Prefab = val2,
						PrefabName = SafePrefabName(val2),
						DisplayName = SafeDisplayName(val2)
					};
					_items.Add(catalogItem);
					if (!_byId.ContainsKey(catalogItem.Id))
					{
						_byId[catalogItem.Id] = catalogItem;
					}
					num++;
				}
			}
			if (num > 0)
			{
				BuildDropdownNames();
			}
			IsReady = _items.Count > 0;
			return IsReady;
		}

		public static bool TryGet(ushort id, out CatalogItem item)
		{
			return _byId.TryGetValue(id, out item);
		}

		public static string GetName(ushort id)
		{
			if (_byId.TryGetValue(id, out var value) && value != null)
			{
				return value.DisplayName;
			}
			Item val = default(Item);
			if (ItemDatabase.TryGetItem(id, ref val) && (Object)(object)val != (Object)null)
			{
				return SafeDisplayName(val);
			}
			return "Unknown item " + id;
		}

		public static bool TryResolveCatalog(string value, out CatalogItem item)
		{
			item = null;
			if (string.IsNullOrEmpty(value) || string.Equals(value.Trim(), "(empty)", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			string text = value.Trim();
			if (_byName.TryGetValue(text, out item) && (Object)(object)item?.Prefab != (Object)null)
			{
				return true;
			}
			string text2 = FoldName(text);
			if (text2.Length > 0 && _byFold.TryGetValue(text2, out item) && (Object)(object)item?.Prefab != (Object)null)
			{
				return true;
			}
			if (ushort.TryParse(text, out var result) && _byId.TryGetValue(result, out item))
			{
				return (Object)(object)item?.Prefab != (Object)null;
			}
			Item val = default(Item);
			if (ItemDatabase.TryGetItem(text, ref val) && (Object)(object)val != (Object)null)
			{
				item = WrapTransient(val);
				return (Object)(object)item?.Prefab != (Object)null;
			}
			return false;
		}

		private static void ConsiderItem(List<Item> found, HashSet<int> seen, Item item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				int instanceID = ((Object)item).GetInstanceID();
				if (seen.Add(instanceID))
				{
					found.Add(item);
				}
			}
		}

		private static void BuildDropdownNames()
		{
			_byName.Clear();
			_byFold.Clear();
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			for (int i = 0; i < _items.Count; i++)
			{
				string key = DropdownBaseName(_items[i]);
				if (!dictionary.ContainsKey(key))
				{
					dictionary[key] = 0;
				}
				dictionary[key]++;
			}
			List<string> list = new List<string>(_items.Count);
			foreach (CatalogItem item in _items.OrderBy<CatalogItem, string>((CatalogItem catalogItem) => catalogItem.DisplayName, StringComparer.OrdinalIgnoreCase).ThenBy<CatalogItem, string>((CatalogItem catalogItem) => catalogItem.PrefabName, StringComparer.OrdinalIgnoreCase))
			{
				string text = DropdownBaseName(item);
				string text2 = (item.DropdownName = ((dictionary[text] > 1) ? (text + " (" + Sanitize(item.PrefabName) + ")") : text));
				IndexName(text2, item);
				IndexName(item.DisplayName, item);
				IndexName(item.PrefabName, item);
				list.Add(text2);
			}
			_dropdownNames = list.ToArray();
		}

		private static string DropdownBaseName(CatalogItem item)
		{
			string text = Sanitize(item.DisplayName);
			if (string.IsNullOrEmpty(text))
			{
				text = Sanitize(item.PrefabName);
			}
			if (string.IsNullOrEmpty(text))
			{
				text = ((item.Id != 0) ? ("Item " + item.Id) : "Unnamed item");
			}
			return text;
		}

		private static void IndexName(string name, CatalogItem item)
		{
			if (item == null || string.IsNullOrEmpty(name))
			{
				return;
			}
			string text = name.Trim();
			if (text.Length != 0)
			{
				if (!_byName.ContainsKey(text))
				{
					_byName[text] = item;
				}
				string text2 = FoldName(text);
				if (text2.Length > 0 && !_byFold.ContainsKey(text2))
				{
					_byFold[text2] = item;
				}
			}
		}

		private static CatalogItem WrapTransient(Item prefab)
		{
			return new CatalogItem
			{
				Id = prefab.itemID,
				Prefab = prefab,
				PrefabName = SafePrefabName(prefab),
				DisplayName = SafeDisplayName(prefab),
				DropdownName = SafeDisplayName(prefab)
			};
		}

		private static string FoldName(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			foreach (char c in value)
			{
				if (char.IsLetterOrDigit(c))
				{
					stringBuilder.Append(char.ToLowerInvariant(c));
				}
			}
			return stringBuilder.ToString();
		}

		private static string Sanitize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			foreach (char c in value)
			{
				if (c == '=' || c == '[' || c == ']' || c == '\\' || c == '"' || c == '\n' || c == '\r' || c == '#')
				{
					stringBuilder.Append(' ');
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString().Trim();
		}

		private static string SafePrefabName(Item item)
		{
			try
			{
				if ((Object)(object)item != (Object)null && (Object)(object)((Component)item).gameObject != (Object)null && !string.IsNullOrEmpty(((Object)((Component)item).gameObject).name))
				{
					string text = ((Object)((Component)item).gameObject).name;
					int num = text.IndexOf("(Clone)", StringComparison.Ordinal);
					if (num >= 0)
					{
						text = text.Substring(0, num).Trim();
					}
					return text;
				}
				if ((Object)(object)item != (Object)null && !string.IsNullOrEmpty(((Object)item).name))
				{
					return ((Object)item).name;
				}
			}
			catch
			{
			}
			return "unknown";
		}

		private static string SafeDisplayName(Item item)
		{
			try
			{
				if (item?.UIData != null && !string.IsNullOrEmpty(item.UIData.itemName))
				{
					try
					{
						string name = item.GetName();
						if (!string.IsNullOrEmpty(name) && name.IndexOf("NAME_", StringComparison.OrdinalIgnoreCase) < 0)
						{
							return name;
						}
					}
					catch
					{
					}
					return Prettify(item.UIData.itemName);
				}
			}
			catch
			{
			}
			return Prettify(SafePrefabName(item));
		}

		private static string Prettify(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return "Unknown";
			}
			StringBuilder stringBuilder = new StringBuilder(name.Length + 8);
			for (int i = 0; i < name.Length; i++)
			{
				char c = name[i];
				if (c == '_' || c == '-')
				{
					stringBuilder.Append(' ');
					continue;
				}
				if (i > 0 && char.IsUpper(c) && !char.IsUpper(name[i - 1]) && name[i - 1] != ' ')
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(c);
			}
			return stringBuilder.ToString().Trim();
		}
	}
	internal sealed class LuggageEntry
	{
		public SpawnPool Pool;

		public string EnumName;

		public string DisplayName;
	}
	internal static class LuggageCatalog
	{
		private static readonly List<LuggageEntry> _entries = new List<LuggageEntry>();

		private static readonly Dictionary<SpawnPool, LuggageEntry> _byPool = new Dictionary<SpawnPool, LuggageEntry>();

		public static IReadOnlyList<LuggageEntry> All => _entries;

		public static int Count => _entries.Count;

		public static void Refresh()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			_entries.Clear();
			_byPool.Clear();
			foreach (SpawnPool value in Enum.GetValues(typeof(SpawnPool)))
			{
				if (IsLuggagePool(value))
				{
					string enumName = ((object)value/*cast due to .constrained prefix*/).ToString();
					LuggageEntry luggageEntry = new LuggageEntry
					{
						Pool = value,
						EnumName = enumName,
						DisplayName = Prettify(enumName)
					};
					_entries.Add(luggageEntry);
					_byPool[value] = luggageEntry;
				}
			}
			_entries.Sort((LuggageEntry a, LuggageEntry b) => string.Compare(a.DisplayName, b.DisplayName, StringComparison.OrdinalIgnoreCase));
		}

		public unsafe static bool IsLuggagePool(SpawnPool pool)
		{
			string text = ((object)(*(SpawnPool*)(&pool))/*cast due to .constrained prefix*/).ToString();
			return text.StartsWith("Luggage", StringComparison.Ordinal) || string.Equals(text, "RespawnCoffin", StringComparison.Ordinal);
		}

		public static bool TryGet(SpawnPool pool, out LuggageEntry entry)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return _byPool.TryGetValue(pool, out entry);
		}

		public static SpawnPool GuessPoolFromWorld(string objectName, string sceneName)
		{
			//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_000a: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_00c1: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			SpawnPool val = GuessPoolFromName(objectName);
			if ((int)val > 0)
			{
				return val;
			}
			if (!string.IsNullOrEmpty(objectName) && objectName.IndexOf("Trick", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				SpawnPool val2 = GuessPoolFromName("LuggageClown");
				if ((int)val2 > 0)
				{
					return val2;
				}
			}
			if (!string.IsNullOrEmpty(sceneName))
			{
				if (sceneName.IndexOf("Airport", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return GuessPoolFromName("LuggageBeach");
				}
				if (sceneName.StartsWith("Level_", StringComparison.OrdinalIgnoreCase))
				{
					return GuessPoolFromName("Luggage" + sceneName.Substring("Level_".Length));
				}
			}
			return (SpawnPool)0;
		}

		public static SpawnPool GuessPoolFromName(string objectName)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(objectName))
			{
				return (SpawnPool)0;
			}
			for (int i = 0; i < _entries.Count; i++)
			{
				LuggageEntry luggageEntry = _entries[i];
				if (objectName.IndexOf(luggageEntry.EnumName, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return luggageEntry.Pool;
				}
			}
			for (int j = 0; j < _entries.Count; j++)
			{
				LuggageEntry luggageEntry2 = _entries[j];
				string text = luggageEntry2.DisplayName.Replace(" ", string.Empty);
				if (text.Length >= 3 && objectName.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return luggageEntry2.Pool;
				}
			}
			return (SpawnPool)0;
		}

		public unsafe static string GetDisplayName(SpawnPool pool)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (_byPool.TryGetValue(pool, out var value) && value != null)
			{
				return value.DisplayName;
			}
			return Prettify(((object)(*(SpawnPool*)(&pool))/*cast due to .constrained prefix*/).ToString());
		}

		private static string Prettify(string enumName)
		{
			if (string.IsNullOrEmpty(enumName))
			{
				return "Unknown";
			}
			string text = enumName;
			if (text.StartsWith("Luggage", StringComparison.Ordinal))
			{
				text = text.Substring("Luggage".Length);
			}
			if (string.IsNullOrEmpty(text))
			{
				text = enumName;
			}
			char[] array = new char[text.Length + 8];
			int length = 0;
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				if (c == '_' || c == '-')
				{
					array[length++] = ' ';
					continue;
				}
				if (i > 0 && char.IsUpper(c) && !char.IsUpper(text[i - 1]) && text[i - 1] != ' ')
				{
					array[length++] = ' ';
				}
				array[length++] = c;
			}
			return new string(array, 0, length).Trim();
		}
	}
	[Serializable]
	internal sealed class SavedLootFile
	{
		public int version = 1;

		public List<SavedPool> pools = new List<SavedPool>();

		public List<SavedPool> vanilla = new List<SavedPool>();

		public List<SavedSpotCount> spots = new List<SavedSpotCount>();
	}
	[Serializable]
	internal sealed class SavedSpotCount
	{
		public string pool;

		public int count;
	}
	[Serializable]
	internal sealed class SavedPool
	{
		public string pool;

		public List<SavedWeight> weights = new List<SavedWeight>();

		public List<int> removed = new List<int>();

		public int spawnCount;

		public int countValue;

		public bool forceCount;

		public bool randomCount;

		public int multiplier;

		public bool shareWithParty;

		public bool disableDuplicates;
	}
	internal sealed class PoolSpawnSettings
	{
		public bool ForceCount;

		public bool RandomCount;

		public int CountValue;

		public int Multiplier = 1;

		public bool ShareWithParty;

		public bool DisableDuplicates;

		public bool IsDefault => !ForceCount && !RandomCount && Multiplier <= 1 && !ShareWithParty && !DisableDuplicates;

		public PoolSpawnSettings Clone()
		{
			return new PoolSpawnSettings
			{
				ForceCount = ForceCount,
				RandomCount = RandomCount,
				CountValue = CountValue,
				Multiplier = ((Multiplier < 1) ? 1 : Multiplier),
				ShareWithParty = ShareWithParty,
				DisableDuplicates = DisableDuplicates
			};
		}
	}
	[Serializable]
	internal sealed class SavedWeight
	{
		public int id;

		public int weight;
	}
	internal sealed class LootEntry
	{
		public ushort Id;

		public int Weight;

		public bool IsCustom;

		public bool IsVanilla;
	}
	internal static class LootStore
	{
		[HarmonyPatch(typeof(LootData), "PopulateLootData")]
		[HarmonyPriority(0)]
		private static class Patch_PopulateLootData
		{
			private static void Postfix()
			{
				try
				{
					CaptureVanillaAndApply();
				}
				catch (Exception ex)
				{
					Plugin.LogError("PopulateLootData overlay failed: " + ex);
				}
			}
		}

		public const int DefaultAddWeight = 15;

		public const int MaxRolledSpawns = 24;

		private static readonly Dictionary<SpawnPool, Dictionary<ushort, int>> _vanilla = new Dictionary<SpawnPool, Dictionary<ushort, int>>();

		private static readonly Dictionary<SpawnPool, Dictionary<ushort, int>> _overrides = new Dictionary<SpawnPool, Dictionary<ushort, int>>();

		private static readonly Dictionary<SpawnPool, HashSet<ushort>> _removed = new Dictionary<SpawnPool, HashSet<ushort>>();

		private static readonly Dictionary<SpawnPool, PoolSpawnSettings> _spawn = new Dictionary<SpawnPool, PoolSpawnSettings>();

		private static readonly Dictionary<SpawnPool, int> _vanillaSpots = new Dictionary<SpawnPool, int>();

		private static string _path;

		private static bool _loaded;

		private static SavedPool _clipboard;

		public static bool HasVanillaSnapshot { get; private set; }

		public static bool HasClipboard => _clipboard != null;

		public static void Initialize()
		{
			if (!_loaded)
			{
				_path = Path.Combine(Paths.ConfigPath, "tony4twentys.PEAK_Luggage_Items.loot.json");
				Load();
				_loaded = true;
			}
		}

		public static bool IsEdited(SpawnPool pool)
		{
			//IL_0006: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ushort, int> value;
			HashSet<ushort> value2;
			return (_overrides.TryGetValue(pool, out value) && value.Count > 0) || (_removed.TryGetValue(pool, out value2) && value2.Count > 0) || HasSpawnEdits(pool);
		}

		public static bool HasSpawnEdits(SpawnPool pool)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			PoolSpawnSettings value;
			return _spawn.TryGetValue(pool, out value) && value != null && !value.IsDefault;
		}

		public static PoolSpawnSettings GetSpawnSettings(SpawnPool pool)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (_spawn.TryGetValue(pool, out var value) && value != null)
			{
				return value.Clone();
			}
			return new PoolSpawnSettings();
		}

		public static int GetMaxSpotCount(SpawnPool pool)
		{
			//IL_000e: 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)
			LuggageSpawnPatches.DiscoverVanillaSpotCounts();
			int num = 0;
			if (_vanillaSpots.TryGetValue(pool, out var value) && value > 0)
			{
				num = value;
			}
			return Mathf.Clamp(Mathf.Max(num, FallbackMaxSpots(pool)), 1, 24);
		}

		public static int GetCountValue(SpawnPool pool)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			PoolSpawnSettings spawnSettings = GetSpawnSettings(pool);
			int maxSpotCount = GetMaxSpotCount(pool);
			if (spawnSettings.CountValue > 0)
			{
				return Mathf.Clamp(spawnSettings.CountValue, 1, maxSpotCount);
			}
			return maxSpotCount;
		}

		public static int GetWantedSpawnCount(SpawnPool pool, int thisOpenSpots, int instanceMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			PoolSpawnSettings spawnSettings = GetSpawnSettings(pool);
			int countValue = GetCountValue(pool);
			int num = ((instanceMax > 0) ? instanceMax : thisOpenSpots);
			if (num <= 0)
			{
				num = countValue;
			}
			int num2 = Mathf.Min(countValue, num);
			int num3 = (spawnSettings.ForceCount ? Mathf.Max(0, num2) : ((!spawnSettings.RandomCount) ? Mathf.Max(0, num) : ((num2 > 0) ? Random.Range(1, num2 + 1) : 0)));
			if (num3 <= 0 && spawnSettings.Multiplier > 1)
			{
				num3 = 1;
			}
			int num4 = ((spawnSettings.Multiplier < 1) ? 1 : spawnSettings.Multiplier);
			return Mathf.Max(0, num3 * num4);
		}

		public static void RememberVanillaSpots(SpawnPool pool, int count)
		{
			//IL_0001: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			if (LuggageCatalog.IsLuggagePool(pool) && count > 0 && (!_vanillaSpots.TryGetValue(pool, out var value) || value < count))
			{
				_vanillaSpots[pool] = count;
				Save();
			}
		}

		public unsafe static int FallbackMaxSpots(SpawnPool pool)
		{
			string a = ((object)(*(SpawnPool*)(&pool))/*cast due to .constrained prefix*/).ToString();
			if (string.Equals(a, "LuggageClown", StringComparison.Ordinal))
			{
				return 6;
			}
			if (string.Equals(a, "LuggageAncient", StringComparison.Ordinal) || string.Equals(a, "LuggageCursed", StringComparison.Ordinal) || string.Equals(a, "RespawnCoffin", StringComparison.Ordinal))
			{
				return 1;
			}
			if (string.Equals(a, "LuggageClimber", StringComparison.Ordinal))
			{
				return 2;
			}
			return 3;
		}

		public static bool HasSpawnCountOverride(SpawnPool pool)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			PoolSpawnSettings spawnSettings = GetSpawnSettings(pool);
			return spawnSettings.ForceCount || spawnSettings.RandomCount || spawnSettings.Multiplier > 1;
		}

		public static bool GetShareWithParty(SpawnPool pool)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			PoolSpawnSettings value;
			return _spawn.TryGetValue(pool, out value) && value != null && value.ShareWithParty;
		}

		public static bool GetDisableDuplicates(SpawnPool pool)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			PoolSpawnSettings value;
			return _spawn.TryGetValue(pool, out value) && value != null && value.DisableDuplicates;
		}

		public static bool GetAllowRepeats(SpawnPool pool)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ShouldAllowRepeats(pool, -1);
		}

		public static List<GameObject> PickPrefabsNoDuplicates(SpawnPool pool, int count, HashSet<ushort> used)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> list = new List<GameObject>();
			if (count <= 0)
			{
				return list;
			}
			if (used == null)
			{
				used = new HashSet<ushort>();
			}
			List<LootEntry> list2 = new List<LootEntry>();
			List<LootEntry> effectiveItems = GetEffectiveItems(pool);
			for (int i = 0; i < effectiveItems.Count; i++)
			{
				if (effectiveItems[i].Weight > 0)
				{
					list2.Add(effectiveItems[i]);
				}
			}
			if (list2.Count == 0)
			{
				return list;
			}
			while (list.Count < count)
			{
				int num = 0;
				for (int j = 0; j < list2.Count; j++)
				{
					if (!used.Contains(list2[j].Id))
					{
						num += list2[j].Weight;
					}
				}
				if (num <= 0)
				{
					if (used.Count == 0)
					{
						break;
					}
					used.Clear();
					continue;
				}
				int num2 = Random.Range(0, num);
				LootEntry lootEntry = null;
				for (int k = 0; k < list2.Count; k++)
				{
					if (!used.Contains(list2[k].Id))
					{
						num2 -= list2[k].Weight;
						if (num2 < 0)
						{
							lootEntry = list2[k];
							break;
						}
					}
				}
				if (lootEntry == null)
				{
					break;
				}
				Item val = null;
				try
				{
					ItemDatabase.TryGetItem(lootEntry.Id, ref val);
				}
				catch
				{
				}
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
				{
					used.Add(lootEntry.Id);
					continue;
				}
				used.Add(lootEntry.Id);
				list.Add(((Component)val).gameObject);
			}
			return list;
		}

		public static int CountEnabledItems(SpawnPool pool)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			List<LootEntry> effectiveItems = GetEffectiveItems(pool);
			for (int i = 0; i < effectiveItems.Count; i++)
			{
				if (effectiveItems[i].Weight > 0)
				{
					num++;
				}
			}
			return num;
		}

		public static bool ShouldAllowRepeats(SpawnPool pool, int wanted)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			int num = CountEnabledItems(pool);
			if (wanted <= 0)
			{
				PoolSpawnSettings spawnSettings = GetSpawnSettings(pool);
				int countValue = GetCountValue(pool);
				int num2 = ((spawnSettings.Multiplier < 1) ? 1 : spawnSettings.Multiplier);
				wanted = Mathf.Max(1, countValue * num2);
			}
			if (GetDisableDuplicates(pool))
			{
				return num < wanted;
			}
			if (!_spawn.TryGetValue(pool, out var value) || value == null)
			{
				return false;
			}
			return value.ForceCount || value.RandomCount || value.Multiplier > 1;
		}

		public static void SetForceCount(SpawnPool pool, bool value)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			MutateSettings(pool, delegate(PoolSpawnSettings s)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				s.ForceCount = value;
				if (value)
				{
					s.RandomCount = false;
					if (s.CountValue <= 0)
					{
						s.CountValue = GetMaxSpotCount(pool);
					}
				}
			});
		}

		public static void SetRandomCount(SpawnPool pool, bool value)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			MutateSettings(pool, delegate(PoolSpawnSettings s)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				s.RandomCount = value;
				if (value)
				{
					s.ForceCount = false;
					if (s.CountValue <= 0)
					{
						s.CountValue = GetMaxSpotCount(pool);
					}
				}
			});
		}

		public static void SetCountValue(SpawnPool pool, int value)
		{
			//IL_000f: 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)
			int max = GetMaxSpotCount(pool);
			MutateSettings(pool, delegate(PoolSpawnSettings s)
			{
				s.CountValue = Mathf.Clamp(value, 1, max);
			});
		}

		public static void SetMultiplier(SpawnPool pool, int multiplier)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			MutateSettings(pool, delegate(PoolSpawnSettings s)
			{
				s.Multiplier = Mathf.Max(1, multiplier);
			});
		}

		public static void SetShareWithParty(SpawnPool pool, bool value)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			MutateSettings(pool, delegate(PoolSpawnSettings s)
			{
				s.ShareWithParty = value;
				if (value)
				{
					s.DisableDuplicates = false;
				}
			});
		}

		public static void SetDisableDuplicates(SpawnPool pool, bool value)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			MutateSettings(pool, delegate(PoolSpawnSettings s)
			{
				s.DisableDuplicates = value;
				if (value)
				{
					s.ShareWithParty = false;
				}
			});
		}

		public static void CopyPool(SpawnPool pool)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			_clipboard = ExportPool(pool);
		}

		public static bool PastePool(SpawnPool dest)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (_clipboard == null)
			{
				return false;
			}
			ImportPool(dest, _clipboard);
			return true;
		}

		public unsafe static SavedPool ExportPool(SpawnPool pool)
		{
			//IL_0001: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			PoolSpawnSettings spawnSettings = GetSpawnSettings(pool);
			SavedPool savedPool = new SavedPool
			{
				pool = ((object)(*(SpawnPool*)(&pool))/*cast due to .constrained prefix*/).ToString(),
				weights = new List<SavedWeight>(),
				removed = new List<int>(),
				spawnCount = spawnSettings.CountValue,
				countValue = spawnSettings.CountValue,
				forceCount = spawnSettings.ForceCount,
				randomCount = spawnSettings.RandomCount,
				multiplier = ((spawnSettings.Multiplier < 1) ? 1 : spawnSettings.Multiplier),
				shareWithParty = spawnSettings.ShareWithParty,
				disableDuplicates = spawnSettings.DisableDuplicates
			};
			HashSet<ushort> hashSet = new HashSet<ushort>();
			List<LootEntry> effectiveItems = GetEffectiveItems(pool);
			for (int i = 0; i < effectiveItems.Count; i++)
			{
				LootEntry lootEntry = effectiveItems[i];
				if (lootEntry.Weight > 0)
				{
					savedPool.weights.Add(new SavedWeight
					{
						id = lootEntry.Id,
						weight = lootEntry.Weight
					});
					hashSet.Add(lootEntry.Id);
				}
			}
			if (_vanilla.TryGetValue(pool, out var value) && value != null)
			{
				foreach (ushort key in value.Keys)
				{
					if (!hashSet.Contains(key))
					{
						savedPool.removed.Add(key);
					}
				}
			}
			return savedPool;
		}

		public static void ImportPool(SpawnPool dest, SavedPool data)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_010a: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			if (data == null)
			{
				return;
			}
			_overrides.Remove(dest);
			_removed.Remove(dest);
			_spawn.Remove(dest);
			PoolSpawnSettings poolSpawnSettings = ReadSpawnSettings(data);
			if (!poolSpawnSettings.IsDefault || poolSpawnSettings.CountValue > 0)
			{
				_spawn[dest] = poolSpawnSettings;
			}
			HashSet<ushort> hashSet = new HashSet<ushort>();
			if (data.weights != null)
			{
				for (int i = 0; i < data.weights.Count; i++)
				{
					SavedWeight savedWeight = data.weights[i];
					if (savedWeight != null && savedWeight.id >= 0 && savedWeight.id <= 65535 && savedWeight.weight > 0)
					{
						ushort num = (ushort)savedWeight.id;
						WriteWeight(dest, num, savedWeight.weight);
						hashSet.Add(num);
					}
				}
			}
			if (_vanilla.TryGetValue(dest, out var value) && value != null)
			{
				foreach (ushort key in value.Keys)
				{
					if (!hashSet.Contains(key))
					{
						GetOrCreateRemoved(dest).Add(key);
					}
				}
			}
			if (data.removed != null)
			{
				for (int j = 0; j < data.removed.Count; j++)
				{
					int num2 = data.removed[j];
					if (num2 >= 0 && num2 <= 65535)
					{
						ushort item = (ushort)num2;
						if (!hashSet.Contains(item))
						{
							GetOrCreateRemoved(dest).Add(item);
						}
					}
				}
			}
			Save();
			ApplyToGame();
		}

		public static SavedLootFile ExportUserFile()
		{
			return BuildSavedFile();
		}

		public static void ApplyUserFile(SavedLootFile file)
		{
			if (!LootJson.HasData(file))
			{
				Plugin.LogDebug("Ignored empty preset/loot file so current settings were not wiped.");
				return;
			}
			_overrides.Clear();
			_removed.Clear();
			_spawn.Clear();
			ApplySavedPools(file.pools);
			Save();
			ApplyToGame();
		}

		public static bool TryGetVanillaWeight(SpawnPool pool, ushort id, out int weight)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			weight = 0;
			Dictionary<ushort, int> value;
			return _vanilla.TryGetValue(pool, out value) && value != null && value.TryGetValue(id, out weight) && weight > 0;
		}

		public static string DescribeSpawn(SpawnPool pool, int vanillaSpots)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			PoolSpawnSettings spawnSettings = GetSpawnSettings(pool);
			int countValue = GetCountValue(pool);
			string text = (spawnSettings.ForceCount ? ("force " + countValue) : (spawnSettings.RandomCount ? ("random 1-" + countValue) : ((vanillaSpots <= 0) ? "vanilla spots" : (vanillaSpots + " vanilla spot" + ((vanillaSpots == 1) ? "" : "s")))));
			if (spawnSettings.Multiplier > 1)
			{
				text = text + "  ·  " + spawnSettings.Multiplier + "×";
			}
			if (spawnSettings.ShareWithParty)
			{
				text += "  ·  party share";
			}
			return text;
		}

		public static List<LootEntry> GetEffectiveItems(SpawnPool pool)
		{
			//IL_000c: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ushort, int> dictionary = new Dictionary<ushort, int>();
			if (_vanilla.TryGetValue(pool, out var value))
			{
				foreach (KeyValuePair<ushort, int> item in value)
				{
					dictionary[item.Key] = item.Value;
				}
			}
			if (_removed.TryGetValue(pool, out var value2))
			{
				foreach (ushort item2 in value2)
				{
					dictionary.Remove(item2);
				}
			}
			if (_overrides.TryGetValue(pool, out var value3))
			{
				foreach (KeyValuePair<ushort, int> item3 in value3)
				{
					if (item3.Value <= 0)
					{
						dictionary.Remove(item3.Key);
					}
					else
					{
						dictionary[item3.Key] = item3.Value;
					}
				}
			}
			List<LootEntry> list = new List<LootEntry>(dictionary.Count);
			foreach (KeyValuePair<ushort, int> item4 in dictionary)
			{
				bool flag = value?.ContainsKey(item4.Key) ?? false;
				int num = 0;
				if (flag)
				{
					num = value[item4.Key];
				}
				list.Add(new LootEntry
				{
					Id = item4.Key,
					Weight = item4.Value,
					IsVanilla = flag,
					IsCustom = (!flag || num != item4.Value)
				});
			}
			list.Sort((LootEntry a, LootEntry b) => string.Compare(ItemCatalog.GetName(a.Id), ItemCatalog.GetName(b.Id), StringComparison.OrdinalIgnoreCase));
			return list;
		}

		public static int GetTotalWeight(SpawnPool pool)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			List<LootEntry> effectiveItems = GetEffectiveItems(pool);
			for (int i = 0; i < effectiveItems.Count; i++)
			{
				num += Mathf.Max(0, effectiveItems[i].Weight);
			}
			return num;
		}

		public static bool IsEnabled(SpawnPool pool, ushort id)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			List<LootEntry> effectiveItems = GetEffectiveItems(pool);
			for (int i = 0; i < effectiveItems.Count; i++)
			{
				if (effectiveItems[i].Id == id)
				{
					return effectiveItems[i].Weight > 0;
				}
			}
			return false;
		}

		public static int GetSuggestedWeight(SpawnPool pool, ushort id)
		{
			//IL_0001: 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)
			List<LootEntry> effectiveItems = GetEffectiveItems(pool);
			for (int i = 0; i < effectiveItems.Count; i++)
			{
				if (effectiveItems[i].Id == id && effectiveItems[i].Weight > 0)
				{
					return effectiveItems[i].Weight;
				}
			}
			if (_vanilla.TryGetValue(pool, out var value) && value.TryGetValue(id, out var value2) && value2 > 0)
			{
				return value2;
			}
			return 15;
		}

		public static void SetEnabled(SpawnPool pool, ushort id, bool enabled, int weightIfEnabled)
		{
			//IL_0021: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			if (enabled)
			{
				int weight = ((weightIfEnabled > 0) ? weightIfEnabled : GetSuggestedWeight(pool, id));
				SetWeight(pool, id, weight);
			}
			else
			{
				RemoveItem(pool, id);
			}
		}

		public static void AddItem(SpawnPool pool, ushort id)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetRemoved(pool, out var removed) && removed.Remove(id))
			{
				if (removed.Count == 0)
				{
					_removed.Remove(pool);
				}
				Save();
				ApplyToGame();
				return;
			}
			List<LootEntry> effectiveItems = GetEffectiveItems(pool);
			for (int i = 0; i < effectiveItems.Count; i++)
			{
				if (effectiveItems[i].Id == id)
				{
					return;
				}
			}
			int weight = 15;
			if (_vanilla.TryGetValue(pool, out var value) && value.TryGetValue(id, out var value2) && value2 > 0)
			{
				weight = value2;
			}
			SetWeight(pool, id, weight);
		}

		public static void SetWeight(SpawnPool pool, ushort id, int weight)
		{
			//IL_0017: 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)
			if (weight <= 0)
			{
				RemoveItem(pool, id);
				return;
			}
			WriteWeight(pool, id, weight);
			Save();
			ApplyToGame();
		}

		private static void WriteWeight(SpawnPool pool, ushort id, int weight)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetRemoved(pool, out var removed))
			{
				removed.Remove(id);
				if (removed.Count == 0)
				{
					_removed.Remove(pool);
				}
			}
			if (_vanilla.TryGetValue(pool, out var value) && value.TryGetValue(id, out var value2) && value2 == weight)
			{
				if (_overrides.TryGetValue(pool, out var value3))
				{
					value3.Remove(id);
					if (value3.Count == 0)
					{
						_overrides.Remove(pool);
					}
				}
			}
			else
			{
				GetOrCreateOverrides(pool)[id] = weight;
			}
		}

		public static void RemoveItem(SpawnPool pool, ushort id)
		{
			//IL_0006: 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_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)
			if (_overrides.TryGetValue(pool, out var value))
			{
				value.Remove(id);
				if (value.Count == 0)
				{
					_overrides.Remove(pool);
				}
			}
			if (_vanilla.TryGetValue(pool, out var value2) && value2.ContainsKey(id))
			{
				GetOrCreateRemoved(pool).Add(id);
			}
			Save();
			ApplyToGame();
		}

		public static void ResetPool(SpawnPool pool)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			_overrides.Remove(pool);
			_removed.Remove(pool);
			_spawn.Remove(pool);
			Save();
			RestorePoolFromSnapshot(pool);
			ApplyToGame();
		}

		public static void ClearPool(SpawnPool pool)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_009d: 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)
			List<LootEntry> effectiveItems = GetEffectiveItems(pool);
			for (int i = 0; i < effectiveItems.Count; i++)
			{
				ushort id = effectiveItems[i].Id;
				if (_overrides.TryGetValue(pool, out var value))
				{
					value.Remove(id);
				}
				if (_vanilla.TryGetValue(pool, out var value2) && value2.ContainsKey(id))
				{
					GetOrCreateRemoved(pool).Add(id);
				}
			}
			if (_overrides.TryGetValue(pool, out var value3) && value3.Count == 0)
			{
				_overrides.Remove(pool);
			}
			Save();
			ApplyToGame();
		}

		public static void EnableAll(SpawnPool pool)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			HashSet<ushort> hashSet = new HashSet<ushort>();
			IReadOnlyList<CatalogItem> items = ItemCatalog.Items;
			for (int i = 0; i < items.Count; i++)
			{
				CatalogItem catalogItem = items[i];
				if (catalogItem != null && !hashSet.Contains(catalogItem.Id))
				{
					hashSet.Add(catalogItem.Id);
					WriteWeight(pool, catalogItem.Id, GetSuggestedWeight(pool, catalogItem.Id));
				}
			}
			List<LootEntry> effectiveItems = GetEffectiveItems(pool);
			for (int j = 0; j < effectiveItems.Count; j++)
			{
				ushort id = effectiveItems[j].Id;
				if (!hashSet.Contains(id))
				{
					WriteWeight(pool, id, (effectiveItems[j].Weight > 0) ? effectiveItems[j].Weight : GetSuggestedWeight(pool, id));
				}
			}
			Save();
			ApplyToGame();
		}

		public static void SetAllEnabledWeights(SpawnPool pool, int weight)
		{
			//IL_000f: 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)
			weight = Mathf.Clamp(weight, 1, 9999);
			List<LootEntry> effectiveItems = GetEffectiveItems(pool);
			for (int i = 0; i < effectiveItems.Count; i++)
			{
				WriteWeight(pool, effectiveItems[i].Id, weight);
			}
			Save();
			ApplyToGame();
		}

		public static void TryEnsureDefaults()
		{
			if (HasVanillaSnapshot)
			{
				ApplyToGame();
			}
			else if (TryCaptureFromLiveTables())
			{
				Save();
				ApplyToGame();
			}
			else if (BuildVanillaFromItemLootData())
			{
				Plugin.LogDebug("Built luggage defaults from item LootData (" + _vanilla.Count + " pools).");
				Save();
				ApplyToGame();
			}
		}

		public static void CaptureVanillaAndApply()
		{
			CaptureVanilla();
			if (HasVanillaSnapshot)
			{
				Save();
			}
			ApplyToGame();
		}

		public static void ApplyToGame()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (LootData.AllSpawnWeightData == null)
			{
				return;
			}
			foreach (LuggageEntry item in LuggageCatalog.All)
			{
				SpawnPool pool = item.Pool;
				bool flag = IsEdited(pool);
				if (!LootData.AllSpawnWeightData.TryGetValue(pool, out var value) || value == null)
				{
					if (!flag && !HasVanillaSnapshot)
					{
						continue;
					}
					value = new Dictionary<ushort, int>();
					LootData.AllSpawnWeightData[pool] = value;
				}
				if (HasVanillaSnapshot)
				{
					SyncLiveToEffective(value, GetEffectiveItems(pool));
				}
				else
				{
					if (!flag)
					{
						continue;
					}
					if (_removed.TryGetValue(pool, out var value2))
					{
						foreach (ushort item2 in value2)
						{
							value.Remove(item2);
						}
					}
					if (!_overrides.TryGetValue(pool, out var value3))
					{
						continue;
					}
					foreach (KeyValuePair<ushort, int> item3 in value3)
					{
						if (item3.Value <= 0)
						{
							value.Remove(item3.Key);
						}
						else
						{
							value[item3.Key] = item3.Value;
						}
					}
				}
			}
			InvalidateLootCaches();
			Plugin.LogDebug("Applied luggage loot overlays.");
		}

		private static void SyncLiveToEffective(Dictionary<ushort, int> live, List<LootEntry> effective)
		{
			HashSet<ushort> hashSet = new HashSet<ushort>();
			for (int i = 0; i < effective.Count; i++)
			{
				LootEntry lootEntry = effective[i];
				live[lootEntry.Id] = lootEntry.Weight;
				hashSet.Add(lootEntry.Id);
			}
			List<ushort> list = new List<ushort>();
			foreach (ushort key in live.Keys)
			{
				if (!hashSet.Contains(key))
				{
					list.Add(key);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				live.Remove(list[j]);
			}
		}

		private static bool TryCaptureFromLiveTables()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (LootData.AllSpawnWeightData == null || LootData.AllSpawnWeightData.Count == 0)
			{
				return false;
			}
			int num = 0;
			foreach (KeyValuePair<SpawnPool, Dictionary<ushort, int>> allSpawnWeightDatum in LootData.AllSpawnWeightData)
			{
				if (LuggageCatalog.IsLuggagePool(allSpawnWeightDatum.Key) && allSpawnWeightDatum.Value != null && allSpawnWeightDatum.Value.Count > 0)
				{
					num++;
				}
			}
			if (num == 0)
			{
				return false;
			}
			CaptureVanilla();
			return HasVanillaSnapshot;
		}

		private static bool BuildVanillaFromItemLootData()
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: 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_0202: Unknown result type (might be due to invalid IL or missing references)
			ItemDatabase val = null;
			try
			{
				val = SingletonAsset<ItemDatabase>.Instance;
			}
			catch
			{
				return false;
			}
			if (val?.itemLookup == null || val.itemLookup.Count == 0)
			{
				return false;
			}
			Dictionary<SpawnPool, Dictionary<ushort, int>> dictionary = new Dictionary<SpawnPool, Dictionary<ushort, int>>();
			foreach (KeyValuePair<ushort, Item> item in val.itemLookup)
			{
				Item value = item.Value;
				if ((Object)(object)value == (Object)null)
				{
					continue;
				}
				LootData component = ((Component)value).GetComponent<LootData>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				int value2 = 15;
				try
				{
					if (LootData.RarityWeights != null && LootData.RarityWeights.TryGetValue(component.Rarity, out var value3) && value3 > 0)
					{
						value2 = value3;
					}
				}
				catch
				{
				}
				foreach (SpawnPool value5 in Enum.GetValues(typeof(SpawnPool)))
				{
					if (!LuggageCatalog.IsLuggagePool(value5))
					{
						continue;
					}
					bool flag = false;
					try
					{
						flag = ((Enum)component.spawnLocations).HasFlag((Enum)(object)value5);
					}
					catch
					{
						continue;
					}
					if (flag)
					{
						if (!dictionary.TryGetValue(value5, out var value4) || value4 == null)
						{
							value4 = (dictionary[value5] = new Dictionary<ushort, int>());
						}
						value4[value.itemID] = value2;
					}
				}
			}
			if (dictionary.Count == 0)
			{
				return false;
			}
			_vanilla.Clear();
			foreach (KeyValuePair<SpawnPool, Dictionary<ushort, int>> item2 in dictionary)
			{
				_vanilla[item2.Key] = item2.Value;
			}
			HasVanillaSnapshot = _vanilla.Count > 0;
			return HasVanillaSnapshot;
		}

		private static void CaptureVanilla()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			_vanilla.Clear();
			if (LootData.AllSpawnWeightData == null)
			{
				return;
			}
			foreach (KeyValuePair<SpawnPool, Dictionary<ushort, int>> allSpawnWeightDatum in LootData.AllSpawnWeightData)
			{
				if (!LuggageCatalog.IsLuggagePool(allSpawnWeightDatum.Key) || allSpawnWeightDatum.Value == null)
				{
					continue;
				}
				Dictionary<ushort, int> dictionary = new Dictionary<ushort, int>(allSpawnWeightDatum.Value.Count);
				foreach (KeyValuePair<ushort, int> item in allSpawnWeightDatum.Value)
				{
					dictionary[item.Key] = item.Value;
				}
				_vanilla[allSpawnWeightDatum.Key] = dictionary;
			}
			HasVanillaSnapshot = _vanilla.Count > 0;
			Plugin.LogDebug("Captured vanilla loot for " + _vanilla.Count + " luggage pools.");
		}

		private static void RestorePoolFromSnapshot(SpawnPool pool)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (LootData.AllSpawnWeightData == null || !_vanilla.TryGetValue(pool, out var value))
			{
				return;
			}
			Dictionary<ushort, int> dictionary = new Dictionary<ushort, int>(value.Count);
			foreach (KeyValuePair<ushort, int> item in value)
			{
				dictionary[item.Key] = item.Value;
			}
			LootData.AllSpawnWeightData[pool] = dictionary;
		}

		private static void InvalidateLootCaches()
		{
			GameAccess.ClearLootCaches();
		}

		private static Dictionary<ushort, int> GetOrCreateOverrides(SpawnPool pool)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!_overrides.TryGetValue(pool, out var value) || value == null)
			{
				value = new Dictionary<ushort, int>();
				_overrides[pool] = value;
			}
			return value;
		}

		private static HashSet<ushort> GetOrCreateRemoved(SpawnPool pool)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!_removed.TryGetValue(pool, out var value) || value == null)
			{
				value = new HashSet<ushort>();
				_removed[pool] = value;
			}
			return value;
		}

		private static bool TryGetRemoved(SpawnPool pool, out HashSet<ushort> removed)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return _removed.TryGetValue(pool, out removed) && removed != null;
		}

		private static PoolSpawnSettings ReadSpawnSettings(SavedPool saved)
		{
			PoolSpawnSettings poolSpawnSettings = new PoolSpawnSettings
			{
				ForceCount = saved.forceCount,
				RandomCount = saved.randomCount,
				CountValue = ((saved.countValue > 0) ? saved.countValue : saved.spawnCount),
				Multiplier = ((saved.multiplier < 1) ? 1 : saved.multiplier),
				ShareWithParty = saved.shareWithParty,
				DisableDuplicates = saved.disableDuplicates
			};
			if (!poolSpawnSettings.ForceCount && !poolSpawnSettings.RandomCount && saved.spawnCount > 0 && saved.countValue <= 0)
			{
				poolSpawnSettings.ForceCount = true;
				poolSpawnSettings.CountValue = saved.spawnCount;
			}
			if (poolSpawnSettings.ForceCount && poolSpawnSettings.RandomCount)
			{
				poolSpawnSettings.RandomCount = false;
			}
			if (poolSpawnSettings.ShareWithParty && poolSpawnSettings.DisableDuplicates)
			{
				poolSpawnSettings.DisableDuplicates = false;
			}
			return poolSpawnSettings;
		}

		private static void LoadVanillaSpots(List<SavedSpotCount> list)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			if (list == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				SavedSpotCount savedSpotCount = list[i];
				if (savedSpotCount != null && !string.IsNullOrEmpty(savedSpotCount.pool) && savedSpotCount.count > 0 && Enum.TryParse<SpawnPool>(savedSpotCount.pool, out SpawnPool result) && LuggageCatalog.IsLuggagePool(result))
				{
					int num = Mathf.Clamp(savedSpotCount.count, 1, 24);
					if (!_vanillaSpots.TryGetValue(result, out var value) || num > value)
					{
						_vanillaSpots[result] = num;
					}
				}
			}
		}

		private static List<SavedSpotCount> SerializeVanillaSpots()
		{
			//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)
			List<SavedSpotCount> list = new List<SavedSpotCount>();
			foreach (KeyValuePair<SpawnPool, int> vanillaSpot in _vanillaSpots)
			{
				if (vanillaSpot.Value > 0)
				{
					list.Add(new SavedSpotCount
					{
						pool = ((object)vanillaSpot.Key/*cast due to .constrained prefix*/).ToString(),
						count = vanillaSpot.Value
					});
				}
			}
			return list;
		}

		private unsafe static void MutateSettings(SpawnPool pool, Action<PoolSpawnSettings> mutate)
		{
			//IL_0006: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (!_spawn.TryGetValue(pool, out var value) || value == null)
			{
				value = new PoolSpawnSettings();
			}
			mutate(value);
			if (value.IsDefault && value.CountValue <= 0)
			{
				_spawn.Remove(pool);
			}
			else
			{
				_spawn[pool] = value;
			}
			Save();
			Plugin.LogTrace("saved spawn " + ((object)(*(SpawnPool*)(&pool))/*cast due to .constrained prefix*/).ToString() + " force=" + value.ForceCount + " random=" + value.RandomCount + " count=" + value.CountValue + " mult=" + value.Multiplier + " share=" + value.ShareWithParty + " noDupes=" + value.DisableDuplicates + " kept=" + _spawn.ContainsKey(pool));
		}

		internal unsafe static string DebugDescribeAllPools()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("lootFile=" + _path);
			IReadOnlyList<LuggageEntry> all = LuggageCatalog.All;
			for (int i = 0; i < all.Count; i++)
			{
				SpawnPool pool = all[i].Pool;
				PoolSpawnSettings spawnSettings = GetSpawnSettings(pool);
				int num = CountEnabledItems(pool);
				int maxSpotCount = GetMaxSpotCount(pool);
				int wantedSpawnCount = GetWantedSpawnCount(pool, maxSpotCount, maxSpotCount);
				stringBuilder.AppendLine("  " + all[i].DisplayName + " [" + ((object)(*(SpawnPool*)(&pool))/*cast due to .constrained prefix*/).ToString() + "] force=" + spawnSettings.ForceCount + " random=" + spawnSettings.RandomCount + " count=" + spawnSettings.CountValue + " getCount=" + GetCountValue(pool) + " maxSpots=" + maxSpotCount + " mult=" + spawnSettings.Multiplier + " wanted=" + wantedSpawnCount + " override=" + HasSpawnCountOverride(pool) + " share=" + spawnSettings.ShareWithParty + " noDupes=" + spawnSettings.DisableDuplicates + " items=" + num + " edited=" + IsEdited(pool) + " inMemory=" + _spawn.ContainsKey(pool));
			}
			return stringBuilder.ToString();
		}

		private static void LoadVanillaList(List<SavedPool> list)
		{
			//IL_0054: 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)
			if (list == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				SavedPool savedPool = list[i];
				if (savedPool == null || string.IsNullOrEmpty(savedPool.pool) || savedPool.weights == null || !Enum.TryParse<SpawnPool>(savedPool.pool, out SpawnPool result) || !LuggageCatalog.IsLuggagePool(result))
				{
					continue;
				}
				Dictionary<ushort, int> dictionary = new Dictionary<ushort, int>();
				for (int j = 0; j < savedPool.weights.Count; j++)
				{
					SavedWeight savedWeight = savedPool.weights[j];
					if (savedWeight != null && savedWeight.id >= 0 && savedWeight.id <= 65535 && savedWeight.weight > 0)
					{
						dictionary[(ushort)savedWeight.id] = savedWeight.weight;
					}
				}
				if (dictionary.Count > 0)
				{
					_vanilla[result] = dictionary;
				}
			}
			HasVanillaSnapshot = _vanilla.Count > 0;
		}

		private static List<SavedPool> SerializeVanilla()
		{
			//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)
			List<SavedPool> list = new List<SavedPool>();
			foreach (KeyValuePair<SpawnPool, Dictionary<ushort, int>> item in _vanilla)
			{
				if (item.Value == null || item.Value.Count == 0)
				{
					continue;
				}
				SavedPool savedPool = new SavedPool
				{
					pool = ((object)item.Key/*cast due to .constrained prefix*/).ToString(),
					weights = new List<SavedWeight>(),
					removed = new List<int>()
				};
				foreach (KeyValuePair<ushort, int> item2 in item.Value)
				{
					savedPool.weights.Add(new SavedWeight
					{
						id = item2.Key,
						weight = item2.Value
					});
				}
				list.Add(savedPool);
			}
			return list;
		}

		private static void Load()
		{
			_overrides.Clear();
			_removed.Clear();
			_spawn.Clear();
			if (string.IsNullOrEmpty(_path) || !File.Exists(_path))
			{
				return;
			}
			try
			{
				string json = File.ReadAllText(_path);
				SavedLootFile savedLootFile = LootJson.FromJson(json);
				if (LootJson.HasData(savedLootFile))
				{
					LoadVanillaList(savedLootFile.vanilla);
					LoadVanillaSpots(savedLootFile.spots);
					ApplySavedPools(savedLootFile.pools);
					Plugin.LogInfo("Loaded luggage loot overlays from " + _path);
				}
			}
			catch (Exception ex)
			{
				Plugin.LogError("Failed to load loot overlays: " + ex.Message);
			}
		}

		private static void ApplySavedPools(List<SavedPool> list)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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)
			if (list == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				SavedPool savedPool = list[i];
				if (savedPool == null || string.IsNullOrEmpty(savedPool.pool) || !Enum.TryParse<SpawnPool>(savedPool.pool, out SpawnPool result) || !LuggageCatalog.IsLuggagePool(result))
				{
					continue;
				}
				if (savedPool.weights != null)
				{
					for (int j = 0; j < savedPool.weights.Count; j++)
					{
						SavedWeight savedWeight = savedPool.weights[j];
						if (savedWeight != null && savedWeight.id >= 0 && savedWeight.id <= 65535 && savedWeight.weight > 0)
						{
							GetOrCreateOverrides(result)[(ushort)savedWeight.id] = savedWeight.weight;
						}
					}
				}
				if (savedPool.removed != null)
				{
					for (int k = 0; k < savedPool.removed.Count; k++)
					{
						int num = savedPool.removed[k];
						if (num >= 0 && num <= 65535)
						{
							GetOrCreateRemoved(result).Add((ushort)num);
						}
					}
				}
				PoolSpawnSettings poolSpawnSettings = ReadSpawnSettings(savedPool);
				if (!poolSpawnSettings.IsDefault || poolSpawnSettings.CountValue > 0)
				{
					_spawn[result] = poolSpawnSettings;
				}
			}
		}

		private unsafe static SavedLootFile BuildSavedFile()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			SavedLootFile savedLootFile = new SavedLootFile
			{
				version = 3,
				pools = new List<SavedPool>(),
				vanilla = SerializeVanilla(),
				spots = SerializeVanillaSpots()
			};
			HashSet<SpawnPool> hashSet = new HashSet<SpawnPool>();
			foreach (SpawnPool key in _overrides.Keys)
			{
				hashSet.Add(key);
			}
			foreach (SpawnPool key2 in _removed.Keys)
			{
				hashSet.Add(key2);
			}
			foreach (SpawnPool key3 in _spawn.Keys)
			{
				hashSet.Add(key3);
			}
			foreach (SpawnPool item in hashSet)
			{
				PoolSpawnSettings spawnSettings = GetSpawnSettings(item);
				SavedPool savedPool = new SavedPool
				{
					pool = ((object)(*(SpawnPool*)(&item))/*cast due to .constrained prefix*/).ToString(),
					weights = new List<SavedWeight>(),
					removed = new List<int>(),
					spawnCount = spawnSettings.CountValue,
					countValue = spawnSettings.CountValue,
					forceCount = spawnSettings.ForceCount,
					randomCount = spawnSettings.RandomCount,
					multiplier = ((spawnSettings.Multiplier < 1) ? 1 : spawnSettings.Multiplier),
					shareWithParty = spawnSettings.ShareWithParty,
					disableDuplicates = spawnSettings.DisableDuplicates
				};
				if (_overrides.TryGetValue(item, out var value))
				{
					foreach (KeyValuePair<ushort, int> item2 in value)
					{
						savedPool.weights.Add(new SavedWeight
						{
							id = item2.Key,
							weight = item2.Value
						});
					}
				}
				if (_removed.TryGetValue(item, out var value2))
				{
					foreach (ushort item3 in value2)
					{
						savedPool.removed.Add(item3);
					}
				}
				if (savedPool.weights.Count > 0 || savedPool.removed.Count > 0 || !spawnSettings.IsDefault || spawnSettings.CountValue > 0)
				{
					savedLootFile.pools.Add(savedPool);
				}
			}
			return savedLootFile;
		}

		private static void Save()
		{
			if (string.IsNullOrEmpty(_path))
			{
				return;
			}
			try
			{
				SavedLootFile file = BuildSavedFile();
				File.WriteAllText(_path, LootJson.ToJson(file));
				PresetStore.SaveDefaultQuiet();
			}
			catch (Exception ex)
			{
				Plugin.LogError("Failed to save loot overlays: " + ex.Message);
			}
		}
	}
	internal static class LootJson
	{
		private sealed class Reader
		{
			private readonly string _s;

			private int _i;

			public Reader(string json)
			{
				_s = json ?? string.Empty;
			}

			public void SkipWs()
			{
				while (_i < _s.Length && char.IsWhiteSpace(_s[_i]))
				{
					_i++;
				}
			}

			public void Expect(char c)
			{
				SkipWs();
				if (_i >= _s.Length || _s[_i] != c)
				{
					throw new FormatException("Expected '" + c + "' at " + _i);
				}
				_i++;
			}

			public bool TryConsume(char c)
			{
				if (_i < _s.Length && _s[_i] == c)
				{
					_i++;
					return true;
				}
				return false;
			}

			public string ReadString()
			{
				SkipWs();
				Expect('"');
				StringBuilder stringBuilder = new StringBuilder();
				while (_i < _s.Length)
				{
					char c = _s[_i++];
					switch (c)
					{
					case '"':
						return stringBuilder.ToString();
					case '\\':
						if (_i < _s.Length)
						{
							char c2 = _s[_i++];
							switch (c2)
							{
							case 'n':
								stringBuilder.Append('\n');
								break;
							case 'r':
								stringBuilder.Append('\r');
								break;
							case 't':
								stringBuilder.Append('\t');
								break;
							default:
								stringBuilder.Append(c2);
								break;
							}
							break;
						}
						goto default;
					default:
						stringBuilder.Append(c);
						break;
					}
				}
				throw new FormatException("Unterminated string.");
			}

			public int ReadInt()
			{
				SkipWs();
				int i = _i;
				if (_i < _s.Length && (_s[_i] == '-' || _s[_i] == '+'))
				{
					_i++;
				}
				while (_i < _s.Length && char.IsDigit(_s[_i]))
				{
					_i++;
				}
				if (i == _i)
				{
					throw new FormatException("Expected number at " + _i);
				}
				return int.Parse(_s.Substring(i, _i - i), CultureInfo.InvariantCulture);
			}

			public bool ReadBool()
			{
				SkipWs();
				if (Match("true"))
				{
					return true;
				}
				if (Match("false"))
				{
					return false;
				}
				throw new FormatException("Expected bool at " + _i);
			}

			public void SkipValue()
			{
				SkipWs();
				if (_i >= _s.Length)
				{
					return;
				}
				switch (_s[_i])
				{
				case '"':
					ReadString();
					break;
				case '{':
					_i++;
					while (true)
					{
						SkipWs();
						if (TryConsume('}'))
						{
							break;
						}
						ReadString();
						SkipWs();
						Expect(':');
						SkipValue();
						SkipWs();
						TryConsume(',');
					}
					break;
				case '[':
					_i++;
					while (true)
					{
						SkipWs();
						if (TryConsume(']'))
						{
							break;
						}
						SkipValue();
						SkipWs();
						TryConsume(',');
					}
					break;
				default:
					if (!Match("true") && !Match("false") && !Match("null"))
					{
						ReadInt();
					}
					break;
				}
			}

			private bool Match(string token)
			{
				if (_i + token.Length > _s.Length)
				{
					return false;
				}
				for (int i = 0; i < token.Length; i++)
				{
					if (_s[_i + i] != token[i])
					{
						return false;
					}
				}
				_i += token.Length;
				return true;
			}
		}

		public static bool HasData(SavedLootFile file)
		{
			return file != null && ((file.pools != null && file.pools.Count > 0) || (file.vanilla != null && file.vanilla.Count > 0) || (file.spots != null && file.spots.Count > 0));
		}

		public static string ToJson(SavedLootFile file)
		{
			if (file == null)
			{
				file = new SavedLootFile();
			}
			StringBuilder stringBuilder = new StringBuilder(2048);
			stringBuilder.Append("{\n  \"version\": ").Append(file.version).Append(",\n");
			stringBuilder.Append("  \"pools\": ");
			WritePoolList(stringBuilder, file.pools, "  ");
			stringBuilder.Append(",\n  \"vanilla\": ");
			WritePoolList(stringBuilder, file.vanilla, "  ");
			stringBuilder.Append(",\n  \"spots\": ");
			WriteSpotList(stringBuilder, file.spots, "  ");
			stringBuilder.Append("\n}");
			return stringBuilder.ToString();
		}

		public static SavedLootFile FromJson(string json)
		{
			SavedLootFile savedLootFile = new SavedLootFile
			{
				pools = new List<SavedPool>(),
				vanilla = new List<SavedPool>(),
				spots = new List<SavedSpotCount>()
			};
			if (string.IsNullOrWhiteSpace(json))
			{
				return savedLootFile;
			}
			Reader reader = new Reader(json);
			reader.SkipWs();
			reader.Expect('{');
			while (true)
			{
				reader.SkipWs();
				if (reader.TryConsume('}'))
				{
					break;
				}
				string text = reader.ReadString();
				reader.SkipWs();
				reader.Expect(':');
				reader.SkipWs();
				switch (text)
				{
				case "version":
					savedLootFile.version = reader.ReadInt();
					break;
				case "pools":
					savedLootFile.pools = ReadPoolList(reader);
					break;
				case "vanilla":
					savedLootFile.vanilla = ReadPoolList(reader);
					break;
				case "spots":
					savedLootFile.spots = ReadSpotList(reader);
					break;
				default:
					reader.SkipValue();
					break;
				}
				reader.SkipWs();
				reader.TryConsume(',');
			}
			return savedLootFile;
		}

		private static void WritePoolList(StringBuilder sb, List<SavedPool> list, string indent)
		{
			if (list == null || list.Count == 0)
			{
				sb.Append("[]");
				return;
			}
			sb.Append("[\n");
			for (int i = 0; i < list.Count; i++)
			{
				if (i > 0)
				{
					sb.Append(",\n");
				}
				WritePool(sb, list[i], indent + "  ");
			}
			sb.Append('\n').Append(indent).Append(']');
		}

		private static void WritePool(StringBuilder sb, SavedPool pool, string indent)
		{
			if (pool == null)
			{
				sb.Append(indent).Append("{}");
				return;
			}
			sb.Append(indent).Append("{\n");
			sb.Append(indent).Append("  \"pool\": ").Append(Quote(pool.pool))
				.Append(",\n");
			sb.Append(indent).Append("  \"weights\": [");
			if (pool.weights != null)
			{
				for (int i = 0; i < pool.weights.Count; i++)
				{
					SavedWeight savedWeight = pool.weights[i];
					if (savedWeight != null)
					{
						if (i > 0)
						{
							sb.Append(", ");
						}
						sb.Append("{\"id\": ").Append(savedWeight.id).Append(", \"weight\": ")
							.Append(savedWeight.weight)
							.Append('}');
					}
				}
			}
			sb.Append("],\n");
			sb.Append(indent).Append("  \"removed\": [");
			if (pool.removed != null)
			{
				for (int j = 0; j < pool.removed.Count; j++)
				{
					if (j > 0)
					{
						sb.Append(", ");
					}
					sb.Append(pool.removed[j]);
				}
			}
			sb.Append("],\n");
			sb.Append(indent).Append("  \"spawnCount\": ").Append(pool.spawnCount)
				.Append(",\n");
			sb.Append(indent).Append("  \"countValue\": ").Append(pool.countValue)
				.Append(",\n");
			sb.Append(indent).Append("  \"forceCount\": ").Append(pool.forceCount ? "true" : "false")
				.Append(",\n");
			sb.Append(indent).Append("  \"randomCount\": ").Append(pool.randomCount ? "true" : "false")
				.Append(",\n");
			sb.Append(indent).Append("  \"multiplier\": ").Append(pool.multiplier)
				.Append(",\n");
			sb.Append(indent).Append("  \"shareWithParty\": ").Append(pool.shareWithParty ? "true" : "false")
				.Append(",\n");
			sb.Append(indent).Append("  \"disableDuplicates\": ").Append(pool.disableDuplicates ? "true" : "false")
				.Append('\n');
			sb.Append(indent).Append('}');
		}

		private static void WriteSpotList(StringBuilder sb, List<SavedSpotCount> list, string indent)
		{
			if (list == null || list.Count == 0)
			{
				sb.Append("[]");
				return;
			}
			sb.Append("[\n");
			for (int i = 0; i < list.Count; i++)
			{
				SavedSpotCount savedSpotCount = list[i];
				if (i > 0)
				{
					sb.Append(",\n");
				}
				sb.Append(indent).Append("  {\"pool\": ").Append(Quote(savedSpotCount?.pool));
				sb.Append(", \"count\": ").Append(savedSpotCount?.count ?? 0).Append('}');
			}
			sb.Append('\n').Append(indent).Append(']');
		}

		private static List<SavedPool> ReadPoolList(Reader reader)
		{
			List<SavedPool> list = new List<SavedPool>();
			reader.Expect('[');
			while (true)
			{
				reader.SkipWs();
				if (reader.TryConsume(']'))
				{
					break;
				}
				list.Add(ReadPool(reader));
				reader.SkipWs();
				reader.TryConsume(',');
			}
			return list;
		}

		private static SavedPool ReadPool(Reader reader)
		{
			SavedPool savedPool = new SavedPool
			{
				weights = new List<SavedWeight>(),
				removed = new List<int>()
			};
			reader.Expect('{');
			while (true)
			{
				reader.SkipWs();
				if (reader.TryConsume('}'))
				{
					break;
				}
				string text = reader.ReadString();
				reader.SkipWs();
				reader.Expect(':');
				reader.SkipWs();
				switch (text)
				{
				case "pool":
					savedPool.pool = reader.ReadString();
					break;
				case "weights":
					savedPool.weights = ReadWeightList(reader);
					break;
				case "removed":
					savedPool.removed = ReadIntList(reader);
					break;
				case "spawnCount":
					savedPool.spawnCount = reader.ReadInt();
					break;
				case "countValue":
					savedPool.countValue = reader.ReadInt();
					break;
				case "forceCount":
					savedPool.forceCount = reader.ReadBool();
					break;
				case "randomCount":
					savedPool.randomCount = reader.ReadBool();
					break;
				case "multiplier":
					savedPool.multiplier = reader.ReadInt();
					break;
				case "shareWithParty":
					savedPool.shareWithParty = reader.ReadBool();
					break;
				case "disableDuplicates":
					savedPool.disableDuplicates = reader.ReadBool();
					break;
				default:
					reader.SkipValue();
					break;
				}
				reader.SkipWs();
				reader.TryConsume(',');
			}
			return savedPool;
		}

		private static List<SavedWeight> ReadWeightList(Reader reader)
		{
			List<SavedWeight> list = new List<SavedWeight>();
			reader.Expect('[');
			while (true)
			{
				reader.SkipWs();
				if (reader.TryConsume(']'))
				{
					break;
				}
				SavedWeight savedWeight = new SavedWeight();
				reader.Expect('{');
				while (true)
				{
					reader.SkipWs();
					if (reader.TryConsume('}'))
					{
						break;
					}
					string text = reader.ReadString();
					reader.SkipWs();
					reader.Expect(':');
					reader.SkipWs();
					if (text == "id")
					{
						savedWeight.id = reader.ReadInt();
					}
					else if (text == "weight")
					{
						savedWeight.weight = reader.ReadInt();
					}
					else
					{
						reader.SkipValue();
					}
					reader.SkipWs();
					reader.TryConsume(',');
				}
				list.Add(savedWeight);
				reader.SkipWs();
				reader.TryConsume(',');
			}
			return list;
		}

		private static List<SavedSpotCount> ReadSpotList(Reader reader)
		{
			List<SavedSpotCount> list = new List<SavedSpotCount>();
			reader.Expect('[');
			while (true)
			{
				reader.SkipWs();
				if (reader.TryConsume(']'))
				{
					break;
				}
				SavedSpotCount savedSpotCount = new SavedSpotCount();
				reader.Expect('{');
				while (true)
				{
					reader.SkipWs();
					if (reader.TryConsume('}'))
					{
						break;
					}
					string text = reader.ReadString();
					reader.SkipWs();
					reader.Expect(':');
					reader.SkipWs();
					if (text == "pool")
					{
						savedSpotCount.pool = reader.ReadString();
					}
					else if (text == "count")
					{
						savedSpotCount.count = reader.ReadInt();
					}
					else
					{
						reader.SkipValue();
					}
					reader.SkipWs();
					reader.TryConsume(',');
				}
				list.Add(savedSpotCount);
				reader.SkipWs();
				reader.TryConsume(',');
			}
			return list;
		}

		private static List<int> ReadIntList(Reader reader)
		{
			List<int> list = new List<int>();
			reader.Expect('[');
			while (true)
			{
				reader.SkipWs();
				if (reader.TryConsume(']'))
				{
					break;
				}
				list.Add(reader.ReadInt());
				reader.SkipWs();
				reader.TryConsume(',');
			}
			return list;
		}

		private static string Quote(string value)
		{
			if (value == null)
			{
				value = string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length + 8);
			stringBuilder.Append('"');
			foreach (char c in value)
			{
				if (c == '"' || c == '\\')
				{
					stringBuilder.Append('\\').Append(c);
					continue;
				}
				switch (c)
				{
				case '\n':
					stringBuilder.Append("\\n");
					break;
				case '\r':
					stringBuilder.Append("\\r");
					break;
				case '\t':
					stringBuilder.Append("\\t");
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
			stringBuilder.Append('"');
			return stringBuilder.ToString();
		}
	}
	internal static class PresetStore
	{
		public const string DefaultName = "default";

		private static string _folder;

		public static string FolderPath
		{
			get
			{
				EnsureFolder();
				return _folder;
			}
		}

		public static void Initialize()
		{
			EnsureFolder();
		}

		public static List<string> ListNames()
		{
			List<string> list = new List<string>();
			EnsureFolder();
			if (string.IsNullOrEmpty(_folder) || !Directory.Exists(_folder))
			{
				return list;
			}
			try
			{
				string[] files = Directory.GetFiles(_folder, "*.json");
				for (int i = 0; i < files.Length; i++)
				{
					list.Add(Path.GetFileNameWithoutExtension(files[i]));
				}
				list.Sort(StringComparer.OrdinalIgnoreCase);
				int num = list.FindIndex((string n) => IsDefaultName(n));
				if (num > 0)
				{
					string item = list[num];
					list.RemoveAt(num);
					list.Insert(0, item);
				}
			}
			catch (Exception ex)
			{
				Plugin.LogError("Failed to list presets: " + ex.Message);
			}
			return list;
		}

		public static bool Save(string name, out string error)
		{
			error = null;
			string text = Sanitize(name);
			if (string.IsNullOrEmpty(text))
			{
				error = "Type a name for this preset first.";
				return false;
			}
			EnsureFolder();
			if (string.IsNullOrEmpty(_folder))
			{
				error = "Could not create the Presets folder next to the plugin.";
				return false;
			}
			try
			{
				string text2 = Path.Combine(_folder, text + ".json");
				SavedLootFile savedLootFile = LootStore.ExportUserFile();
				File.WriteAllText(text2, LootJson.ToJson(savedLootFile));
				Plugin.LogInfo("Saved preset " + text + " (" + ((savedLootFile.pools != null) ? savedLootFile.pools.Count : 0) + " luggage) to " + text2);
				return true;
			}
			catch (Exception ex)
			{
				error = "Failed to save preset: " + ex.Message;
				Plugin.LogError(error);
				return false;
			}
		}

		public static bool Load(string name, out string error)
		{
			error = null;
			string text = Sanitize(name);
			if (string.IsNullOrEmpty(text))
			{
				error = "Pick a preset to load.";
				return false;
			}
			EnsureFolder();
			string text2 = Path.Combine(_folder ?? string.Empty, text + ".json");
			if (!File.Exists(text2))
			{
				error = "No preset named \"" + text + "\".";
				return false;
			}
			try
			{
				SavedLootFile file = LootJson.FromJson(File.ReadAllText(text2));
				if (!LootJson.HasData(file))
				{
					error = "Preset \"" + text + "\" is empty.";
					return false;
				}
				LootStore.ApplyUserFile(file);
				Plugin.LogDebug("Loaded preset " + text + " from " + text2);
				return true;
			}
			catch (Exception ex)
			{
				error = "Failed to load preset: " + ex.Message;
				Plugin.LogError(error);
				return false;
			}
		}

		public static bool SaveDefault()
		{
			string error;
			return Save("default", out error);
		}

		public static void SaveDefaultQuiet()
		{
			try
			{
				EnsureFolder();
				if (!string.IsNullOrEmpty(_folder))
				{
					SavedLootFile file = LootStore.ExportUserFile();
					if (LootJson.HasData(file))
					{
						File.WriteAllText(Path.Combine(_folder, "default.json"), LootJson.ToJson(file));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.LogError("Failed to save default preset: " + ex.Message);
			}
		}

		public static bool TryLoadDefault()
		{
			EnsureFolder();
			string path = Path.Combine(_folder ?? string.Empty, "default.json");
			if (!File.Exists(path))
			{
				return false;
			}
			try
			{
				SavedLootFile file = LootJson.FromJson(File.ReadAllText(path));
				if (!LootJson.HasData(file))
				{
					return false;
				}
				LootStore.ApplyUserFile(file);
				Plugin.LogInfo("Loaded last-used luggage settings from the default preset.");
				return true;
			}
			catch (Exception ex)
			{
				Plugin.LogError("Failed to load the default preset: " + ex.Message);
				return false;
			}
		}

		public static bool IsDefaultName(string name)
		{
			return string.Equals(Sanitize(name), "default", StringComparison.OrdinalIgnoreCase);
		}

		public static bool Delete(string name, out string error)
		{
			error = null;
			string text = Sanitize(name);
			if (string.IsNullOrEmpty(text))
			{
				error = "Pick a preset to delete.";
				return false;
			}
			if (IsDefaultName(text))
			{
				error = "The default preset is updated automatically when you close the menu.";
				return false;
			}
			EnsureFolder();
			string path = Path.Combine(_folder ?? string.Empty, text + ".json");
			if (!File.Exists(path))
			{
				error = "No preset named \"" + text + "\".";
				return false;
			}
			try
			{
				File.Delete(path);
				return true;
			}
			catch (Exception ex)
			{
				error = "Failed to delete preset: " + ex.Message;
				Plugin.LogError(error);
				return false;
			}
		}

		public static string Sanitize(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return string.Empty;
			}
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			char[] array = name.Trim().ToCharArray();
			for (int i = 0; i < array.Length; i++)
			{
				char c = array[i];
				bool flag = c < ' ';
				if (!flag)
				{
					for (int j = 0; j < invalidFileNameChars.Length; j++)
					{
						if (c == invalidFileNameChars[j])
						{
							flag = true;
							break;
						}
					}
				}
				if (flag)
				{
					array[i] = '_';
				}
			}
			string text = new string(array).Trim();
			if (text.Length > 40)
			{
				text = text.Substring(0, 40).Trim();
			}
			return text;
		}

		private static void EnsureFolder()
		{
			if (!string.IsNullOrEmpty(_folder) && Directory.Exists(_folder))
			{
				return;
			}
			try
			{
				string location = typeof(Plugin).Assembly.Location;
				string text = (string.IsNullOrEmpty(location) ? null : Path.GetDirectoryName(location));
				if (string.IsNullOrEmpty(text))
				{
					text = Paths.PluginPath;
				}
				_folder = Path.Combine(text, "Presets");
				Directory.CreateDirectory(_folder);
			}
			catch (Exception ex)
			{
				Plugin.LogError("Failed to create Presets folder: " + ex.Message);
			}
		}
	}
	internal static class LuggageSpawnPatches
	{
		[HarmonyPatch(typeof(LootData), "GetRandomItems")]
		private static class Patch_GetRandomItems
		{
			private static void Postfix(SpawnPool spawnPool, int count, ref List<GameObject> __result)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				if ((int)spawnPool != 0 && LootStore.GetDisableDuplicates(spawnPool))
				{
					HashSet<ushort> used = _activeUniqueUsed ?? new HashSet<ushort>();
					__result = ReplaceWithUniquePrefabs(spawnPool, count, used);
					_replacedThisGetObjectsCall = true;
				}
			}
		}

		[HarmonyPatch(typeof(Spawner), "GetObjectsToSpawn")]
		private static class Patch_GetObjectsToSpawn
		{
			private unsafe static void Prefix(Spawner __instance, int spawnCount, ref bool canRepeat)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Invalid comparison between Unknown and I4
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				_replacedThisGetObjectsCall = false;
				Luggage val = (Luggage)(object)((__instance is Luggage) ? __instance : null);
				if (val == null)
				{
					return;
				}
				SpawnPool val2 = ResolvePool(val);
				bool flag = canRepeat;
				if ((int)val2 > 0)
				{
					if (LootStore.GetDisableDuplicates(val2))
					{
						canRepeat = false;
						_activeUniqueUsed = GetUsedItemIds(val);
					}
					else if (LootStore.ShouldAllowRepeats(val2, spawnCount))
					{
						canRepeat = true;
					}
				}
				Plugin.LogTrace("GetObjectsToSpawn Prefix count=" + spawnCount + " canRepeat " + flag + " -> " + canRepeat + " pool=" + ((object)(*(SpawnPool*)(&val2))/*cast due to .constrained prefix*/).ToString());
			}

			private static void Postfix(Spawner __instance, int spawnCount, ref List<GameObject> __result)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: 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)
				Luggage val = (Luggage)(object)((__instance is Luggage) ? __instance : null);
				if (val != null)
				{
					SpawnPool val2 = ResolvePool(val);
					if ((int)val2 != 0 && LootStore.GetDisableDuplicates(val2) && (!_replacedThisGetObjectsCall || HasDuplicateItemIds(__result)))
					{
						__result = ReplaceWithUniquePrefabs(val2, spawnCount, GetUsedItemIds(val));
					}
				}
			}
		}

		[HarmonyPatch(typeof(Spawner), "GetSpawnSpots")]
		private static class Patch_GetSpawnSpots
		{
			private unsafe static void Postfix(Spawner __instance, ref List<Transform> __result)
			{
				//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_006d: Unknown result type (might be due to invalid IL or missing references)
				Luggage val = (Luggage)(object)((__instance is Luggage) ? __instance : null);
				if (val != null)
				{
					SpawnPool pool = ResolvePool(val);
					int num = ((__result != null) ? __result.Count : 0);
					int wanted = GetWanted(val, __result);
					Plugin.LogTrace("GetSpawnSpots have=" + num + " wanted=" + wanted + " override=" + LootStore.HasSpawnCountOverride(pool) + " pool=" + ((object)(*(SpawnPool*)(&pool))/*cast due to .constrained prefix*/).ToString());
				}
			}
		}

		[HarmonyPatch(typeof(Spawner), "SpawnItems")]
		private static class Patch_SpawnItems
		{
			private static void Prefix(Spawner __instance, ref List<Transform> spawnSpots)
			{
				//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_007f: Unknown result type (might be due to invalid IL or missing references)
				Luggage val = (Luggage)(object)((__instance is Luggage) ? __instance : null);
				if (val != null)
				{
					SpawnPool pool = ResolvePool(val);
					BeginUniquePicks(val);
					_activeUniqueUsed = GetUsedItemIds(val);
					int num = ((spawnSpots != null) ? spawnSpots.Count : 0);
					int wanted = GetWanted(val, spawnSpots);
					Plugin.LogTrace("SpawnItems Prefix have=" + num + " wanted=" + wanted + " override=" + LootStore.HasSpawnCountOverride(pool) + " " + DebugDump.HostLine());
				}
			}

			private static void Postfix(Spawner __instance, List<Transform> spawnSpots, ref List<PhotonView> __result)
			{
				Luggage val = (Luggage)(object)((__instance is Luggage) ? __instance : null);
				if (val != null)
				{
					if (__result == null)
					{
						__result = new List<PhotonView>();
					}
					int wanted = GetWanted(val, spawnSpots);
					Plugin.LogTrace("SpawnItems Postfix vanillaResult=" + __result.Count + " wanted=" + wanted);
					FillToWanted(val, __result, wanted);
					ApplyPartyShare(val, __result);
					RememberFilled(val, __result.Count);
					Plugin.LogTrace("SpawnItems Postfix final=" + __result.Count);
				}
			}
		}

		[HarmonyPatch(typeof(SpawnedItemTracker), "SpawnAndTrackFromItemHistory")]
		private static class Patch_SpawnFromHistory
		{
			private static void Prefix(SpawnedItemTracker __instance)
			{
				if (!((Object)(object)__instance == (Object)null))
				{
					BeginUniquePicks(((Component)__instance).GetComponent<Luggage>());
				}
			}

			private unsafe static void Postfix(SpawnedItemTracker __instance, ref List<PhotonView> __result)
			{
				//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_0089: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null)
				{
					return;
				}
				Luggage component = ((Component)__instance).GetComponent<Luggage>();
				Plugin.LogTrace("SpawnAndTrackFromItemHistory result=" + ((__result != null) ? __result.Count : 0) + " luggage=" + (((Object)(object)component != (Object)null) ? ((Object)component).name : "null"));
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				SpawnPool val = ResolvePool(component);
				Plugin.LogTrace("history pool=" + ((object)(*(SpawnPool*)(&val))/*cast due to .constrained prefix*/).ToString() + " override=" + LootStore.HasSpawnCountOverride(val));
				if ((int)val != 0 && LootStore.HasSpawnCountOverride(val))
				{
					if (__result == null)
					{
						__result = new List<PhotonView>();
					}
					FillToWanted(component, __result, GetWanted(component, GameAccess.GetSpawnSpotList((Spawner)(object)component)));
					ApplyPartyShare(component, __result);
					RememberFilled(component, __result.Count);
					Plugin.LogTrace("history final=" + __result.Count);
				}
			}
		}

		private const string AnchorRootName = "PLI_ExtraSpots";

		private const float NearbyItemRadius = 1.6f;

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

		private static readonly Dictionary<int, HashSet<ushort>> _usedItemIds = new Dictionary<int, HashSet<ushort>>();

		private static HashSet<ushort> _activeUniqueUsed;

		private static bool _replacedThisGetObjectsCall;

		internal static void ClearOpenState()
		{
			_filledCount.Clear();
			_usedItemIds.Clear();
			_activeUniqueUsed = null;
			_replacedThisGetObjectsCall = false;
		}

		private static void BeginUniquePicks(Luggage luggage)
		{
			if (!((Object)(object)luggage == (Object)null))
			{
				_usedItemIds[((Object)luggage).GetInstanceID()] = new HashSet<ushort>();
			}
		}

		private static HashSet<ushort> GetUsedItemIds(Luggage luggage)
		{
			if ((Object)(object)luggage == (Object)null)
			{
				return new HashSet<ushort>();
			}
			int instanceID = ((Object)luggage).GetInstanceID();
			if (!_usedItemIds.TryGetValue(instanceID, out var value) || value == null)
			{
				value = new HashSet<ushort>();
				_usedItemIds[instanceID] = value;
			}
			return value;
		}

		internal static void HandleOpened(Luggage luggage, Character interactor)
		{
			if (!((Object)(object)luggage == (Object)null) && !((Object)(object)Plugin.Instance == (Object)null))
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(FillAfterOpen(luggage));
			}
		}

		private unsafe static IEnumerator FillAfterOpen(Luggage luggage)
		{
			yield return (object)new WaitForSeconds(0.2f);
			if ((Object)(object)luggage == (Object)null)
			{
				yield break;
			}
			if (!IsSpawnHost())
			{
				Plugin.LogTrace("FillAfterOpen skip not host. " + DebugDump.HostLine());
				yield break;
			}
			SpawnPool pool = ResolvePool(luggage);
			if ((int)pool == 0 || !LootStore.HasSpawnCountOverride(pool))
			{
				Plugin.LogTrace("FillAfterOpen no count override pool=" + ((object)(*(SpawnPool*)(&pool))/*cast due to .constrained prefix*/).ToString());
				yield break;
			}
			int maxSpots = CountVanillaSpots(luggage);
			int wanted = LootStore.GetWantedSpawnCount(pool, maxSpots, maxSpots);
			int have = CountExistingSpawns(luggage);
			Plugin.LogTrace("FillAfterOpen " + LuggageCatalog.GetDisplayName(pool) + " have=" + have + " wanted=" + wanted + " " + DebugDump.HostLine());
			if (wanted > have)
			{
				List<PhotonView> seeded = new List<PhotonView>(wanted);
				for (int i = 0; i < have; i++)
				{
					seeded.Add(null);
				}
				FillToWanted(luggage, seeded, wanted);
				ApplyPartyShare(luggage, seeded);
				RememberFilled(luggage, have + CountNonNull(seeded));
			}
		}

		private static void RememberFilled(Luggage luggage, int count)
		{
			if (!((Object)(object)luggage == (Object)null) && count > 0)
			{
				int instanceID = ((Object)luggage).GetInstanceID();
				if (!_filledCount.TryGetValue(instanceID, out var value) || value < count)
				{
					_filledCount[instanceID] = count;
				}
			}
		}

		private static int CountExistingSpawns(Luggage luggage)
		{
			int num = 0;
			try
			{
				num = GameAccess.GetTrackedSpawnCount(((Component)luggage).GetComponent<SpawnedItemTracker>());
			}
			catch
			{
			}
			int value = 0;
			if ((Object)(object)luggage != (Object)null)
			{
				_filledCount.TryGetValue(((Object)luggage).GetInstanceID(), out value);
			}
			int num2 = CountNearbyItems(luggage);
			int num3 = num;
			if (value > num3)
			{
				num3 = value;
			}
			if (num2 > num3)
			{
				num3 = num2;
			}
			Plugin.LogTrace("CountExisting tracked=" + num + " remembered=" + value + " nearby=" + num2);
			return num3;
		}

		private static int CountNearbyItems(Luggage luggage)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)luggage == (Object)null)
			{
				return 0;
			}
			Vector3 val;
			try
			{
				val = luggage.Center();
			}
			catch
			{
				val = ((Component)luggage).transform.position;
			}
			Item[] array = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
			if (array == null)
			{
				return 0;
			}
			float num = 2.5600002f;
			int num2 = 0;
			foreach (Item val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Vector3 val3 = ((Component)val2).transform.position - val;
					if (((Vector3)(ref val3)).sqrMagnitude <= num)
					{
						num2++;
					}
				}
			}
			return num2;
		}

		private static int CountNonNull(List<PhotonView> views)
		{
			if (views == null)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < views.Count; i++)
			{
				if ((Object)(object)views[i] != (Object)null)
				{
					num++;
				}
			}
			return num;
		}

		internal unsafe static SpawnPool ResolvePool(Luggage luggage)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Invalid comparison between Unknown and I4
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: 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_011d: 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_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 ((Object)(object)luggage == (Object)null)
			{
				return (SpawnPool)0;
			}
			SpawnPool val = GameAccess.InvokeGetSpawnPool((Spawner)(object)luggage);
			if (LuggageCatalog.IsLuggagePool(val))
			{
				return val;
			}
			SpawnPool spawnerPool = GameAccess.GetSpawnerPool((Spawner)(object)luggage);
			if (LuggageCatalog.IsLuggagePool(spawnerPool))
			{
				return spawnerPool;
			}
			string text = string.Empty;
			bool flag = false;
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				text = ((Scene)(ref activeScene)).name;
				flag = ((Component)luggage).gameObject.scene == activeScene;
			}
			catch
			{
			}
			SpawnPool val2 = (SpawnPool)0;
			if (flag)
			{
				val2 = LuggageCatalog.GuessPoolFromWorld(((Object)luggage).name, text);
			}
			if ((int)val2 > 0)
			{
				Plugin.LogTrace("ResolvePool " + ((Object)luggage).name + " scene=" + text + " invoke=" + ((object)(*(SpawnPool*)(&val))/*cast due to .constrained prefix*/).ToString() + " field=" + ((object)(*(SpawnPool*)(&spawnerPool))/*cast due to .constrained prefix*/).ToString() + " -> " + ((object)(*(SpawnPool*)(&val2))/*cast due to .constrained prefix*/).ToString());
				return val2;
			}
			Plugin.LogTrace("ResolvePool failed " + ((Object)luggage).name + " scene=" + text + " invoke=" + ((object)(*(SpawnPool*)(&val))/*cast due to .constrained prefix*/).ToString() + " field=" + ((object)(*(SpawnPool*)(&spawnerPool))/*cast due to .constrained prefix*/).ToString());
			return (SpawnPool)0;
		}

		internal static void DiscoverVanillaSpotCounts()
		{
			//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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Luggage[] array = Resources.FindObjectsOfTypeAll<Luggage>();
				if (array == null)
				{
					return;
				}
				foreach (Luggage val in array)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					SpawnPool val2 = ResolvePool(val);
					if ((int)val2 != 0)
					{
						int num = CountVanillaSpots(val);
						if (num > 0)
						{
							LootStore.RememberVanillaSpots(val2, num);
						}
					}
				}
			}
			catch
			{
			}
		}

		internal static int CountVanillaSpots(Luggage luggage)
		{
			int num = CountSpotList(GameAccess.GetSpawnSpotList((Spawner)(object)luggage));
			try
			{
				IList weightedSpotLists = GameAccess.GetWeightedSpotLists((Spawner)(object)luggage);
				if (weightedSpotLists != null)
				{
					for (int i = 0; i < weightedSpotLists.Count; i++)
					{
						object obj = weightedSpotLists[i];
						if (obj != null)
						{
							num = Mathf.Max(num, CountSpotList(GameAccess.GetEntrySpawnSpots(obj)));
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		private static int CountSpotList(List<Transform> spots)
		{
			if (spots == null)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < spots.Count; i++)
			{
				Transform val = spots[i];
				if (!((Object)(object)val == (Object)null) && (!((Object)(object)val.parent != (Object)null) || !(((Object)val.parent).name == "PLI_ExtraSpots")))
				{
					num++;
				}
			}
			return num;
		}

		private static List<Transform> GetLongestSpotList(Luggage luggage, List<Transform> fallback)
		{
			List<Transform> list = fallback;
			int num = CountSpotList(fallback);
			List<Transform> spawnSpotList = GameAccess.GetSpawnSpotList((Spawner)(object)luggage);
			int num2 = CountSpotList(spawnSpotList);
			if (num2 > num)
			{
				list = spawnSpotList;
				num = num2;
			}
			try
			{
				IList weightedSpotLists = GameAccess.GetWeightedSpotLists((Spawner)(object)luggage);
				if (weightedSpotLists != null)
				{
					for (int i = 0; i < weightedSpotLists.Count; i++)
					{
						object obj = weightedSpotLists[i];
						if (obj != null)
						{
							List<Transform> entrySpawnSpots = GameAccess.GetEntrySpawnSpots(obj);
							int num3 = CountSpotList(entrySpawnSpots);
							if (num3 > num)
							{
								list = entrySpawnSpots;
								num = num3;
							}
						}
					}
				}
			}
			catch
			{
			}
			return list ?? fallback ?? new List<Transform>();
		}

		internal static int GetRoomPlayerCount()
		{
			try
			{
				if (PhotonNetwork.InRoom && PhotonNetwork.CurrentRoom != null)
				{
					return Mathf.Max(1, PhotonNetwork.CurrentRoom.PlayerCount);
				}
				if (PhotonNetwork.PlayerList != null && PhotonNetwork.PlayerList.Length != 0)
				{
					return PhotonNetwork.PlayerList.Length;
				}
			}
			catch
			{
			}
			return 1;
		}

		internal static List<Transform> BuildSpots(Luggage luggage, List<Transform> original, int wanted)
		{
			List<Transform> list = new List<Transform>(Mathf.Max(0, wanted));
			if (wanted <= 0)
			{
				return list;
			}
			int num = original?.Count ?? 0;
			int num2 = Mathf.Min(num, wanted);
			for (int i = 0; i < num2; i++)
			{
				if ((Object)(object)original[i] != (Object)null)
				{
					list.Add(original[i]);
				}
			}
			int num3 = wanted - list.Count;
			if (num3 <= 0 || (Object)(object)luggage == (Object)null)
			{
				return list;
			}
			List<Transform> list2 = new List<Transform>(list.Count);
			for (int j = 0; j < list.Count; j++)
			{
				if ((Object)(object)list[j] != (Object)null)
				{
					list2.Add(list[j]);
				}
			}
			Transform orCreateAnchorRoot = GetOrCreateAnchorRoot(luggage);
			for (int k = 0; k < num3; k++)
			{
				Transform orCreateAnchor = GetOrCreateAnchor(orCreateAnchorRoot, k);
				PlaceOnVanillaSpot(luggage, orCreateAnchor, k, list2);
				list.Add(orCreateAnchor);
			}
			return list;
		}

		private static Transform GetOrCreateAnchorRoot(Luggage luggage)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)luggage).transform.Find("PLI_ExtraSpots");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			GameObject val2 = new GameObject("PLI_ExtraSpots");
			val2.transform.SetParent(((Component)luggage).transform, false);
			val2.transform.localPosition = Vector3.zero;
			val2.transform.localRotation = Quaternion.identity;
			return val2.transform;
		}

		private static Transform GetOrCreateAnchor(Transform root, int index)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			string text = "Spot_" + index;
			Transform val = root.Find(text);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			GameObject val2 = new GameObject(text);
			val2.transform.SetParent(root, false);
			return val2.transform;
		}

		private static void PlaceOnVanillaSpot(Luggage luggage, Transform anchor, int extraIndex, List<Transform> vanillaSpots)
		{
			//IL_004f: 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_0033: 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)
			Transform val = null;
			if (vanillaSpots != null && vanillaSpots.Count > 0)
			{
				val = vanillaSpots[extraIndex % vanillaSpots.Count];
			}
			if ((Object)(object)val != (Object)null)
			{
				anchor.position = val.position;
				anchor.rotation = val.rotation;
			}
			else
			{
				anchor.position = luggage.Center();
				anchor.rotation = ((Component)luggage).transform.rotation;
			}
		}

		private static Transform GetVanillaSpot(Luggage luggage, int index)
		{
			List<Transform> longestSpotList = GetLongestSpotList(luggage, GameAccess.GetSpawnSpotList((Spawner)(object)luggage));
			if (longestSpotList == null || longestSpotList.Count == 0)
			{
				return null;
			}
			return longestSpotList[index % longestSpotList.Count];
		}

		private static PhotonView SpawnCopy(Luggage luggage, Item source, int copyIndex)
		{
			//IL_006f: 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_0074: 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_0084: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			Item val = null;
			try
			{
				ItemDatabase.TryGetItem(source.itemID, ref val);
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
			{
				return null;
			}
			Transform vanillaSpot = GetVanillaSpot(luggage, copyIndex);
			Vector3 val2 = (((Object)(object)vanillaSpot != (Object)null) ? vanillaSpot.position : luggage.Center());
			Quaternion val3 = (((Object)(object)vanillaSpot != (Object)null) ? vanillaSpot.rotation : ((Component)luggage).transform.rotation);
			GameObject val4 = null;
			try
			{
				val4 = PhotonNetwork.InstantiateItemRoom(((Object)((Component)val).gameObject).name, val2, val3);
			}
			catch (Exception ex)
			{
				Plugin.LogDebug("Party-share spawn failed: " + ex.Message);
				return null;
			}
			if ((Object)(object)val4 == (Object)null)
			{
				return null;
			}
			Item component = val4.GetComponent<Item>();
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			GameAccess.InvokeOffsetSpawn((Spawner)(object)luggage, component);
			GameAccess.InvokeInitializePhysics((Spawner)(object)luggage, component);
			return ((Component)component).GetComponent<PhotonView>();
		}

		private static bool IsSpawnHost()
		{
			try
			{
				if (NetCode.Session.IsHost)
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				if (PhotonNetwork.IsMasterClient)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static int GetWanted(Luggage luggage, List<Transform> spots)
		{
			//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_000a: Invalid comparison between Unknown and I4
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			SpawnPool val = ResolvePool(luggage);
			if ((int)val == 0)
			{
				return spots?.Count ?? 0;
			}
			int num = CountVanillaSpots(luggage);
			if (num <= 0 && spots != null)
			{
				num = CountSpotList(spots);
			}
			if (num > 0)
			{
				LootStore.RememberVanillaSpots(val, num);
			}
			return LootStore.GetWantedSpawnCount(val, num, num);
		}

		private static PhotonView SpawnOne(Luggage luggage, GameObject prefab, Transform spot, int index, int total)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if ((Object)(object)prefab == (Object)null || (Object)(object)luggage == (Object)null)
			{
				return null;
			}
			Vector3 val;
			Quaternion rotation;
			if ((Object)(object)spot != (Object)null)
			{
				val = spot.position;
				rotation = spot.rotation;
			}
			else
			{
				val = luggage.Center();
				rotation = ((Component)luggage).transform.rotation;
			}
			GameObject val2 = null;
			try
			{
				string text = (((Object)(object)prefab.gameObject != (Object)null) ? ((Object)prefab.gameObject).name : ((Object)prefab).name);
				val2 = PhotonNetwork.InstantiateItemRoom(text, val, rotation);
			}
			catch (Exception ex)
			{
				Plugin.LogDebug("Spawn failed: " + ex.Message);
				return null;
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			Item component = val2.GetComponent<Item>();
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			try
			{
				if (Object.op_Implicit((Object)(object)((Spawner)luggage).spawnUpTowardsTarget))
				{
					Transform transform = ((Component)component).transform;
					Vector3 val3 = ((Spawner)luggage).spawnUpTowardsTarget.position - ((Component)component).transform.position;
					transform.up = ((Vector3)(ref val3)).normalized;
				}
			}
			catch
			{
			}
			try
			{
				if (((Spawner)luggage).centerItemsVisually && (Object)(object)spot != (Object)null)
				{
					Transform transform2 = ((Component)component).transform;
					transform2.position += spot.position - component.Center();
				}
			}
			catch
			{
			}
			GameAccess.InvokeOffsetSpawn((Spawner)(object)luggage, component);
			GameAccess.InvokeInitializePhysics((Spawner)(object)luggage, component);
			return ((Component)component).GetComponent<PhotonView>();
		}

		private static void FillToWanted(Luggage luggage, List<PhotonView> result, int wanted)
		{
			//IL_012c: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)luggage == (Object)null)
			{
				Plugin.LogTrace("FillToWanted abort luggage=null");
				return;
			}
			if (result == null)
			{
				Plugin.LogTrace("FillToWanted abort result=null");
				return;
			}
			if (!IsSpawnHost())
			{
				Plugin.LogTrace("FillToWanted abort not host. " + DebugDump.HostLine() + " have=" + result.Count + " wanted=" + wanted);
				return;
			}
			if (wanted <= result.Count)
			{
				Plugin.LogTrace("FillToWanted skip already have " + result.Count + " >= wanted " + wanted);
				return;
			}
			Plugin.LogTrace("FillToWanted start have=" + result.Count + " wanted=" + wanted + " " + DebugDump.HostLine());
			SpawnPool val = ResolvePool(luggage);
			List<Transform> list = BuildSpots(luggage, GetLongestSpotList(luggage, GameAccess.GetSpawnSpotList((Spawner)(object)luggage)), wanted);
			bool canRepeat = (int)val != 0 && LootStore.ShouldAllowRepeats(val, wanted);
			int count = result.Count;
			if (result.Count == 0)
			{
				List<GameObject> list2 = null;
				list2 = GameAccess.InvokeGetObjectsToSpawn((Spawner)(object)luggage, wanted, canRepeat);
				if (list2 != null)
				{
					for (int i = 0; i < list2.Count; i++)
					{
						if (result.Count >= wanted)
						{
							break;
						}
						Transform spot = ((result.Count < list.Count) ? list[result.Count] : null);
						PhotonView val2 = SpawnOne(luggage, list2[i], spot, result.Count, wanted);
						if ((Object)(object)val2 != (Object)null)
						{
							result.Add(val2);
						}
					}
				}
			}
			int num = 0;
			while (result.Count < wanted && num++ < wanted)
			{
				List<GameObject> list3 = null;
				list3 = GameAccess.InvokeGetObjectsToSpawn((Spawner)(object)luggage, 1, canRepeat);
				if (list3 == null || list3.Count == 0 || (Object)(object)list3[0] == (Object)null)
				{
					break;
				}
				Transform spot2 = ((result.Count < list.Count) ? list[result.Count] : null);
				PhotonView val3 = SpawnOne(luggage, list3[0], spot2, result.Count, wanted);
				if ((Object)(object)val3 == (Object)null)
				{
					break;
				}
				result.Add(val3);
			}
			Plugin.LogTrace("FillToWanted done " + LuggageCatalog.GetDisplayName(val) + " " + count + " -> " + result.Count + " / wanted " + wanted + " repeats=" + canRepeat);
		}

		private static void ApplyPartyShare(Luggage luggage, List<PhotonView> result)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)luggage == (Object)null || result == null || result.Count == 0)
			{
				return;
			}
			SpawnPool val = ResolvePool(luggage);
			if ((int)val == 0 || !LootStore.GetShareWithParty(val))
			{
				return;
			}
			int num = GetRoomPlayerCount() - 1;
			if (num <= 0)
			{
				return;
			}
			int count = result.Count;
			if (num <= 0)
			{
				return;
			}
			List<PhotonView> list = new List<PhotonView>(count * num);
			for (int i = 0; i < count; i++)
			{
				PhotonView val2 = result[i];
				Item val3 = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<Item>() : null);
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				for (int j = 0; j < num; j++)
				{
					PhotonView val4 = SpawnCopy(luggage, val3, i * num + j);
					if ((Object)(object)val4 != (Object)null)
					{
						list.Add(val4);
					}
				}
			}
			for (int k = 0; k < list.Count; k++)
			{
				result.Add(list[k]);
			}
			Plugin.LogDebug(LuggageCatalog.GetDisplayName(val) + " party share: " + count + " item(s) x" + (num + 1) + " players = " + result.Count + " on the ground.");
		}

		private static bool TryGetPrefabItemId(GameObject prefab, out ushort id)
		{
			id = 0;
			if ((Object)(object)prefab == (Object)null)
			{
				return false;
			}
			Item component = prefab.GetComponent<Item>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			id = component.itemID;
			return true;
		}

		private static bool HasDuplicateItemIds(List<GameObject> objects)
		{
			if (objects == null || objects.Count < 2)
			{
				return false;
			}
			HashSet<ushort> hashSet = new HashSet<ushort>();
			for (int i = 0; i < objects.Count; i++)
			{
				if (TryGetPrefabItemId(objects[i], out var id) && !hashSet.Add(id))
				{
					return true;
				}
			}
			return false;
		}

		private unsafe static List<GameObject> ReplaceWithUniquePrefabs(SpawnPool pool, int count, HashSet<ushort> used)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> list = LootStore.PickPrefabsNoDuplicates(pool, count, used);
			Plugin.LogTrace("no-dupe pick count=" + (list?.Count ?? 0) + " pool=" + ((object)(*(SpawnPool*)(&pool))/*cast due to .constrained prefix*/).ToString());
			return list;
		}
	}
	internal static class DebugDump
	{
		[HarmonyPatch(typeof(Luggage), "OpenLuggageRPC")]
		private static class Patch_OpenLuggageRPC
		{
			private static void Prefix(Luggage __instance, bool spawnItems)
			{
				try
				{
					LogLuggage("OpenLuggageRPC Prefix spawnItems=" + spawnItems, __instance);
				}
				catch (Exception ex)
				{
					Plugin.LogTrace("OpenLuggageRPC Prefix log failed: " + ex.Message);
				}
			}

			private static void Postfix(Luggage __instance, bool spawnItems)
			{
				try
				{
					LogLuggage("OpenLuggageRPC Postfix spawnItems=" + spawnItems, __instance);
				}
				catch (Exception ex)
				{
					Plugin.LogTrace("OpenLuggageRPC Postfix log failed: " + ex.Message);
				}
			}
		}

		private static bool _hookedOpen;

		internal static void Initialize()
		{
			if (_hookedOpen)
			{
				return;
			}
			try
			{
				GlobalEvents.OnLuggageOpened = (Action<Luggage, Character>)Delegate.Combine(GlobalEvents.OnLuggageOpened, new Action<Luggage, Character>(LuggageSpawnPatches.HandleOpened));
				GlobalEvents.OnLuggageOpened = (Action<Luggage, Character>)Delegate.Combine(GlobalEvents.OnLuggageOpened, new Action<Luggage, Character>(OnLuggageOpened));
				_hookedOpen = true;
			}
			catch (Exception ex)
			{
				Plugin.LogError("Failed to hook GlobalEvents.OnLuggageOpened: " + ex.Message);
			}
		}

		internal static void Shutdown()
		{
			if (_hookedOpen)
			{
				try
				{
					GlobalEvents.OnLuggageOpened = (Action<Luggage, Character>)Delegate.Remove(GlobalEvents.OnLuggageOpened, new Action<Luggage, Character>(OnLuggageOpened));
				}
				catch
				{
				}
				try
				{
					GlobalEvents.OnLuggageOpened = (Action<Luggage, Character>)Delegate.Remove(GlobalEvents.OnLuggageOpened, new Action<Luggage, Character>(LuggageSpawnPatches.HandleOpened));
				}
				catch
				{
				}
				_hookedOpen = false;
			}
		}

		internal static void DumpEverything(string reason)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsDebug)
			{
				return;
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder(2048);
				stringBuilder.AppendLine("======== PLI DEBUG DUMP (" + reason + ") ========");
				stringBuilder.AppendLine("version=3.0.0");
				Scene activeScene = SceneManager.GetActiveScene();
				stringBuilder.AppendLine("scene=" + ((Scene)(ref activeScene)).name + " time=" + Time.time.ToString("0.00"));
				stringBuilder.AppendLine("menuOpen=" + LuggageMenu.IsOpen);
				stringBuilder.AppendLine(HostLine());
				stringBuilder.AppendLine("items=" + ItemCatalog.Count + " ready=" + ItemCatalog.IsReady + " luggagePools=" + LuggageCatalog.Count + " vanillaSnapshot=" + LootStore.HasVanillaSnapshot);
				stringBuilder.AppendLine(LootStore.DebugDescribeAllPools());
				Plugin.LogInfo(stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				Plugin.LogError("Debug dump failed: " + ex);
			}
		}

		internal static string HostLine()
		{
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			int num = 1;
			string text = string.Empty;
			try
			{
				flag = PhotonNetwork.InRoom;
			}
			catch (Exception ex)
			{
				text = text + " inRoom=" + ex.Message;
			}
			try
			{
				flag2 = PhotonNetwork.IsMasterClient;
			}
			catch (Exception ex2)
			{
				text = text + " master=" + ex2.Message;
			}
			try
			{
				flag3 = NetCode.Session.IsHost;
			}
			catch (Exception ex3)
			{
				text = text + " isHost=" + ex3.Message;
			}
			try
			{
				num = LuggageSpawnPatches.GetRoomPlayerCount();
			}
			catch
			{
			}
			return "inRoom=" + flag + " IsMasterClient=" + flag2 + " NetCode.IsHost=" + flag3 + " players=" + num + text;
		}

		internal unsafe static void LogLuggage(string where, Luggage luggage, string extra = null)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsDebug)
			{
				return;
			}
			try
			{
				if ((Object)(object)luggage == (Object)null)
				{
					Plugin.LogTrace(where + " luggage=null " + extra);
					return;
				}
				SpawnPool pool = LuggageSpawnPatches.ResolvePool(luggage);
				PoolSpawnSettings spawnSettings = LootStore.GetSpawnSettings(pool);
				int thisOpenSpots = 0;
				int instanceMax = 0;
				bool flag = false;
				int num = 0;
				try
				{
					thisOpenSpots = GameAccess.GetSpawnSpotList((Spawner)(object)luggage)?.Count ?? 0;
				}
				catch
				{
				}
				try
				{
					instanceMax = LuggageSpawnPatches.CountVanillaSpots(luggage);
				}
				catch
				{
				}
				try
				{
					SpawnedItemTracker component = ((Component)luggage).GetComponent<SpawnedItemTracker>();
					if ((Object)(object)component != (Object)null)
					{
						flag = component.HasSpawnHistory;
						num = GameAccess.GetHistoryCount(component);
					}
				}
				catch (Exception ex)
				{
					Plugin.LogTrace(where + " tracker read failed: " + ex.Message);
				}
				int wantedSpawnCount = LootStore.GetWantedSpawnCount(pool, thisOpenSpots, instanceMax);
				Plugin.LogTrace(where + " go=" + ((Object)luggage).name + " type=" + ((object)luggage).GetType().Name + " pool=" + ((object)(*(SpawnPool*)(&pool))/*cast due to .constrained prefix*/).ToString() + " (" + LuggageCatalog.GetDisplayName(pool) + ") state=" + GameAccess.GetLuggageState(luggage) + " spotsNow=" + thisOpenSpots + " instanceMax=" + instanceMax + " force=" + spawnSettings.ForceCount + " random=" + spawnSettings.RandomCount + " countValue=" + spawnSettings.CountValue + " storedCount=" + LootStore.GetCountValue(pool) + " mult=" + spawnSettings.Multiplier + " wanted=" + wantedSpawnCount + " override=" + LootStore.HasSpawnCountOverride(pool) + " share=" + spawnSettings.ShareWithParty + " noDupes=" + spawnSettings.DisableDuplicates + " enabledItems=" + LootStore.CountEnabledItems(pool) + " history=" + flag + " historyRecords=" + num + " " + HostLine() + (string.IsNullOrEmpty(extra) ? string.Empty : (" " + extra)));
			}
			catch (Exception ex2)
			{
				Plugin.LogTrace(where + " log failed: " + ex2);
			}
		}

		private static void OnLuggageOpened(Luggage luggage, Character interactor)
		{
			try
			{
				if (Plugin.IsDebug)
				{
					string text = (((Object)(object)interactor != (Object)null) ? ((Object)interactor).name : "null");
					LogLuggage("GlobalEvents.OnLuggageOpened opener=" + text, luggage);
					if ((Object)(object)Plugin.Instance != (Object)null)
					{
						((MonoBehaviour)Plugin.Instance).StartCoroutine(DumpAfterOpen(luggage));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.LogTrace("OnLuggageOpened log failed: " + ex.Message);
			}
		}

		private static IEnumerator DumpAfterOpen(Luggage luggage)
		{
			yield return (object)new WaitForSeconds(0.35f);
			LogLuggage("after-open +0.35s", luggage);
		}
	}
	internal static class LuggageUi
	{
		internal static readonly Color PanelColor = new Color(0.08f, 0.06f, 0.05f, 0.94f);

		internal static readonly Color ButtonColor = new Color(0.1792453f, 0.1253449f, 0.09046815f, 62f / 85f);

		internal static readonly Color ButtonHover = new Color(0.26f, 0.18f, 0.13f, 0.92f);

		internal static readonly Color Cream = new Color(0.95f, 0.93f, 0.88f, 1f);

		internal static readonly Color CreamDim = new Color(0.82f, 0.78f, 0.72f, 0.92f);

		internal static readonly Color AccentOn = new Color(0.55f, 0.42f, 0.22f, 0.95f);

		internal static readonly Color EditedColor = new Color(0.85f, 0.72f, 0.38f, 1f);

		internal static readonly Color FieldWellColor = new Color(0.22f, 0.16f, 0.11f, 1f);

		private static readonly Color CheckboxWellColor = new Color(0.12f, 0.09f, 0.07f, 1f);

		private static readonly Color CheckboxOnColor = new Color(0.92f, 0.78f, 0.38f, 1f);

		private static Sprite _whiteSprite;

		private static GameObject _buttonDonor;

		private static TMP_FontAsset _cachedFont;

		private static int _cachedSceneHandle = -1;

		internal static Canvas CreateOverlayCanvas(GameObject root, int sortingOrder)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			Canvas val = root.GetComponent<Canvas>() ?? root.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.overrideSorting = true;
			val.sortingOrder = sortingOrder;
			val.additionalShaderChannels = (AdditionalCanvasShaderChannels)25;
			CanvasScaler val2 = root.GetComponent<CanvasScaler>() ?? root.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.matchWidthOrHeight = 1f;
			if ((Object)(object)root.GetComponent<GraphicRaycaster>() == (Object)null)
			{
				root.AddComponent<GraphicRaycaster>();
			}
			return val;
		}

		internal static RectTransform CreatePanel(Transform parent, string name, Vector2 size, Color color)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = size;
			Image component2 = val.GetComponent<Image>();
			component2.sprite = WhiteSprite();
			component2.type = (Type)1;
			((Graphic)component2).color = color;
			((Graphic)component2).raycastTarget = true;
			return component;
		}

		internal static TextMeshProUGUI CreateLabel(Transform parent, string name, string text, float fontSize, FontStyles style = (FontStyles)0, TextAlignmentOptions align = (TextAlignmentOptions)513)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0057: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer)
			});
			val.transform.SetParent(parent, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).text = text ?? string.Empty;
			((TMP_Text)val2).fontSize = fontSize;
			((TMP_Text)val2).fontStyle = style;
			((TMP_Text)val2).alignment = align;
			((Graphic)val2).color = Cream;
			((Graphic)val2).raycastTarget = false;
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)0;
			((MaskableGraphic)val2).maskable = true;
			ApplyFont(val2);
			return val2;
		}

		internal static LayoutElement MakeNonCollapsing(GameObject go, float height, float minWidth = 0f)
		{
			LayoutElement val = go.GetComponent<LayoutElement>() ?? go.AddComponent<LayoutElement>();
			val.minHeight = height;
			val.preferredHeight = height;
			val.flexibleHeight = 0f;
			if (minWidth > 0f)
			{
				val.minWidth = minWidth;
				if (val.preferredWidth < minWidth)
				{
					val.preferredWidth = minWidth;
				}
			}
			return val;
		}

		internal static Button CreateButton(Transform parent, string label, UnityAction onClick, Vector2 preferredSize)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return CreatePlainButton(parent, label, onClick, preferredSize);
		}

		internal static Button CreatePlainButton(Transform parent, string label, UnityAction onClick, Vector2 preferredSize)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreatePlainButtonObject(parent, label);
			ApplyButtonSize(val, preferredSize);
			TextMeshProUGUI componentInChildren = val.GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((TMP_Text)componentInChildren).text = label ?? string.Empty;
				((TMP_Text)componentInChildren).overflowMode = (TextOverflowModes)0;
				((MaskableGraphic)componentInChildren).maskable = true;
				ApplyFont(componentInChildren);
			}
			Button component = val.GetComponent<Button>();
			((UnityEventBase)component.onClick).RemoveAllListeners();
			if (onClick != null)
			{
				((UnityEvent)component.onClick).AddListener(onClick);
			}
			return component;
		}

		internal static KitItemRow CreateItemRow(Transform parent, string label, UnityAction<string> onPick, float height)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			GameObject val = CreatePlainButtonObject(parent, label);
			ApplyButtonSize(val, new Vector2(560f, height));
			TextMeshProUGUI componentInChildren = val.GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((TMP_Text)componentInChildren).text = label ?? string.Empty;
				((TMP_Text)componentInChildren).enableAutoSizing = false;
				((TMP_Text)componentInChildren).fontSize = 18f;
				((TMP_Text)componentInChildren).overflowMode = (TextOverflowModes)0;
				((MaskableGraphic)componentInChildren).maskable = true;
				((Graphic)componentInChildren).raycastTarget = false;
				ApplyFont(componentInChildren);
			}
			KitItemRow row = val.GetComponent<KitItemRow>() ?? val.AddComponent<KitItemRow>();
			row.ItemName = label ?? string.Empty;
			row.Label = componentInChildren;
			row.OnPicked = ((onPick == null) ? null : ((Action<string>)delegate(string s)
			{
				onPick.Invoke(s);
			}));
			Button component = val.GetComponent<Button>();
			((UnityEventBase)component.onClick).RemoveAllListeners();
			if (onPick != null)
			{
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					onPick.Invoke(row.ItemName);
				});
			}
			return row;
		}

		internal static Toggle CreateToggle(Transform parent, string label, bool isOn, UnityAction<bool> onChanged, float height = 28f)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			GameObject val = new GameObject("Toggle_" + Sanitize(label), new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			PinTopStretch(val.GetComponent<RectTransform>(), height);
			Image component = val.GetComponent<Image>();
			component.sprite = WhiteSprite();
			((Graphic)component).color = new Color(1f, 1f, 1f, 0.001f);
			((Graphic)component).raycastTarget = true;
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.minHeight = height;
			val2.preferredHeight = height;
			val2.flexibleHeight = 0f;
			val2.flexibleWidth = 1f;
			val2.minWidth = 160f;
			HorizontalLayoutGroup val3 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val3).spacing = 8f;
			((LayoutGroup)val3).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val3).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)val3).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandWidth = false;
			((LayoutGroup)val3).padding = new RectOffset(2, 4, 2, 2);
			Image wellImg;
			Image borderImg;
			Image checkImg = CreateCheckVisual(val.transform, 22f, out wellImg, out borderImg);
			TextMeshProUGUI val4 = CreateLabel(val.transform, "Label", label, 16f, (FontStyles)0, (TextAlignmentOptions)513);
			LayoutElement val5 = ((Component)val4).gameObject.AddComponent<LayoutElement>();
			val5.minWidth = 120f;
			val5.preferredWidth = 220f;
			val5.flexibleWidth = 1f;
			val5.minHeight = height - 4f;
			val5.preferredHeight = height - 4f;
			Toggle val6 = val.AddComponent<Toggle>();
			((Selectable)val6).targetGraphic = (Graphic)(object)component;
			val6.graphic = (Graphic)(object)checkImg;
			ApplyToggleColors(val6);
			val6.SetIsOnWithoutNotify(isOn);
			ApplyCheckMark(wellImg, checkImg, isOn);
			((UnityEvent<bool>)(object)val6.onValueChanged).AddListener((UnityAction<bool>)delegate(bool v)
			{
				ApplyCheckMark(wellImg, checkImg, v);
				onChanged?.Invoke(v);
			});
			return val6;
		}

		internal static Toggle CreateCheckBox(Transform parent, bool isOn, UnityAction<bool> onChanged, float size = 22f)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			GameObject val = new GameObject("CheckBox", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			PinBox(val.GetComponent<RectTransform>(), size, size);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.preferredWidth = size;
			val2.preferredHeight = size;
			val2.minWidth = size;
			val2.minHeight = size;
			val2.flexibleWidth = 0f;
			val2.flexibleHeight = 0f;
			Image wellImg;
			Image borderImg;
			Image checkImg = CreateCheckVisual(val.transform, size, out wellImg, out borderImg);
			Toggle val3 = val.AddComponent<Toggle>();
			((Selectable)val3).targetGraphic = (Graphic)(object)borderImg;
			val3.graphic = (Graphic)(object)checkImg;
			ApplyToggleColors(val3);
			val3.SetIsOnWithoutNotify(isOn);
			ApplyCheckMark(wellImg, checkImg, isOn);
			((UnityEvent<bool>)(object)val3.onValueChanged).AddListener((UnityAction<bool>)delegate(bool v)
			{
				ApplyCheckMark(wellImg, checkImg, v);
				onChanged?.Invoke(v);
			});
			return val3;
		}

		internal static void SetToggleVisual(Toggle toggle, bool isOn)
		{
			if ((Object)(object)toggle == (Object)null)
			{
				return;
			}
			toggle.SetIsOnWithoutNotify(isOn);
			Image val = null;
			Graphic targetGraphic = ((Selectable)toggle).targetGraphic;
			Image val2 = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
			if (val2 != null && ((Object)((Component)val2).gameObject).name == "Well")
			{
				val = val2;
			}
			else
			{
				Transform val3 = ((Component)toggle).transform.Find("Border/Well") ?? ((Component)toggle).transform.Find("Well");
				if ((Object)(object)val3 != (Object)null)
				{
					val = ((Component)val3).GetComponent<Image>();
				}
			}
			Image well = val;
			Graphic graphic = toggle.graphic;
			ApplyCheckMark(well, (Image)(object)((graphic is Image) ? graphic : null), isOn);
		}

		internal static void SetToggleInteractable(Toggle toggle, bool interactable)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)toggle == (Object)null)
			{
				return;
			}
			((Selectable)toggle).interactable = interactable;
			Transform val = ((Component)toggle).transform.Find("Label");
			if (!((Object)(object)val == (Object)null))
			{
				TextMeshProUGUI component = ((Component)val).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = (interactable ? Cream : CreamDim);
				}
			}
		}

		internal static IntDropdown CreateIntDropdown(Transform parent, int min, int max, int value, Action<int> onChanged, float width = 72f, float height = 34f)
		{
			//IL_0014: 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_0080: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected O, but got Unknown
			GameObject val = CreatePlainButtonObject(parent, value.ToString());
			ApplyButtonSize(val, new Vector2(width, height));
			TextMeshProUGUI componentInChildren = val.GetComponentInChildren<TextMeshProUGUI>(true);
			Button component = val.GetComponent<Button>();
			GameObject val2 = new GameObject("Options", new Type[5]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 1f);
			component2.anchorMax = val3;
			component2.anchorMin = val3;
			component2.pivot = new Vector2(0.5f, 1f);
			component2.anchoredPosition = Vector2.zero;
			component2.sizeDelta = new Vector2(width, 0f);
			Image component3 = val2.GetComponent<Image>();
			component3.sprite = WhiteSprite();
			((Graphic)component3).color = FieldWellColor;
			((Graphic)component3).raycastTarget = true;
			VerticalLayoutGroup component4 = val2.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 2f;
			((LayoutGroup)component4).padding = new RectOffset(4, 4, 4, 4);
			((LayoutGroup)component4).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			val2.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			val2.SetActive(false);
			IntDropdown intDropdown = val.AddComponent<IntDropdown>();
			intDropdown.Label = componentInChildren;
			intDropdown.ListRoot = val2;
			intDropdown.OnChanged = onChanged;
			intDropdown.SetRange(min, max, value);
			((UnityEventBase)component.onClick).RemoveAllListeners();
			((UnityEvent)component.onClick).AddListener(new UnityAction(intDropdown.ToggleOpen));
			return intDropdown;
		}

		internal static ChoiceDropdown CreateChoiceDropdown(Transform parent, string[] labels, int[] values, int selectedValue, Action<int> onChanged, float width = 140f, float height = 34f)
		{
			//IL_005f: 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_00cd: Expected O, but got Unknown
			//IL_00ff: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Expected O, but got Unknown
			int num = 0;
			if (values != null)
			{
				for (int i = 0; i < values.Length; i++)
				{
					if (values[i] == selectedValue)
					{
						num = i;
						break;
					}
				}
			}
			string label = ((labels != null && num < labels.Length) ? labels[num] : selectedValue.ToString());
			GameObject val = CreatePlainButtonObject(parent, label);
			ApplyButtonSize(val, new Vector2(width, height));
			TextMeshProUGUI componentInChildren = val.GetComponentInChildren<TextMeshProUGUI>(true);
			Button component = val.GetComponent<Button>();
			GameObject val2 = new GameObject("Options", new Type[5]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 1f);
			component2.anchorMax = val3;
			component2.anchorMin = val3;
			component2.pivot = new Vector2(0.5f, 1f);
			component2.anchoredPosition = Vector2.zero;
			component2.sizeDelta = new Vector2(width, 0f);
			Image component3 = val2.GetComponent<Image>();
			component3.sprite = WhiteSprite();
			((Graphic)component3).color = FieldWellColor;
			((Graphic)component3).raycastTarget = true;
			VerticalLayoutGroup component4 = val2.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 2f;
			((LayoutGroup)component4).padding = new RectOffset(4, 4, 4, 4);
			((LayoutGroup)component4).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			val2.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			val2.SetActive(false);
			ChoiceDropdown choiceDropdown = val.AddComponent<ChoiceDropdown>();
			choiceDropdown.Label = componentInChildren;
			choiceDropdown.ListRoot = val2;
			choiceDropdown.OnChanged = onChanged;
			choiceDropdown.Labels = labels ?? new string[0];
			choiceDropdown.Values = values ?? new int[0];
			choiceDropdown.SetValue(selectedValue);
			((UnityEventBase)component.onClick).RemoveAllListeners();
			((UnityEvent)component.onClick).AddListener(new UnityAction(choiceDropdown.ToggleOpen));
			return choiceDropdown;
		}

		private static Image CreateCheckVisual(Transform parent, float size, out Image wellImg, out Image borderImg)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_006c: 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_00ff: Expected O, but got Unknown
			//IL_013f: 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_018b: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Border", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			PinBox(val.GetComponent<RectTransform>(), size, size);
			borderImg = val.GetComponent<Image>();
			borderImg.sprite = WhiteSprite();
			((Graphic)borderImg).color = Cream;
			((Graphic)borderImg).raycastTarget = true;
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.preferredWidth = size;
			val2.preferredHeight = size;
			val2.minWidth = size;
			val2.minHeight = size;
			val2.flexibleWidth = 0f;
			val2.flexibleHeight = 0f;
			val2.ignoreLayout = false;
			GameObject val3 = new GameObject("Well", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val3.transform.SetParent(val.transform, false);
			Stretch(val3.GetComponent<RectTransform>(), 2f, 2f);
			wellImg = val3.GetComponent<Image>();
			wellImg.sprite = WhiteSprite();
			((Graphic)wellImg).color = CheckboxWellColor;
			((Graphic)wellImg).raycastTarget = true;
			GameObject val4 = new GameObject("Check", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val4.transform.SetParent(val3.transform, false);
			Stretch(val4.GetComponent<RectTransform>(), 3f, 3f);
			Image component = val4.GetComponent<Image>();
			component.sprite = WhiteSprite();
			((Graphic)component).color = CheckboxOnColor;
			((Graphic)component).raycastTarget = false;
			return component;
		}

		private static void ApplyCheckMark(Image well, Image check, bool isOn)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)well != (Object)null)
			{
				((Graphic)well).color = CheckboxWellColor;
			}
			if (!((Object)(object)check == (Object)null))
			{
				((Behaviour)check).enabled = true;
				((Graphic)check).color = (Color)(isOn ? CheckboxOnColor : new Color(CheckboxOnColor.r, CheckboxOnColor.g, CheckboxOnColor.b, 0f));
				((Graphic)check).canvasRenderer.SetAlpha(isOn ? 1f : 0f);
			}
		}

		private static void ApplyToggleColors(Toggle toggle)
		{
			//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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock colors = ((Selectable)toggle).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1.06f, 1.06f, 1.06f, 1f);
			((ColorBlock)(ref colors)).pressedColor = Color.white;
			((ColorBlock)(ref colors)).selectedColor = Color.white;
			((ColorBlock)(ref colors)).disabledColor = new Color(1f, 1f, 1f, 0.45f);
			((Selectable)toggle).colors = colors;
		}

		internal static TMP_InputField CreateLabeledNumber(Transform parent, string label, string value, UnityAction<string> onEndEdit, float fieldWidth = 72f)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Num_" + Sanitize(label), new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			MakeNonCollapsing(val, 36f);
			HorizontalLayoutGroup val2 = AddHorizontalLayout(val, 8f);
			((LayoutGroup)val2).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = true;
			TextMeshProUGUI val3 = CreateLabel(val.transform, "Label", label, 16f, (FontStyles)0, (TextAlignmentOptions)513);
			((Graphic)val3).color = CreamDim;
			LayoutElement val4 = ((Component)val3).gameObject.AddComponent<LayoutElement>();
			val4.flexibleWidth = 1f;
			val4.minWidth = 80f;
			return CreateNumberField(val.transform, value, onEndEdit, fieldWidth);
		}

		internal static TMP_InputField CreateNumberField(Transform parent, string value, UnityAction<string> onEndEdit, float width, float height = 34f)
		{
			TMP_InputField val = CreateField(parent, "Number", value, string.Empty, width, height, flexWidth: false, (TextAlignmentOptions)514);
			val.contentType = (ContentType)2;
			val.characterLimit = 5;
			val.onFocusSelectAll = true;
			if (onEndEdit != null)
			{
				((UnityEvent<string>)(object)val.onEndEdit).AddListener(onEndEdit);
				((UnityEvent<string>)(object)val.onSubmit).AddListener(onEndEdit);
			}
			return val;
		}

		internal static TMP_InputField CreateTextField(Transform parent, string placeholder, float minWidth, float height = 36f)
		{
			TMP_InputField val = CreateField(parent, "TextField", string.Empty, placeholder, minWidth, height, flexWidth: true, (TextAlignmentOptions)513);
			val.contentType = (ContentType)0;
			val.characterLimit = 40;
			val.onFocusSelectAll = false;
			return val;
		}

		private static TMP_InputField CreateField(Transform parent, string name, string value, string placeholder, float width, float height, bool flexWidth, TextAlignmentOptions align)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			//IL_0135: 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_01a5: 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_0222: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			PinTopStretch(val.GetComponent<RectTransform>(), height);
			Image component = val.GetComponent<Image>();
			component.sprite = WhiteSprite();
			((Graphic)component).color = FieldWellColor;
			((Graphic)component).raycastTarget = true;
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.minHeight = height;
			val2.preferredHeight = height;
			val2.minWidth = width;
			val2.preferredWidth = width;
			val2.flexibleWidth = (flexWidth ? 1f : 0f);
			val2.flexibleHeight = 0f;
			GameObject val3 = new GameObject("Text Area", new Type[2]
			{
				typeof(RectTransform),
				typeof(RectMask2D)
			});
			val3.transform.SetParent(val.transform, false);
			Stretch(val3.GetComponent<RectTransform>(), 8f, 4f);
			TextMeshProUGUI val4 = CreateLabel(val3.transform, "Text", value ?? string.Empty, 18f, (FontStyles)0, align);
			Stretch(((TMP_Text)val4).rectTransform, 0f, 0f);
			((Graphic)val4).raycastTarget = true;
			TextMeshProUGUI val5 = null;
			if (!string.IsNullOrEmpty(placeholder))
			{
				val5 = CreateLabel(val3.transform, "Placeholder", placeholder, 18f, (FontStyles)2, align);
				Stretch(((TMP_Text)val5).rectTransform, 0f, 0f);
				((Graphic)val5).color = CreamDim;
			}
			TMP_InputField val6 = val.AddComponent<TMP_InputField>();
			((Selectable)val6).targetGraphic = (Graphic)(object)component;
			val6.textViewport = val3.GetComponent<RectTransform>();
			val6.textComponent = (TMP_Text)(object)val4;
			val6.placeholder = (Graphic)(object)val5;
			val6.text = value ?? string.Empty;
			val6.caretColor = Cream;
			val6.customCaretColor = true;
			val6.selectionColor = new Color(0.45f, 0.35f, 0.2f, 0.45f);
			val6.restoreOriginalTextOnEscape = false;
			((Selectable)val6).interactable = true;
			if ((Object)(object)((TMP_Text)val4).font != (Object)null)
			{
				val6.fontAsset = ((TMP_Text)val4).font;
			}
			FieldFocusOnClick fieldFocusOnClick = val.AddComponent<FieldFocusOnClick>();
			fieldFocusOnClick.Field = val6;
			return val6;
		}

		internal static ScrollRect CreateScrollView(Transform parent, out RectTransform content)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			//IL_0186: 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_01b4: 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_01ce: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Scroll", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(ScrollRect)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = WhiteSprite();
			((Graphic)component).color = new Color(0.05f, 0.04f, 0.03f, 0.55f);
			ScrollRect component2 = val.GetComponent<ScrollRect>();
			component2.horizontal = false;
			component2.vertical = true;
			component2.movementType = (MovementType)2;
			component2.scrollSensitivity = 40f;
			GameObject val2 = new GameObject("Viewport", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Mask)
			});
			val2.transform.SetParent(val.transform, false);
			Stretch(val2.GetComponent<RectTransform>(), 0f, 0f);
			Image component3 = val2.GetComponent<Image>();
			component3.sprite = WhiteSprite();
			((Graphic)component3).color = Color.white;
			((Graphic)component3).raycastTarget = true;
			val2.GetComponent<Mask>().showMaskGraphic = false;
			GameObject val3 = new GameObject("Content", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val2.transform, false);
			content = val3.GetComponent<RectTransform>();
			content.anchorMin = new Vector2(0f, 1f);
			content.anchorMax = new Vector2(1f, 1f);
			content.pivot = new Vector2(0.5f, 1f);
			content.anchoredPosition = Vector2.zero;
			content.sizeDelta = Vector2.zero;
			component2.viewport = val2.GetComponent<RectTransform>();
			component2.content = content;
			return component2;
		}

		internal static TMP_InputField CreateSearchField(Transform parent, string placeholder, UnityAction<string> onChanged)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Search", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = WhiteSprite();
			((Graphic)component).color = new Color(0.06f, 0.05f, 0.04f, 0.95f);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.minHeight = 36f;
			val2.preferredHeight = 36f;
			val2.flexibleWidth = 1f;
			GameObject val3 = new GameObject("Text Area", new Type[2]
			{
				typeof(RectTransform),
				typeof(RectMask2D)
			});
			val3.transform.SetParent(val.transform, false);
			Stretch(val3.GetComponent<RectTransform>(), 10f, 6f);
			TextMeshProUGUI val4 = CreateLabel(val3.transform, "Text", string.Empty, 18f, (FontStyles)0, (TextAlignmentOptions)513);
			Stretch(((TMP_Text)val4).rectTransform, 0f, 0f);
			((Graphic)val4).raycastTarget = true;
			TextMeshProUGUI val5 = CreateLabel(val3.transform, "Placeholder", placeholder, 18f, (FontStyles)2, (TextAlignmentOptions)513);
			Stretch(((TMP_Text)val5).rectTransform, 0f, 0f);
			((Graphic)val5).color = CreamDim;
			TMP_InputField val6 = val.AddComponent<TMP_InputField>();
			((Selectable)val6).targetGraphic = (Graphic)(object)component;
			((Graphic)component).raycastTarget = true;
			val6.textViewport = val3.GetComponent<RectTransform>();
			val6.textComponent = (TMP_Text)(object)val4;
			val6.placeholder = (Graphic)(object)val5;
			val6.caretColor = Cream;
			val6.customCaretColor = true;
			val6.selectionColor = new Color(0.45f, 0.35f, 0.2f, 0.45f);
			val6.onFocusSelectAll = false;
			val6.restoreOriginalTextOnEscape = false;
			((UnityEvent<string>)(object)val6.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				onChanged?.Invoke(s);
			});
			if ((Object)(object)((TMP_Text)val4).font != (Object)null)
			{
				val6.fontAsset = ((TMP_Text)val4).font;
			}
			return val6;
		}

		internal static VerticalLayoutGroup AddVerticalLayout(GameObject go, float spacing, RectOffset padding)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			VerticalLayoutGroup val = go.GetComponent<VerticalLayoutGroup>() ?? go.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val).spacing = spacing;
			((LayoutGroup)val).padding = (RectOffset)(((object)padding) ?? ((object)new RectOffset(12, 12, 12, 12)));
			((LayoutGroup)val).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)val).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandWidth = true;
			return val;
		}

		internal static HorizontalLayoutGroup AddHorizontalLayout(GameObject go, float spacing)
		{
			HorizontalLayoutGroup val = go.GetComponent<HorizontalLayoutGroup>() ?? go.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val).spacing = spacing;
			((LayoutGroup)val).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandWidth = false;
			return val;
		}

		internal static void Stretch(RectTransform rt, float padX, float padY)
		{
			//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_001c: 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)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = new Vector2(padX, padY);
			rt.offsetMax = new Vector2(0f - padX, 0f - padY);
		}

		internal static void PinBox(RectTransform rt, float width, float height)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 0.5f);
			rt.anchorMax = val;
			rt.anchorMin = val;
			rt.pivot = new Vector2(0f, 0.5f);
			rt.sizeDelta = new Vector2(width, height);
			rt.anchoredPosition = Vector2.zero;
		}

		internal static void PinTopStretch(RectTransform rt, float height)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = new Vector2(0f, 1f);
			rt.anchorMax = new Vector2(1f, 1f);
			rt.pivot = new Vector2(0.5f, 1f);
			rt.anchoredPosition = Vector2.zero;
			rt.sizeDelta = new Vector2(0f, height);
		}

		internal static void ReleaseUiFocus()
		{
			try
			{
				EventSystem current = EventSystem.current;
				if (!((Object)(object)current == (Object)null))
				{
					GameObject currentSelectedGameObject = current.currentSelectedGameObject;
					if (!((Object)(object)currentSelectedGameObject == (Object)null) && !((Object)(object)currentSelectedGameObject.GetComponentInParent<LuggageMenu>() == (Object)null))
					{
						current.SetSelectedGameObject((GameObject)null);
					}
				}
			}
			catch
			{
			}
		}

		internal static void MakeDraggable(GameObject handle, RectTransform target)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			Image val = handle.GetComponent<Image>() ?? handle.AddComponent<Image>();
			val.sprite = WhiteSprite();
			((Graphic)val).color = new Color(1f, 1f, 1f, 0.02f);
			((Graphic)val).raycastTarget = true;
			LuggageUiDragHandle luggageUiDragHandle = handle.GetComponent<LuggageUiDragHandle>() ?? handle.AddComponent<LuggageUiDragHandle>();
			luggageUiDragHandle.Target = target;
		}

		internal static void ApplyAllFonts(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).GetComponentInParent<TMP_InputField>(true) != (Object)null))
				{
					ApplyFont(val);
				}
			}
			TMP_InputField[] componentsInChildren2 = ((Component)root).GetComponentsInChildren<TMP_InputField>(true);
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				ApplyInputFieldFont(componentsInChildren2[j]);
			}
		}

		internal static void ApplyInputFieldFont(TMP_InputField input)
		{
			if ((Object)(object)input == (Object)null)
			{
				return;
			}
			TMP_FontAsset gameFont = GetGameFont();
			if (!((Object)(object)gameFont == (Object)null))
			{
				if ((Object)(object)input.textComponent != (Object)null)
				{
					input.textComponent.font = gameFont;
				}
				Graphic placeholder = input.placeholder;
				TextMeshProUGUI val = (TextMeshProUGUI)(object)((placeholder is TextMeshProUGUI) ? placeholder : null);
				if (val != null)
				{
					((TMP_Text)val).font = gameFont;
				}
				input.fontAsset = gameFont;
			}
		}

		internal static bool HasPeakButtonDonor()
		{
			return (Object)(object)ResolveButtonDonor() != (Object)null;
		}

		internal static void InvalidateButtonDonor()
		{
			_buttonDonor = null;
			_cachedFont = null;
			_cachedSceneHandle = -1;
		}

		internal static void ApplyFont(TextMeshProUGUI text)
		{
			if (!((Object)(object)text == (Object)null))
			{
				TMP_FontAsset gameFont = GetGameFont();
				if ((Object)(object)gameFont != (Object)null)
				{
					((TMP_Text)text).font = gameFont;
				}
				((TMP_Text)text).fontStyle = (FontStyles)0;
			}
		}

		internal static Sprite WhiteSprite()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_whiteSprite != (Object)null)
			{
				return _whiteSprite;
			}
			Texture2D whiteTexture = Texture2D.whiteTexture;
			_whiteSprite = Sprite.Create(whiteTexture, new Rect(0f, 0f, (float)((Texture)whiteTexture).width, (float)((Texture)whiteTexture).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)_whiteSprite).name = "PLI_WhiteSprite";
			return _whiteSprite;
		}

		private static GameObject CreatePlainButtonObject(Transform parent, string label)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_00b0: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Btn_" + Sanitize(label), new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = WhiteSprite();
			((Graphic)component).color = ButtonColor;
			Button component2 = val.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			ColorBlock colors = ((Selectable)component2).colors;
			((ColorBlock)(ref colors)).normalColor = ButtonColor;
			((ColorBlock)(ref colors)).highlightedColor = ButtonHover;
			((ColorBlock)(ref colors)).pressedColor = AccentOn;
			((ColorBlock)(ref colors)).selectedColor = ButtonHover;
			((ColorBlock)(ref colors)).disabledColor = new Color(0.2f, 0.16f, 0.12f, 0.5f);
			((Selectable)component2).colors = colors;
			TextMeshProUGUI val2 = CreateLabel(val.transform, "Text", label, 18f, (FontStyles)0, (TextAlignmentOptions)514);
			Stretch(((TMP_Text)val2).rectTransform, 8f, 4f);
			((Graphic)val2).raycastTarget = false;
			return val;
		}

		private static void ApplyButtonSize(GameObject go, Vector2 preferredSize)
		{
			//IL_000d: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			float num = Mathf.Max(32f, preferredSize.y);
			float num2 = Mathf.Max(80f, preferredSize.x);
			component.sizeDelta = new Vector2(num2, num);
			LayoutElement val = go.GetComponent<LayoutElement>() ?? go.AddComponent<LayoutElement>();
			val.preferredWidth = num2;
			val.preferredHeight = num;
			val.minHeight = num;
			val.flexibleWidth = ((preferredSize.x >= 200f) ? 1f : 0f);
		}

		private static GameObject TryClonePauseButton(Transform parent, string label)
		{
			try
			{
				GameObject val = ResolveButtonDonor();
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				GameObject val2 = Object.Instantiate<GameObject>(val, parent, false);
				((Object)val2).name = "PLI_Btn_" + Sanitize(label);
				val2.SetActive(true);
				LocalizedText[] componentsInChildren = val2.GetComponentsInChildren<LocalizedText>(true);
				foreach (LocalizedText val3 in componentsInChildren)
				{
					Object.Destroy((Object)(object)val3);
				}
				LayoutElement[] componentsInChildren2 = val2.GetComponentsInChildren<LayoutElement>(true);
				foreach (LayoutElement val4 in componentsInChildren2)
				{
					if (!((Object)(object)((Component)val4).gameObject == (Object)(object)val2))
					{
						val4.ignoreLayout = false;
					}
				}
				return val2;
			}
			catch
			{
				_buttonDonor = null;
				return null;
			}
		}

		private static GameObject ResolveButtonDonor()
		{
			if ((Object)(object)_buttonDonor != (Object)null)
			{
				return _buttonDonor;
			}
			try
			{
				PauseMenuMainPage val = null;
				if ((Object)(object)GUIManager.instance != (Object)null)
				{
					val = GUIManager.instance.pauseMenuMainPage;
				}
				if ((Object)(object)val == (Object)null)
				{
					val = Object.FindFirstObjectByType<PauseMenuMainPage>((FindObjectsInactive)1);
				}
				Button val2 = GameAccess.GetPauseMenuButton(val, "m_resumeButton") ?? GameAccess.GetPauseMenuButton(val, "m_settingsButton") ?? GameAccess.GetPauseMenuButton(val, "m_quitButton");
				if ((Object)(object)val2 != (Object)null)
				{
					_buttonDonor = ((Component)val2).gameObject;
					return _buttonDonor;
				}
			}
			catch
			{
			}
			try
			{
				GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
				foreach (GameObject val3 in array)
				{
					if (!((Object)(object)val3 == (Object)null) && ((Object)val3).name != null && ((Object)val3).name.IndexOf("UI_MainMenuButton", StringComparison.Ordinal) >= 0 && !((Object)(object)val3.GetComponent<Button>() == (Object)null))
					{
						_buttonDonor = val3;
						return _buttonDonor;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static TMP_FontAsset GetGameFont()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			int num = SceneHandle.op_Implicit(((Scene)(ref activeScene)).handle);
			if ((Object)(object)_cachedFont != (Object)null && _cachedSceneHandle == num)
			{
				return _cachedFont;
			}
			try
			{
				if ((Object)(object)GUIManager.instance != (Object)null)
				{
					TextMeshProUGUI componentInChildren = ((Component)GUIManager.instance).GetComponentInChildren<TextMeshProUGUI>(true);
					if ((Object)(object)componentInChildren != (Object)null && (Object)(object)((TMP_Text)componentInChildren).font != (Object)null)
					{
						_cachedFont = ((TMP_Text)componentInChildren).font;
						_cachedSceneHandle = num;
						return _cachedFont;
					}
				}
			}
			catch
			{
			}
			try
			{
				TextMeshProUGUI val = Object.FindFirstObjectByType<TextMeshProUGUI>((FindObjectsInactive)1);
				if ((Object)(object)val != (Object)null && (Object)(object)((TMP_Text)val).font != (Object)null)
				{
					_cachedFont = ((TMP_Text)val).font;
					_cachedSceneHandle = num;
					return _cachedFont;
				}
			}
			catch
			{
			}
			return _cachedFont;
		}

		private static string Sanitize(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "Btn";
			}
			char[] array = s.ToCharArray();
			for (int i = 0; i < array.Length; i++)
			{
				if (!char.IsLetterOrDigit(array[i]))
				{
					array[i] = '_';
				}
			}
			return new string(array);
		}
	}
	internal sealed class KitItemRow : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		internal string ItemName;

		internal Action<string> OnPicked;

		internal TextMeshProUGUI Label;

		public void OnPointerClick(PointerEventData eventData)
		{
			if (OnPicked != null && !string.IsNullOrEmpty(ItemName))
			{
				OnPicked(ItemName);
			}
		}
	}
	internal sealed class LuggageRow : MonoBehaviour
	{
		internal SpawnPool Pool;

		internal TextMeshProUGUI NameLabel;

		internal TextMeshProUGUI MetaLabel;
	}
	internal sealed class LootItemRow : MonoBehaviour
	{
		internal ushort ItemId;

		internal bool Enabled;

		internal bool Custom;

		internal Toggle EnabledToggle;

		internal TMP_InputField WeightField;

		internal TextMeshProUGUI NameLabel;

		internal TextMeshProUGUI OddsLabel;
	}
	internal sealed class IntDropdown : MonoBehaviour
	{
		internal static IntDropdown OpenInstance;

		internal TextMeshProUGUI Label;

		internal GameObject ListRoot;

		internal Action<int> OnChanged;

		internal int Value = 1;

		internal int Min = 1;

		internal int Max = 1;

		private GameObject _blocker;

		public void SetRange(int min, int max, int value)
		{
			Min = Mathf.Max(1, min);
			Max = Mathf.Max(Min, max);
			Value = Mathf.Clamp(value, Min, Max);
			if ((Object)(object)Label != (Object)null)
			{
				((TMP_Text)Label).text = Value.ToString();
			}
			if ((Object)(object)ListRoot != (Object)null && ListRoot.activeSelf)
			{
				RebuildOptions();
			}
		}

		public void SetValue(int value)
		{
			Value = Mathf.Clamp(value, Min, Max);
			if ((Object)(object)Label != (Object)null)
			{
				((TMP_Text)Label).text = Value.ToString();
			}
		}

		public void SetInteractable(bool interactable)
		{
			//IL_003b: 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)
			Button component = ((Component)this).GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((Selectable)component).interactable = interactable;
			}
			if ((Object)(object)Label != (Object)null)
			{
				((Graphic)Label).color = (interactable ? LuggageUi.Cream : LuggageUi.CreamDim);
			}
			if (!interactable)
			{
				Close();
			}
		}

		public void ToggleOpen()
		{
			if ((Object)(object)ListRoot == (Object)null)
			{
				return;
			}
			if (ListRoot.activeSelf)
			{
				Close();
				return;
			}
			if ((Object)(object)OpenInstance != (Object)null && (Object)(object)OpenInstance != (Object)(object)this)
			{
				OpenInstance.Close();
			}
			ChoiceDropdown.CloseOpen();
			AttachToOverlay();
			RebuildOptions();
			PositionList();
			if ((Object)(object)_blocker != (Object)null)
			{
				_blocker.SetActive(true);
			}
			ListRoot.SetActive(true);
			ListRoot.transform.SetAsLastSibling();
			OpenInstance = this;
		}

		internal static void CloseOpen()
		{
			IntDropdown openInstance = OpenInstance;
			OpenInstance = null;
			if ((Object)(object)openInstance == (Object)null)
			{
				return;
			}
			try
			{
				openInstance.Close();
			}
			catch
			{
			}
		}

		public void Close()
		{
			if ((Object)(object)ListRoot != (Object)null)
			{
				ListRoot.SetActive(false);
			}
			if ((Object)(object)_blocker != (Object)null)
			{
				_blocker.SetActive(false);
			}
			if ((Object)(object)OpenInstance == (Object)(object)this)
			{
				OpenInstance = null;
			}
		}

		private void OnDisable()
		{
			Close();
		}

		private void AttachToOverlay()
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00c5: 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_0107: Expected O, but got Unknown
			Canvas val = ((Component)this).GetComponentInParent<Canvas>();
			if ((Object)(object)val != (Object)null)
			{
				val = val.rootCanvas;
			}
			Transform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform : ((Component)this).transform.root);
			if ((Object)(object)_blocker == (Object)null)
			{
				_blocker = new GameObject("PLI_DropdownBlocker", new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(Button)
				});
				Image component = _blocker.GetComponent<Image>();
				component.sprite = LuggageUi.WhiteSprite();
				((Graphic)component).color = new Color(0f, 0f, 0f, 0.01f);
				((Graphic)component).raycastTarget = true;
				Button component2 = _blocker.GetComponent<Button>();
				((Selectable)component2).transition = (Transition)0;
				((UnityEvent)component2.onClick).AddListener(new UnityAction(Close));
			}
			_blocker.transform.SetParent(val2, false);
			LuggageUi.Stretch(_blocker.GetComponent<RectTransform>(), 0f, 0f);
			_blocker.transform.SetAsLastSibling();
			ListRoot.transform.SetParent(val2, false);
			ListRoot.transform.SetAsLastSibling();
		}

		private void PositionList()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_0092: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			RectTransform component = ListRoot.GetComponent<RectTransform>();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)component == (Object)null))
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				val.GetWorldCorners(array);
				Vector3 position = (array[0] + array[1]) * 0.5f;
				Vector2 val2 = default(Vector2);
				((Vector2)(ref val2))..ctor(0.5f, 0.5f);
				component.anchorMax = val2;
				component.anchorMin = val2;
				component.pivot = new Vector2(0.5f, 1f);
				((Transform)component).position = position;
				Rect rect = val.rect;
				component.SetSizeWithCurrentAnchors((Axis)0, Mathf.Max(72f, ((Rect)(ref rect)).width));
			}
		}

		private void RebuildOptions()
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			if ((Object)(object)ListRoot == (Object)null)
			{
				return;
			}
			for (int num = ListRoot.transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)ListRoot.transform.GetChild(num)).gameObject);
			}
			for (int i = Min; i <= Max; i++)
			{
				int pick = i;
				LuggageUi.CreatePlainButton(ListRoot.transform, pick.ToString(), (UnityAction)delegate
				{
					Pick(pick);
				}, new Vector2(72f, 30f));
			}
		}

		private void Pick(int value)
		{
			SetValue(value);
			Close();
			OnChanged?.Invoke(Value);
		}
	}
	internal sealed class ChoiceDropdown : MonoBehaviour
	{
		internal static ChoiceDropdown OpenInstance;

		internal TextMeshProUGUI Label;

		internal GameObject ListRoot;

		internal Action<int> OnChanged;

		internal string[] Labels = new string[0];

		internal int[] Values = new int[0];

		internal int Value;

		private GameObject _blocker;

		public void SetValue(int value)
		{
			Value = value;
			if ((Object)(object)Label == (Object)null)
			{
				return;
			}
			for (int i = 0; i < Values.Length && i < Labels.Length; i++)
			{
				if (Values[i] == value)
				{
					((TMP_Text)Label).text = Labels[i];
					return;
				}
			}
			((TMP_Text)Label).text = value.ToString();
		}

		public void ToggleOpen()
		{
			if ((Object)(object)ListRoot == (Object)null)
			{
				return;
			}
			if (ListRoot.activeSelf)
			{
				Close();
				return;
			}
			if ((Object)(object)OpenInstance != (Object)null && (Object)(object)OpenInstance != (Object)(object)this)
			{
				OpenInstance.Close();
			}
			IntDropdown.CloseOpen();
			AttachToOverlay();
			RebuildOptions();
			PositionList();
			if ((Object)(object)_blocker != (Object)null)
			{
				_blocker.SetActive(true);
			}
			ListRoot.SetActive(true);
			ListRoot.transform.SetAsLastSibling();
			OpenInstance = this;
		}

		internal static void CloseOpen()
		{
			ChoiceDropdown openInstance = OpenInstance;
			OpenInstance = null;
			if ((Object)(object)openInstance == (Object)null)
			{
				return;
			}
			try
			{
				openInstance.Close();
			}
			catch
			{
			}
		}

		public void Close()
		{
			if ((Object)(object)ListRoot != (Object)null)
			{
				ListRoot.SetActive(false);
			}
			if ((Object)(object)_blocker != (Object)null)
			{
				_blocker.SetActive(false);
			}
			if ((Object)(object)OpenInstance == (Object)(object)this)
			{
				OpenInstance = null;
			}
		}

		private void OnDisable()
		{
			Close();
		}

		private void AttachToOverlay()
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00c5: 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_0107: Expected O, but got Unknown
			Canvas val = ((Component)this).GetComponentInParent<Canvas>();
			if ((Object)(object)val != (Object)null)
			{
				val = val.rootCanvas;
			}
			Transform val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform : ((Component)this).transform.root);
			if ((Object)(object)_blocker == (Object)null)
			{
				_blocker = new GameObject("PLI_ChoiceBlocker", new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(Button)
				});
				Image component = _blocker.GetComponent<Image>();
				component.sprite = LuggageUi.WhiteSprite();
				((Graphic)component).color = new Color(0f, 0f, 0f, 0.01f);
				((Graphic)component).raycastTarget = true;
				Button component2 = _blocker.GetComponent<Button>();
				((Selectable)component2).transition = (Transition)0;
				((UnityEvent)component2.onClick).AddListener(new UnityAction(Close));
			}
			_blocker.transform.SetParent(val2, false);
			LuggageUi.Stretch(_blocker.GetComponent<RectTransform>(), 0f, 0f);
			_blocker.transform.SetAsLastSibling();
			ListRoot.transform.SetParent(val2, false);
			ListRoot.transform.SetAsLastSibling();
		}

		private void PositionList()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_0092: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			RectTransform component = ListRoot.GetComponent<RectTransform>();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)component == (Object)null))
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				val.GetWorldCorners(array);
				Vector3 position = (array[0] + array[1]) * 0.5f;
				Vector2 val2 = default(Vector2);
				((Vector2)(ref val2))..ctor(0.5f, 0.5f);
				component.anchorMax = val2;
				component.anchorMin = val2;
				component.pivot = new Vector2(0.5f, 1f);
				((Transform)component).position = position;
				Rect rect = val.rect;
				component.SetSizeWithCurrentAnchors((Axis)0, Mathf.Max(120f, ((Rect)(ref rect)).width));
			}
		}

		private void RebuildOptions()
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			if ((Object)(object)ListRoot == (Object)null)
			{
				return;
			}
			for (int num = ListRoot.transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)ListRoot.transform.GetChild(num)).gameObject);
			}
			int num2 = Mathf.Min(Labels.Length, Values.Length);
			for (int i = 0; i < num2; i++)
			{
				int pick = Values[i];
				string label = Labels[i];
				LuggageUi.CreatePlainButton(ListRoot.transform, label, (UnityAction)delegate
				{
					Pick(pick);
				}, new Vector2(140f, 30f));
			}
		}

		private void Pick(int value)
		{
			SetValue(value);
			Close();
			OnChanged?.Invoke(Value);
		}
	}
	internal sealed class FieldFocusOnClick : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		internal TMP_InputField Field;

		public void OnPointerClick(PointerEventData eventData)
		{
			if (!((Object)(object)Field == (Object)null) && ((UIBehaviour)Field).IsActive() && ((Selectable)Field).interactable)
			{
				Field.ActivateInputField();
				((Selectable)Field).Select();
			}
		}
	}
	internal sealed class LuggageUiDragHandle : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler, IPointerDownHandler
	{
		internal RectTransform Target;

		public void OnPointerDown(PointerEventData eventData)
		{
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Target == (Object)null) && eventData != null)
			{
				RectTransform target = Target;
				target.anchoredPosition += eventData.delta;
			}
		}
	}
	internal sealed class LuggageMenu : MonoBehaviour
	{
		[HarmonyPatch(typeof(GUIManager), "UpdateWindowStatus")]
		private static class Patch_UpdateWindowStatus
		{
			private static void Postfix(GUIManager __instance)
			{
				if (!((Object)(object)__instance == (Object)null) && IsOpen)
				{
					GameAccess.SetMenuWindowFlags(__instance, blocking: true, showingCursor: true);
				}
			}
		}

		[HarmonyPatch(typeof(GUIManager), "LateUpdate")]
		private static class Patch_GuiLateUpdate
		{
			private static void Postfix()
			{
				if ((Object)(object)Plugin.Instance != (Object)null && Plugin.Instance.IsMenuHotkeyDown())
				{
					Toggle();
				}
			}
		}

		[HarmonyPatch(typeof(Character), "CanDoInput")]
		private static class Patch_CanDoInput
		{
			private static void Postfix(ref bool __result)
			{
				if (IsOpen)
				{
					__result = false;
				}
			}
		}

		[HarmonyPatch(typeof(CursorHandler), "Update")]
		private static class Patch_CursorHandler
		{
			private static void Postfix()
			{
				if (IsOpen)
				{
					Cursor.lockState = (CursorLockMode)0;
					Cursor.visible = true;
				}
			}
		}

		[HarmonyPatch(typeof(PauseMenuMainPage), "Start")]
		private static class Patch_PauseMenuStart
		{
			private static void Postfix(PauseMenuMainPage __instance)
			{
				InjectPauseButton(__instance);
			}
		}

		[HarmonyPatch(typeof(PauseMenuMainPage), "OnEnable")]
		private static class Patch_PauseMenuEnable
		{
			private static void Postfix(PauseMenuMainPage __instance)
			{
				InjectPauseButton(__instance);
			}
		}

		private const int SortOrder = 32000;

		private const string HomeHelp = "Pick a luggage type. Vanilla items start checked. Weight is a relative chance — all 100s is even, they do not need to add up to 100. Closing the menu keeps your last settings as the default preset.";

		private const string LoadingHelp = "Item list is still loading — open a luggage again in a moment.";

		private static LuggageMenu _instance;

		private static int _toggleFrame = -1;

		private Canvas _canvas;

		private RectTransform _panel;

		private GameObject _listPage;

		private GameObject _detailPage;

		private TextMeshProUGUI _help;

		private TextMeshProUGUI _detailTitle;

		private TextMeshProUGUI _detailMeta;

		private TextMeshProUGUI _spawnPreview;

		private Toggle _forceCountToggle;

		private Toggle _randomCountToggle;

		private IntDropdown _forceCountDropdown;

		private IntDropdown _randomCountDropdown;

		private TMP_InputField _multiplierField;

		private Toggle _shareToggle;

		private Toggle _repeatsToggle;

		private Toggle _debugToggle;

		private Toggle _pauseButtonToggle;

		private ChoiceDropdown _hotkeyModDropdown;

		private Button _hotkeyKeyButton;

		private TextMeshProUGUI _hotkeyKeyLabel;

		private int _listenHotkey;

		private TMP_InputField _listSearch;

		private TMP_InputField _detailSearch;

		private TMP_InputField _presetNameField;

		private TextMeshProUGUI _presetDropLabel;

		private GameObject _presetListGo;

		private RectTransform _presetListContent;

		private string _selectedPreset = string.Empty;

		private RectTransform _listContent;

		private RectTransform _detailContent;

		private readonly List<LuggageRow> _luggageRows = new List<LuggageRow>(16);

		private readonly List<LootItemRow> _lootRows = new List<LootItemRow>(256);

		private bool _visible;

		private bool _built;

		private bool _builtWithPeakButtons;

		private bool _uiSceneDirty;

		private SpawnPool? _selectedPool;

		private string _listFilter = string.Empty;

		private string _detailFilter = string.Empty;

		private CursorLockMode _prevLock;

		private bool _prevCursorVisible;

		private Vector2 _frozenLookValues;

		private bool _hasFrozenLook;

		private static readonly string[] HotkeyModLabels = new string[7] { "None", "Left Ctrl", "Right Ctrl", "Left Alt", "Right Alt", "Left Shift", "Right Shift" };

		private static readonly int[] HotkeyModValues = new int[7] { 0, 306, 305, 308, 307, 304, 303 };

		public static bool IsOpen => (Object)(object)_instance != (Object)null && _instance._visible && ((Component)_instance).gameObject.activeInHierarchy;

		public static bool IsListeningForHotkey => (Object)(object)_instance != (Object)null && _instance._listenHotkey != 0;

		public static void EnsureCreated()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null))
			{
				GameObject val = new GameObject("PLI_LuggageMenu");
				Object.DontDestroyOnLoad((Object)(object)val);
				_instance = val.AddComponent<LuggageMenu>();
				val.SetActive(false);
			}
		}

		public static void Toggle()
		{
			if (Time.frameCount == _toggleFrame)
			{
				return;
			}
			_toggleFrame = Time.frameCount;
			EnsureCreated();
			if (!((Object)(object)_instance == (Object)null))
			{
				if (_instance._visible && (Object)(object)((Component)_instance).gameObject != (Object)null && ((Component)_instance).gameObject.activeInHierarchy)
				{
					_instance.CloseInternal();
				}
				else
				{
					_instance.Open();
				}
			}
		}

		public static void OnAfterSceneLoad()
		{
			IntDropdown.CloseOpen();
			ChoiceDropdown.CloseOpen();
			LuggageUi.InvalidateButtonDonor();
			if ((Object)(object)_instance == (Object)null)
			{
				EnsureCreated();
				return;
			}
			try
			{
				if (_instance._visible)
				{
					_instance.CloseInternal();
				}
			}
			catch
			{
			}
			try
			{
				GameAccess.SetMenuWindowFlags(GUIManager.instance, blocking: false, showingCursor: false);
			}
			catch
			{
			}
			try
			{
				_instance.TearDownUi();
			}
			catch
			{
			}
			_instance._visible = false;
			_instance._hasFrozenLook = false;
			_instance._selectedPool = null;
		}

		public static void Close()
		{
			if ((Object)(object)_instance != (Object)null)
			{
				_instance.CloseInternal();
			}
		}

		public static void DestroyInstance()
		{
			LuggageMenu instance = _instance;
			_instance = null;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				if ((Object)(object)((Component)instance).gameObject != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)instance).gameObject);
				}
			}
			catch
			{
			}
		}

		public static void OnCatalogReady()
		{
			if ((Object)(object)_instance != (Object)null && _instance._built)
			{
				_instance.RebuildLuggageRows();
				if (_instance._visible && _instance._selectedPool.HasValue)
				{
					_instance.RebuildLootRows();
				}
			}
		}

		internal static void InjectPauseButton(PauseMenuMainPage page)
		{
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)page == (Object)null)
			{
				return;
			}
			try
			{
				Transform val = null;
				Button val2 = GameAccess.GetPauseMenuButton(page, "m_settingsButton") ?? GameAccess.GetPauseMenuButton(page, "m_resumeButton");
				if ((Object)(object)val2 != (Object)null)
				{
					val = ((Component)val2).transform.parent;
				}
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Transform val3 = val.Find("PLI_PauseLuggageItems");
				GameObject val4 = (((Object)(object)val3 != (Object)null) ? ((Component)val3).gameObject : null);
				if ((Object)(object)val4 == (Object)null)
				{
					val4 = Object.Instantiate<GameObject>(((Component)val2).gameObject, val, false);
					((Object)val4).name = "PLI_PauseLuggageItems";
					LocalizedText[] componentsInChildren = val4.GetComponentsInChildren<LocalizedText>(true);
					foreach (LocalizedText val5 in componentsInChildren)
					{
						Object.Destroy((Object)(object)val5);
					}
					TextMeshProUGUI componentInChildren = val4.GetComponentInChildren<TextMeshProUGUI>(true);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						((TMP_Text)componentInChildren).text = "Luggage Items";
					}
					RectTransform component = val4.GetComponent<RectTransform>();
					RectTransform component2 = ((Component)val2).GetComponent<RectTransform>();
					if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
					{
						component.anchoredPosition = component2.anchoredPosition + new Vector2(0f, -112f);
					}
				}
				Button component3 = val4.GetComponent<Button>();
				if ((Object)(object)component3 != (Object)null)
				{
					((UnityEventBase)component3.onClick).RemoveAllListeners();
					((UnityEvent)component3.onClick).AddListener(new UnityAction(Toggle));
				}
				val4.SetActive(Plugin.GetShowPauseMenuButton());
			}
			catch (Exception ex)
			{
				Plugin.LogDebug("Pause button inject failed: " + ex.Message);
			}
		}

		private void Open()
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			_visible = true;
			((Component)this).gameObject.SetActive(true);
			try
			{
				if (_uiSceneDirty && _built)
				{
					TearDownUi();
				}
				_uiSceneDirty = false;
				try
				{
					LootStore.TryEnsureDefaults();
				}
				catch (Exception ex)
				{
					Plugin.LogDebug("Defaults: " + ex.Message);
				}
				int count = ItemCatalog.Count;
				try
				{
					ItemCatalog.TryRefresh();
				}
				catch (Exception ex2)
				{
					Plugin.LogDebug("Catalog refresh: " + ex2.Message);
				}
				if (ItemCatalog.Count > count)
				{
					Plugin.LogInfo("Found " + (ItemCatalog.Count - count) + " more item(s) in the loot picker (" + ItemCatalog.Count + " total).");
				}
				if (!_built)
				{
					Build();
				}
				_prevLock = Cursor.lockState;
				_prevCursorVisible = Cursor.visible;
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				ApplyMenuInputBlock(block: true);
				CaptureFrozenLook();
				ShowListPage();
				LuggageUi.ApplyAllFonts(((Component)this).transform);
				if (!ItemCatalog.IsReady && (Object)(object)_help != (Object)null)
				{
					((TMP_Text)_help).text = "Item list is still loading — open a luggage again in a moment.";
				}
			}
			catch (Exception ex3)
			{
				Plugin.LogError("Failed to open Luggage Items menu: " + ex3);
				try
				{
					TearDownUi();
					Build();
					ShowListPage();
				}
				catch (Exception ex4)
				{
					Plugin.LogError("Menu rebuild failed: " + ex4.Message);
					_visible = false;
					((Component)this).gameObject.SetActive(false);
					try
					{
						ApplyMenuInputBlock(block: false);
					}
					catch
					{
					}
				}
			}
		}

		private void CloseInternal()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (_visible)
			{
				_listenHotkey = 0;
				if ((Object)(object)_multiplierField != (Object)null && _selectedPool.HasValue)
				{
					OnMultiplierEdited(_multiplierField.text);
				}
				_visible = false;
				_selectedPool = null;
				_hasFrozenLook = false;
				DeactivateSearches();
				LuggageUi.ReleaseUiFocus();
				ApplyMenuInputBlock(block: false);
				Cursor.lockState = _prevLock;
				Cursor.visible = _prevCursorVisible;
				((Component)this).gameObject.SetActive(false);
				try
				{
					PresetStore.SaveDefault();
				}
				catch
				{
				}
				LootStore.ApplyToGame();
			}
		}

		private void TearDownUi()
		{
			for (int num = ((Component)this).transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Component)this).transform.GetChild(num)).gameObject);
			}
			_luggageRows.Clear();
			_lootRows.Clear();
			_panel = null;
			_listPage = null;
			_detailPage = null;
			_help = null;
			_detailTitle = null;
			_detailMeta = null;
			_spawnPreview = null;
			_forceCountToggle = null;
			_randomCountToggle = null;
			_forceCountDropdown = null;
			_randomCountDropdown = null;
			_multiplierField = null;
			_debugToggle = null;
			_pauseButtonToggle = null;
			_hotkeyModDropdown = null;
			_hotkeyKeyButton = null;
			_hotkeyKeyLabel = null;
			_listenHotkey = 0;
			_shareToggle = null;
			_repeatsToggle = null;
			_listSearch = null;
			_detailSearch = null;
			_presetNameField = null;
			_presetDropLabel = null;
			_presetListGo = null;
			_presetListContent = null;
			_listContent = null;
			_detailContent = null;
			_canvas = null;
			_built = false;
			_builtWithPeakButtons = false;
			_uiSceneDirty = false;
			LuggageUi.InvalidateButtonDonor();
		}

		private void Build()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if (!_built)
			{
				_built = true;
				_builtWithPeakButtons = LuggageUi.HasPeakButtonDonor();
				_canvas = LuggageUi.CreateOverlayCanvas(((Component)this).gameObject, 32000);
				_panel = LuggageUi.CreatePanel(((Component)this).transform, "Panel", new Vector2(820f, 960f), LuggageUi.PanelColor);
				LuggageUi.AddVerticalLayout(((Component)_panel).gameObject, 6f, new RectOffset(20, 20, 16, 16));
				GameObject val = new GameObject("TitleBar", new Type[1] { typeof(RectTransform) });
				val.transform.SetParent((Transform)(object)_panel, false);
				LuggageUi.MakeNonCollapsing(val, 36f);
				TextMeshProUGUI val2 = LuggageUi.CreateLabel(val.transform, "Title", "PEAK Luggage Items", 26f, (FontStyles)0, (TextAlignmentOptions)514);
				LuggageUi.Stretch(((TMP_Text)val2).rectTransform, 0f, 0f);
				LuggageUi.MakeDraggable(val, _panel);
				_help = LuggageUi.CreateLabel((Transform)(object)_panel, "Help", "Pick a luggage type. Vanilla items start checked. Weight is a relative chance — all 100s is even, they do not need to add up to 100. Closing the menu keeps your last settings as the default preset.", 15f, (FontStyles)0, (TextAlignmentOptions)514);
				((Graphic)_help).color = LuggageUi.CreamDim;
				LuggageUi.MakeNonCollapsing(((Component)_help).gameObject, 48f);
				((TMP_Text)_help).enableWordWrapping = true;
				BuildListPage();
				BuildDetailPage();
			}
		}

		private void BuildListPage()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			_listPage = new GameObject("ListPage", new Type[1] { typeof(RectTransform) });
			_listPage.transform.SetParent((Transform)(object)_panel, false);
			LayoutElement val = _listPage.AddComponent<LayoutElement>();
			val.flexibleHeight = 1f;
			val.minHeight = 520f;
			LuggageUi.AddVerticalLayout(_listPage, 8f, new RectOffset(0, 0, 0, 0));
			_debugToggle = LuggageUi.CreateToggle(_listPage.transform, "Debug logs (writes [PLI] lines to BepInEx/LogOutput.log)", Plugin.IsDebug, OnDebugToggled, 30f);
			LuggageUi.MakeNonCollapsing(((Component)_debugToggle).gameObject, 32f);
			_pauseButtonToggle = LuggageUi.CreateToggle(_listPage.transform, "Show Luggage Items on the pause menu", Plugin.GetShowPauseMenuButton(), OnPauseButtonToggled, 30f);
			LuggageUi.MakeNonCollapsing(((Component)_pauseButtonToggle).gameObject, 32f);
			BuildHotkeyRow(_listPage.transform);
			_listSearch = LuggageUi.CreateSearchField(_listPage.transform, "Search luggage...", FilterLuggage);
			BuildPresetSection(_listPage.transform);
			ScrollRect val2 = LuggageUi.CreateScrollView(_listPage.transform, out _listContent);
			((Component)val2).gameObject.AddComponent<LayoutElement>().flexibleHeight = 1f;
			LuggageUi.AddVerticalLayout(((Component)_listContent).gameObject, 4f, new RectOffset(4, 4, 4, 4));
			ContentSizeFitter val3 = ((Component)_listContent).gameObject.AddComponent<ContentSizeFitter>();
			val3.verticalFit = (FitMode)2;
			GameObject val4 = new GameObject("Footer", new Type[1] { typeof(RectTransform) });
			val4.transform.SetParent(_listPage.transform, false);
			LuggageUi.MakeNonCollapsing(val4, 44f);
			((LayoutGroup)LuggageUi.AddHorizontalLayout(val4, 10f)).childAlignment = (TextAnchor)4;
			LuggageUi.CreateButton(val4.transform, "Close", new UnityAction(CloseInternal), new Vector2(160f, 40f));
			RebuildLuggageRows();
		}

		private void BuildPresetSection(Transform parent)
		{
			//IL_001e: 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_005d: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//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_01bd: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Expected O, but got Unknown
			TextMeshProUGUI val = LuggageUi.CreateLabel(parent, "PresetHdr", "Presets", 16f, (FontStyles)0, (TextAlignmentOptions)513);
			((Graphic)val).color = LuggageUi.CreamDim;
			LuggageUi.MakeNonCollapsing(((Component)val).gameObject, 20f);
			GameObject val2 = new GameObject("PresetSave", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(parent, false);
			LuggageUi.MakeNonCollapsing(val2, 38f);
			((LayoutGroup)LuggageUi.AddHorizontalLayout(val2, 8f)).childAlignment = (TextAnchor)3;
			_presetNameField = LuggageUi.CreateTextField(val2.transform, "Preset name", 280f);
			LuggageUi.CreateButton(val2.transform, "Save preset", new UnityAction(SaveCurrentPreset), new Vector2(150f, 36f));
			GameObject val3 = new GameObject("PresetLoad", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(parent, false);
			LuggageUi.MakeNonCollapsing(val3, 38f);
			HorizontalLayoutGroup val4 = LuggageUi.AddHorizontalLayout(val3, 8f);
			((LayoutGroup)val4).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val4).childForceExpandWidth = true;
			Button val5 = LuggageUi.CreateButton(val3.transform, "Load a preset...", new UnityAction(TogglePresetList), new Vector2(360f, 36f));
			LayoutElement component = ((Component)val5).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				component.flexibleWidth = 1f;
			}
			_presetDropLabel = ((Component)val5).GetComponentInChildren<TextMeshProUGUI>(true);
			LuggageUi.CreateButton(val3.transform, "Delete", new UnityAction(DeleteSelectedPreset), new Vector2(110f, 36f));
			GameObject val6 = new GameObject("PresetList", new Type[1] { typeof(RectTransform) });
			val6.transform.SetParent(parent, false);
			LayoutElement val7 = val6.AddComponent<LayoutElement>();
			val7.minHeight = 0f;
			val7.preferredHeight = 0f;
			val7.flexibleHeight = 0f;
			_presetListGo = val6;
			ScrollRect val8 = LuggageUi.CreateScrollView(val6.transform, out _presetListContent);
			LuggageUi.Stretch(((Component)val8).GetComponent<RectTransform>(), 0f, 0f);
			LuggageUi.AddVerticalLayout(((Component)_presetListContent).gameObject, 3f, new RectOffset(4, 4, 4, 4));
			ContentSizeFitter val9 = ((Component)_presetListContent).gameObject.AddComponent<ContentSizeFitter>();
			val9.verticalFit = (FitMode)2;
			_presetListGo.SetActive(false);
			RebuildPresetList();
		}

		private void BuildDetailPage()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Expected O, but got Unknown
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Expected O, but got Unknown
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Expected O, but got Unknown
			//IL_0366: 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_03b8: Expected O, but got Unknown
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Expected O, but got Unknown
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Expected O, but got Unknown
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_0505: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Expected O, but got Unknown
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Expected O, but got Unknown
			//IL_05a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0604: Unknown result type (might be due to invalid IL or missing references)
			//IL_060e: Expected O, but got Unknown
			//IL_0622: Unknown result type (might be due to invalid IL or missing references)
			//IL_0631: Unknown result type (might be due to invalid IL or missing references)
			//IL_063b: Expected O, but got Unknown
			//IL_064f: 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_0668: Expected O, but got Unknown
			//IL_067c: Unknown result type (might be due to invalid IL or missing references)
			//IL_068b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Expected O, but got Unknown
			//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cf: Expected O, but got Unknown
			//IL_0714: 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_076f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0779: Expected O, but got Unknown
			_detailPage = new GameObject("DetailPage", new Type[1] { typeof(RectTransform) });
			_detailPage.transform.SetParent((Transform)(object)_panel, false);
			LayoutElement val = _detailPage.AddComponent<LayoutElement>();
			val.flexibleHeight = 1f;
			val.minHeight = 520f;
			LuggageUi.AddVerticalLayout(_detailPage, 6f, new RectOffset(0, 0, 0, 0));
			_detailTitle = LuggageUi.CreateLabel(_detailPage.transform, "DetailTitle", "Luggage", 22f, (FontStyles)0, (TextAlignmentOptions)514);
			LuggageUi.MakeNonCollapsing(((Component)_detailTitle).gameObject, 32f);
			_detailMeta = LuggageUi.CreateLabel(_detailPage.transform, "DetailMeta", string.Empty, 15f, (FontStyles)0, (TextAlignmentOptions)514);
			((Graphic)_detailMeta).color = LuggageUi.CreamDim;
			LuggageUi.MakeNonCollapsing(((Component)_detailMeta).gameObject, 24f);
			TextMeshProUGUI val2 = LuggageUi.CreateLabel(_detailPage.transform, "SpawnHdr", "Spawns", 18f, (FontStyles)0, (TextAlignmentOptions)513);
			((Graphic)val2).color = LuggageUi.CreamDim;
			LuggageUi.MakeNonCollapsing(((Component)val2).gameObject, 22f);
			GameObject val3 = new GameObject("CountModes", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(_detailPage.transform, false);
			LuggageUi.MakeNonCollapsing(val3, 68f);
			LuggageUi.AddVerticalLayout(val3, 4f, new RectOffset(0, 0, 0, 0));
			BuildCountModeRow(val3.transform, "Force Count", force: true);
			BuildCountModeRow(val3.transform, "Random Count", force: false);
			GameObject val4 = new GameObject("SpawnNums", new Type[1] { typeof(RectTransform) });
			val4.transform.SetParent(_detailPage.transform, false);
			LuggageUi.MakeNonCollapsing(val4, 36f);
			((LayoutGroup)LuggageUi.AddHorizontalLayout(val4, 12f)).childAlignment = (TextAnchor)3;
			_multiplierField = LuggageUi.CreateLabeledNumber(val4.transform, "Multiplier", "1", OnMultiplierEdited);
			((UnityEvent<string>)(object)_multiplierField.onValueChanged).AddListener((UnityAction<string>)OnMultiplierEdited);
			GameObject val5 = new GameObject("SpawnToggles", new Type[1] { typeof(RectTransform) });
			val5.transform.SetParent(_detailPage.transform, false);
			LuggageUi.MakeNonCollapsing(val5, 60f);
			LuggageUi.AddVerticalLayout(val5, 2f, new RectOffset(0, 0, 0, 0));
			_shareToggle = LuggageUi.CreateToggle(val5.transform, "Share with party", isOn: false, OnShareChanged);
			_repeatsToggle = LuggageUi.CreateToggle(val5.transform, "Disable duplicates", isOn: false, OnRepeatsChanged);
			_spawnPreview = LuggageUi.CreateLabel(_detailPage.transform, "SpawnPreview", string.Empty, 14f, (FontStyles)0, (TextAlignmentOptions)514);
			((Graphic)_spawnPreview).color = LuggageUi.CreamDim;
			LuggageUi.MakeNonCollapsing(((Component)_spawnPreview).gameObject, 36f);
			((TMP_Text)_spawnPreview).enableWordWrapping = true;
			GameObject val6 = new GameObject("SpawnActions", new Type[1] { typeof(RectTransform) });
			val6.transform.SetParent(_detailPage.transform, false);
			LuggageUi.MakeNonCollapsing(val6, 40f);
			((LayoutGroup)LuggageUi.AddHorizontalLayout(val6, 8f)).childAlignment = (TextAnchor)4;
			LuggageUi.CreateButton(val6.transform, "Copy settings", new UnityAction(CopySettings), new Vector2(170f, 36f));
			LuggageUi.CreateButton(val6.transform, "Paste settings", new UnityAction(PasteSettings), new Vector2(170f, 36f));
			TextMeshProUGUI val7 = LuggageUi.CreateLabel(_detailPage.transform, "WeightHint", "Weight is relative, not a percent. 100 and 100 is 50/50. All 100s is even.", 14f, (FontStyles)0, (TextAlignmentOptions)514);
			((Graphic)val7).color = LuggageUi.CreamDim;
			LuggageUi.MakeNonCollapsing(((Component)val7).gameObject, 22f);
			_detailSearch = LuggageUi.CreateSearchField(_detailPage.transform, "Search items...", FilterLoot);
			ScrollRect val8 = LuggageUi.CreateScrollView(_detailPage.transform, out _detailContent);
			((Component)val8).gameObject.AddComponent<LayoutElement>().flexibleHeight = 1f;
			LuggageUi.AddVerticalLayout(((Component)_detailContent).gameObject, 4f, new RectOffset(4, 4, 4, 4));
			ContentSizeFitter val9 = ((Component)_detailContent).gameObject.AddComponent<ContentSizeFitter>();
			val9.verticalFit = (FitMode)2;
			GameObject val10 = new GameObject("Actions", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val10.transform.SetParent(_detailPage.transform, false);
			Image component = val10.GetComponent<Image>();
			component.sprite = LuggageUi.WhiteSprite();
			((Graphic)component).color = new Color(0.08f, 0.06f, 0.05f, 0.96f);
			((Graphic)component).raycastTarget = true;
			LuggageUi.MakeNonCollapsing(val10, 44f);
			((LayoutGroup)LuggageUi.AddHorizontalLayout(val10, 8f)).childAlignment = (TextAnchor)4;
			LuggageUi.CreateButton(val10.transform, "Select all", new UnityAction(SelectAllItems), new Vector2(140f, 40f));
			LuggageUi.CreateButton(val10.transform, "Equal chances", new UnityAction(SetCheckedTo100), new Vector2(170f, 40f));
			LuggageUi.CreateButton(val10.transform, "Clear", new UnityAction(ClearSelected), new Vector2(100f, 40f));
			LuggageUi.CreateButton(val10.transform, "Reset vanilla", new UnityAction(ResetSelected), new Vector2(160f, 40f));
			GameObject val11 = new GameObject("Footer", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val11.transform.SetParent(_detailPage.transform, false);
			Image component2 = val11.GetComponent<Image>();
			component2.sprite = LuggageUi.WhiteSprite();
			((Graphic)component2).color = new Color(0.08f, 0.06f, 0.05f, 0.96f);
			((Graphic)component2).raycastTarget = true;
			LuggageUi.MakeNonCollapsing(val11, 44f);
			((LayoutGroup)LuggageUi.AddHorizontalLayout(val11, 10f)).childAlignment = (TextAnchor)4;
			LuggageUi.CreateButton(val11.transform, "Back", new UnityAction(ShowListPage), new Vector2(160f, 40f));
			_detailPage.SetActive(false);
		}

		private void RebuildLuggageRows()
		{
			//IL_0099: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: 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_0183: 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_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _luggageRows.Count; i++)
			{
				if ((Object)(object)_luggageRows[i] != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_luggageRows[i]).gameObject);
				}
			}
			_luggageRows.Clear();
			if ((Object)(object)_listContent == (Object)null)
			{
				return;
			}
			IReadOnlyList<LuggageEntry> all = LuggageCatalog.All;
			for (int j = 0; j < all.Count; j++)
			{
				LuggageEntry luggageEntry = all[j];
				SpawnPool pool = luggageEntry.Pool;
				GameObject val = new GameObject("Luggage_" + luggageEntry.EnumName, new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(Button)
				});
				val.transform.SetParent((Transform)(object)_listContent, false);
				LuggageUi.MakeNonCollapsing(val, 44f);
				Image component = val.GetComponent<Image>();
				component.sprite = LuggageUi.WhiteSprite();
				((Graphic)component).color = LuggageUi.ButtonColor;
				Button component2 = val.GetComponent<Button>();
				((Selectable)component2).targetGraphic = (Graphic)(object)component;
				ColorBlock colors = ((Selectable)component2).colors;
				((ColorBlock)(ref colors)).normalColor = LuggageUi.ButtonColor;
				((ColorBlock)(ref colors)).highlightedColor = LuggageUi.ButtonHover;
				((ColorBlock)(ref colors)).pressedColor = LuggageUi.AccentOn;
				((ColorBlock)(ref colors)).selectedColor = LuggageUi.ButtonHover;
				((Selectable)component2).colors = colors;
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					OpenDetail(pool);
				});
				HorizontalLayoutGroup val2 = LuggageUi.AddHorizontalLayout(val, 10f);
				((LayoutGroup)val2).padding = new RectOffset(12, 12, 4, 4);
				((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = true;
				((LayoutGroup)val2).childAlignment = (TextAnchor)3;
				TextMeshProUGUI val3 = LuggageUi.CreateLabel(val.transform, "Name", luggageEntry.DisplayName, 18f, (FontStyles)0, (TextAlignmentOptions)513);
				LayoutElement val4 = ((Component)val3).gameObject.AddComponent<LayoutElement>();
				val4.flexibleWidth = 1f;
				val4.minWidth = 160f;
				TextMeshProUGUI val5 = LuggageUi.CreateLabel(val.transform, "Meta", string.Empty, 15f, (FontStyles)0, (TextAlignmentOptions)516);
				((Graphic)val5).color = LuggageUi.CreamDim;
				LayoutElement val6 = ((Component)val5).gameObject.AddComponent<LayoutElement>();
				val6.preferredWidth = 220f;
				val6.minWidth = 160f;
				val6.flexibleWidth = 0f;
				LuggageRow luggageRow = val.AddComponent<LuggageRow>();
				luggageRow.Pool = pool;
				luggageRow.NameLabel = val3;
				luggageRow.MetaLabel = val5;
				_luggageRows.Add(luggageRow);
			}
			RefreshLuggageMeta();
			FilterLuggage(_listFilter);
			Canvas.ForceUpdateCanvases();
			LuggageUi.ApplyAllFonts((Transform)(object)_listContent);
		}

		private void RebuildLootRows()
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _lootRows.Count; i++)
			{
				if ((Object)(object)_lootRows[i] != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)((Component)_lootRows[i]).gameObject);
				}
			}
			_lootRows.Clear();
			if ((Object)(object)_detailContent == (Object)null || !_selectedPool.HasValue)
			{
				return;
			}
			for (int num = ((Transform)_detailContent).childCount - 1; num >= 0; num--)
			{
				Object.DestroyImmediate((Object)(object)((Component)((Transform)_detailContent).GetChild(num)).gameObject);
			}
			CreateLootHeader((Transform)(object)_detailContent);
			SpawnPool value = _selectedPool.Value;
			Dictionary<ushort, LootEntry> dictionary = new Dictionary<ushort, LootEntry>();
			List<LootEntry> effectiveItems = LootStore.GetEffectiveItems(value);
			for (int j = 0; j < effectiveItems.Count; j++)
			{
				dictionary[effectiveItems[j].Id] = effectiveItems[j];
			}
			List<LootItemRow> list = new List<LootItemRow>(ItemCatalog.Count + effectiveItems.Count);
			HashSet<ushort> hashSet = new HashSet<ushort>();
			IReadOnlyList<CatalogItem> items = ItemCatalog.Items;
			for (int k = 0; k < items.Count; k++)
			{
				CatalogItem catalogItem = items[k];
				if (catalogItem != null && !hashSet.Contains(catalogItem.Id))
				{
					hashSet.Add(catalogItem.Id);
					list.Add(CreateLootRow(value, catalogItem.Id, dictionary));
				}
			}
			for (int l = 0; l < effectiveItems.Count; l++)
			{
				ushort id = effectiveItems[l].Id;
				if (!hashSet.Contains(id))
				{
					hashSet.Add(id);
					list.Add(CreateLootRow(value, id, dictionary));
				}
			}
			list.Sort(delegate(LootItemRow a, LootItemRow b)
			{
				if (a.Enabled != b.Enabled)
				{
					return (!a.Enabled) ? 1 : (-1);
				}
				string strA = (((Object)(object)a.NameLabel != (Object)null) ? ((TMP_Text)a.NameLabel).text : ItemCatalog.GetName(a.ItemId));
				string strB = (((Object)(object)b.NameLabel != (Object)null) ? ((TMP_Text)b.NameLabel).text : ItemCatalog.GetName(b.ItemId));
				return string.Compare(strA, strB, StringComparison.OrdinalIgnoreCase);
			});
			for (int num2 = 0; num2 < list.Count; num2++)
			{
				((Component)list[num2]).transform.SetSiblingIndex(num2 + 1);
			}
			_lootRows.AddRange(list);
			RefreshDetailMeta();
			FilterLoot(_detailFilter);
			Canvas.ForceUpdateCanvases();
			LuggageUi.ApplyAllFonts((Transform)(object)_detailContent);
		}

		private static void CreateLootHeader(Transform parent)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_00e2: 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_019d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("LootHeader", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			LuggageUi.MakeNonCollapsing(val, 24f);
			HorizontalLayoutGroup val2 = LuggageUi.AddHorizontalLayout(val, 8f);
			((LayoutGroup)val2).childAlignment = (TextAnchor)3;
			((LayoutGroup)val2).padding = new RectOffset(2, 2, 0, 0);
			GameObject val3 = new GameObject("CheckSpace", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val.transform, false);
			LayoutElement val4 = val3.AddComponent<LayoutElement>();
			val4.minWidth = 26f;
			val4.preferredWidth = 26f;
			val4.flexibleWidth = 0f;
			TextMeshProUGUI val5 = LuggageUi.CreateLabel(val.transform, "ItemHdr", "Item", 14f, (FontStyles)0, (TextAlignmentOptions)513);
			((Graphic)val5).color = LuggageUi.CreamDim;
			LayoutElement val6 = ((Component)val5).gameObject.AddComponent<LayoutElement>();
			val6.flexibleWidth = 1f;
			val6.minWidth = 180f;
			TextMeshProUGUI val7 = LuggageUi.CreateLabel(val.transform, "ChanceHdr", "Chance", 14f, (FontStyles)0, (TextAlignmentOptions)516);
			((Graphic)val7).color = LuggageUi.CreamDim;
			LayoutElement val8 = ((Component)val7).gameObject.AddComponent<LayoutElement>();
			val8.preferredWidth = 70f;
			val8.minWidth = 70f;
			val8.flexibleWidth = 0f;
			TextMeshProUGUI val9 = LuggageUi.CreateLabel(val.transform, "WeightHdr", "Weight", 14f, (FontStyles)0, (TextAlignmentOptions)514);
			((Graphic)val9).color = LuggageUi.CreamDim;
			LayoutElement val10 = ((Component)val9).gameObject.AddComponent<LayoutElement>();
			val10.preferredWidth = 88f;
			val10.minWidth = 88f;
			val10.flexibleWidth = 0f;
		}

		private LootItemRow CreateLootRow(SpawnPool pool, ushort id, Dictionary<ushort, LootEntry> effective)
		{
			//IL_0055: 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_00aa: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: 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)
			LootEntry value;
			bool flag = effective.TryGetValue(id, out value) && value.Weight > 0;
			bool flag2 = flag && value.IsCustom;
			int weight;
			string value2 = (flag ? value.Weight.ToString() : ((!LootStore.TryGetVanillaWeight(pool, id, out weight)) ? string.Empty : weight.ToString()));
			GameObject val = new GameObject("Loot_" + id, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent((Transform)(object)_detailContent, false);
			LuggageUi.MakeNonCollapsing(val, 40f);
			HorizontalLayoutGroup val2 = LuggageUi.AddHorizontalLayout(val, 8f);
			((LayoutGroup)val2).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
			Toggle enabledToggle = LuggageUi.CreateCheckBox(val.transform, flag, delegate(bool on)
			{
				OnItemEnabled(id, on);
			});
			TextMeshProUGUI val3 = LuggageUi.CreateLabel(val.transform, "Name", ItemCatalog.GetName(id), 17f, (FontStyles)0, (TextAlignmentOptions)513);
			((Graphic)val3).color = ((!flag) ? LuggageUi.CreamDim : (flag2 ? LuggageUi.EditedColor : LuggageUi.Cream));
			LayoutElement val4 = ((Component)val3).gameObject.AddComponent<LayoutElement>();
			val4.flexibleWidth = 1f;
			val4.minWidth = 180f;
			TextMeshProUGUI val5 = LuggageUi.CreateLabel(val.transform, "Odds", flag ? "—" : "off", 15f, (FontStyles)0, (TextAlignmentOptions)516);
			((Graphic)val5).color = LuggageUi.CreamDim;
			LayoutElement val6 = ((Component)val5).gameObject.AddComponent<LayoutElement>();
			val6.preferredWidth = 70f;
			val6.minWidth = 70f;
			val6.flexibleWidth = 0f;
			TMP_InputField weightField = LuggageUi.CreateNumberField(val.transform, value2, delegate(string raw)
			{
				OnWeightEdited(id, raw);
			}, 88f);
			LootItemRow lootItemRow = val.AddComponent<LootItemRow>();
			lootItemRow.ItemId = id;
			lootItemRow.Enabled = flag;
			lootItemRow.Custom = flag2;
			lootItemRow.EnabledToggle = enabledToggle;
			lootItemRow.WeightField = weightField;
			lootItemRow.NameLabel = val3;
			lootItemRow.OddsLabel = val5;
			return lootItemRow;
		}

		private void OpenDetail(SpawnPool pool)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_selectedPool = pool;
			ShowDetailPage();
		}

		private void ShowListPage()
		{
			_selectedPool = null;
			DeactivateSearches();
			if ((Object)(object)_detailPage != (Object)null)
			{
				_detailPage.SetActive(false);
			}
			if ((Object)(object)_listPage != (Object)null)
			{
				_listPage.SetActive(true);
			}
			RefreshLuggageMeta();
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = (ItemCatalog.IsReady ? "Pick a luggage type. Vanilla items start checked. Weight is a relative chance — all 100s is even, they do not need to add up to 100. Closing the menu keeps your last settings as the default preset." : "Item list is still loading — open a luggage again in a moment.");
			}
			ClosePresetList();
			RebuildPresetList();
			IntDropdown.CloseOpen();
			ChoiceDropdown.CloseOpen();
			LuggageUi.SetToggleVisual(_debugToggle, Plugin.IsDebug);
			LuggageUi.SetToggleVisual(_pauseButtonToggle, Plugin.GetShowPauseMenuButton());
			RefreshHotkeyRow();
		}

		private void ShowDetailPage()
		{
			DeactivateSearches();
			if ((Object)(object)_listPage != (Object)null)
			{
				_listPage.SetActive(false);
			}
			if ((Object)(object)_detailPage != (Object)null)
			{
				_detailPage.SetActive(true);
			}
			RebuildLootRows();
			SyncSpawnSettings();
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = (LootStore.HasVanillaSnapshot ? "Vanilla items start checked. Edit any weight — they do not need to add up to 100. Next luggage opened uses these tables." : "Defaults are still loading. Start one climb if this is the first launch; after that they persist. You can still check items now.");
			}
		}

		private void OnItemEnabled(ushort id, bool enabled)
		{
			//IL_001e: 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 (_selectedPool.HasValue)
			{
				int weightIfEnabled = LootStore.GetSuggestedWeight(_selectedPool.Value, id);
				LootItemRow lootItemRow = FindLootRow(id);
				if ((Object)(object)lootItemRow?.WeightField != (Object)null && int.TryParse(lootItemRow.WeightField.text, out var result) && result > 0)
				{
					weightIfEnabled = result;
				}
				LootStore.SetEnabled(_selectedPool.Value, id, enabled, weightIfEnabled);
				if ((Object)(object)lootItemRow != (Object)null)
				{
					lootItemRow.Enabled = enabled;
				}
				RefreshLootVisuals();
			}
		}

		private void OnWeightEdited(ushort id, string raw)
		{
			//IL_008d: 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)
			if (!_selectedPool.HasValue || !int.TryParse(raw, out var result))
			{
				return;
			}
			result = Mathf.Clamp(result, 0, 9999);
			LootItemRow lootItemRow = FindLootRow(id);
			if (result <= 0)
			{
				LootStore.SetEnabled(_selectedPool.Value, id, enabled: false, 0);
				if ((Object)(object)lootItemRow != (Object)null)
				{
					lootItemRow.Enabled = false;
					LuggageUi.SetToggleVisual(lootItemRow.EnabledToggle, isOn: false);
				}
			}
			else
			{
				LootStore.SetWeight(_selectedPool.Value, id, result);
			}
			RefreshLootVisuals();
		}

		private void OnPauseButtonToggled(bool value)
		{
			Plugin.SetShowPauseMenuButton(value);
			RefreshPauseButton();
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = (value ? "Pause menu button is ON. The hotkey still works either way." : ("Pause menu button is OFF. Open with " + Plugin.FormatHotkey() + "."));
			}
		}

		internal static void RefreshPauseButton()
		{
			try
			{
				PauseMenuMainPage val = Object.FindFirstObjectByType<PauseMenuMainPage>((FindObjectsInactive)1);
				if ((Object)(object)val != (Object)null)
				{
					InjectPauseButton(val);
				}
			}
			catch
			{
			}
		}

		private void OnDebugToggled(bool value)
		{
			Plugin.SetDebug(value);
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = (value ? "Debug is ON. Open a luggage as host, then open BepInEx/LogOutput.log and search for [PLI]." : "Pick a luggage type. Vanilla items start checked. Weight is a relative chance — all 100s is even, they do not need to add up to 100. Closing the menu keeps your last settings as the default preset.");
			}
		}

		private void BuildHotkeyRow(Transform parent)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected I4, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			GameObject val = new GameObject("HotkeyRow", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			LuggageUi.MakeNonCollapsing(val, 38f);
			HorizontalLayoutGroup val2 = LuggageUi.AddHorizontalLayout(val, 8f);
			((LayoutGroup)val2).childAlignment = (TextAnchor)3;
			TextMeshProUGUI val3 = LuggageUi.CreateLabel(val.transform, "HotkeyLbl", "Open menu", 16f, (FontStyles)0, (TextAlignmentOptions)513);
			LayoutElement val4 = ((Component)val3).gameObject.AddComponent<LayoutElement>();
			val4.minWidth = 90f;
			val4.preferredWidth = 90f;
			val4.flexibleWidth = 0f;
			_hotkeyModDropdown = LuggageUi.CreateChoiceDropdown(val.transform, HotkeyModLabels, HotkeyModValues, (int)Plugin.GetMenuModifier(), OnHotkeyModifierPicked);
			_hotkeyKeyButton = LuggageUi.CreateButton(val.transform, Plugin.PrettyKey(Plugin.GetMenuKey()), new UnityAction(BeginListenMenuKey), new Vector2(130f, 34f));
			_hotkeyKeyLabel = ((Component)_hotkeyKeyButton).GetComponentInChildren<TextMeshProUGUI>(true);
		}

		private void RefreshHotkeyRow()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected I4, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			_listenHotkey = 0;
			if ((Object)(object)_hotkeyModDropdown != (Object)null)
			{
				_hotkeyModDropdown.SetValue((int)Plugin.GetMenuModifier());
			}
			if ((Object)(object)_hotkeyKeyLabel != (Object)null)
			{
				((TMP_Text)_hotkeyKeyLabel).text = Plugin.PrettyKey(Plugin.GetMenuKey());
			}
		}

		private void OnHotkeyModifierPicked(int value)
		{
			Plugin.SetMenuModifier((KeyCode)value);
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = "Menu hotkey is now " + Plugin.FormatHotkey() + ". Also available from the pause menu.";
			}
		}

		private void BeginListenMenuKey()
		{
			IntDropdown.CloseOpen();
			ChoiceDropdown.CloseOpen();
			_listenHotkey = 1;
			if ((Object)(object)_hotkeyKeyLabel != (Object)null)
			{
				((TMP_Text)_hotkeyKeyLabel).text = "Press a key...";
			}
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = "Press the key to open this menu. Esc cancels.";
			}
		}

		private void FinishListenMenuKey(KeyCode key)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0010: 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)
			_listenHotkey = 0;
			if ((int)key > 0)
			{
				Plugin.SetMenuKey(key);
			}
			if ((Object)(object)_hotkeyKeyLabel != (Object)null)
			{
				((TMP_Text)_hotkeyKeyLabel).text = Plugin.PrettyKey(Plugin.GetMenuKey());
			}
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = "Menu hotkey is now " + Plugin.FormatHotkey() + ". Also available from the pause menu.";
			}
		}

		private static KeyCode ReadPressedKey()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected I4, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
			{
				int num = (int)value;
				if ((int)value == 0 || (int)value == 27 || (num >= 323 && num <= 329) || !Input.GetKeyDown(value))
				{
					continue;
				}
				return value;
			}
			return (KeyCode)0;
		}

		private bool BeginBulkLootAction()
		{
			IntDropdown.CloseOpen();
			ChoiceDropdown.CloseOpen();
			DeactivateSearches();
			if (_selectedPool.HasValue)
			{
				return true;
			}
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = "Pick a luggage type first.";
			}
			return false;
		}

		private void SelectAllItems()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (BeginBulkLootAction())
			{
				try
				{
					LootStore.EnableAll(_selectedPool.Value);
				}
				catch (Exception ex)
				{
					Plugin.LogError("Select all failed: " + ex.Message);
				}
				RebuildLootRows();
			}
		}

		private void SetCheckedTo100()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (BeginBulkLootAction())
			{
				try
				{
					LootStore.SetAllEnabledWeights(_selectedPool.Value, 100);
				}
				catch (Exception ex)
				{
					Plugin.LogError("Equal chances failed: " + ex.Message);
				}
				RebuildLootRows();
			}
		}

		private void ClearSelected()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (BeginBulkLootAction())
			{
				try
				{
					LootStore.ClearPool(_selectedPool.Value);
				}
				catch (Exception ex)
				{
					Plugin.LogError("Clear failed: " + ex.Message);
				}
				RebuildLootRows();
			}
		}

		private void ResetSelected()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (BeginBulkLootAction())
			{
				try
				{
					LootStore.ResetPool(_selectedPool.Value);
				}
				catch (Exception ex)
				{
					Plugin.LogError("Reset vanilla failed: " + ex.Message);
				}
				RebuildLootRows();
				SyncSpawnSettings();
			}
		}

		private void BuildCountModeRow(Transform parent, string label, bool force)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			GameObject val = new GameObject(force ? "ForceCount" : "RandomCount", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			LuggageUi.MakeNonCollapsing(val, 32f);
			HorizontalLayoutGroup val2 = LuggageUi.AddHorizontalLayout(val, 8f);
			((LayoutGroup)val2).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = true;
			Toggle val3 = LuggageUi.CreateToggle(val.transform, label, isOn: false, force ? new UnityAction<bool>(OnForceCountChanged) : new UnityAction<bool>(OnRandomCountChanged), 30f);
			IntDropdown intDropdown = LuggageUi.CreateIntDropdown(val.transform, 1, 3, 3, OnCountValueChanged, 72f, 30f);
			if (force)
			{
				_forceCountToggle = val3;
				_forceCountDropdown = intDropdown;
			}
			else
			{
				_randomCountToggle = val3;
				_randomCountDropdown = intDropdown;
			}
		}

		private void OnForceCountChanged(bool value)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (_selectedPool.HasValue)
			{
				LootStore.SetForceCount(_selectedPool.Value, value);
				SyncSpawnSettings();
			}
		}

		private void OnRandomCountChanged(bool value)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (_selectedPool.HasValue)
			{
				LootStore.SetRandomCount(_selectedPool.Value, value);
				SyncSpawnSettings();
			}
		}

		private void OnCountValueChanged(int value)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (_selectedPool.HasValue)
			{
				LootStore.SetCountValue(_selectedPool.Value, value);
				SyncSpawnSettings();
			}
		}

		private void OnMultiplierEdited(string raw)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (_selectedPool.HasValue)
			{
				if (!int.TryParse(raw, out var result))
				{
					result = 1;
				}
				LootStore.SetMultiplier(_selectedPool.Value, result);
				SyncSpawnSettings();
			}
		}

		private void OnShareChanged(bool value)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (_selectedPool.HasValue)
			{
				LootStore.SetShareWithParty(_selectedPool.Value, value);
				SyncSpawnSettings();
			}
		}

		private void OnRepeatsChanged(bool value)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (_selectedPool.HasValue)
			{
				LootStore.SetDisableDuplicates(_selectedPool.Value, value);
				SyncSpawnSettings();
			}
		}

		private void CopySettings()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (_selectedPool.HasValue)
			{
				LootStore.CopyPool(_selectedPool.Value);
				if ((Object)(object)_help != (Object)null)
				{
					((TMP_Text)_help).text = "Copied this luggage's items, weights, and spawn settings. Open another luggage and press Paste settings.";
				}
			}
		}

		private void PasteSettings()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if (!_selectedPool.HasValue)
			{
				return;
			}
			if (!LootStore.PastePool(_selectedPool.Value))
			{
				if ((Object)(object)_help != (Object)null)
				{
					((TMP_Text)_help).text = "Nothing to paste yet. Copy settings from a luggage first.";
				}
				return;
			}
			RebuildLootRows();
			SyncSpawnSettings();
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = "Pasted settings onto " + LuggageCatalog.GetDisplayName(_selectedPool.Value) + ".";
			}
		}

		private void SaveCurrentPreset()
		{
			string name = (((Object)(object)_presetNameField != (Object)null) ? _presetNameField.text : string.Empty);
			if (!PresetStore.Save(name, out var error))
			{
				if ((Object)(object)_help != (Object)null)
				{
					((TMP_Text)_help).text = error;
				}
				return;
			}
			_selectedPreset = PresetStore.Sanitize(name);
			if ((Object)(object)_presetNameField != (Object)null)
			{
				_presetNameField.SetTextWithoutNotify(_selectedPreset);
			}
			UpdatePresetDropLabel();
			RebuildPresetList();
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = "Saved preset \"" + _selectedPreset + "\" in the Presets folder next to the plugin.";
			}
		}

		private void TogglePresetList()
		{
			if ((Object)(object)_presetListGo == (Object)null)
			{
				return;
			}
			if (_presetListGo.activeSelf)
			{
				ClosePresetList();
				return;
			}
			RebuildPresetList();
			_presetListGo.SetActive(true);
			LayoutElement component = _presetListGo.GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				int count = PresetStore.ListNames().Count;
				component.minHeight = ((count == 0) ? 40f : Mathf.Min(160f, 8f + (float)count * 38f));
				component.preferredHeight = component.minHeight;
			}
		}

		private void ClosePresetList()
		{
			if (!((Object)(object)_presetListGo == (Object)null))
			{
				_presetListGo.SetActive(false);
				LayoutElement component = _presetListGo.GetComponent<LayoutElement>();
				if ((Object)(object)component != (Object)null)
				{
					component.minHeight = 0f;
					component.preferredHeight = 0f;
				}
			}
		}

		private void RebuildPresetList()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			if ((Object)(object)_presetListContent == (Object)null)
			{
				return;
			}
			for (int num = ((Transform)_presetListContent).childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Transform)_presetListContent).GetChild(num)).gameObject);
			}
			List<string> list = PresetStore.ListNames();
			if (list.Count == 0)
			{
				TextMeshProUGUI val = LuggageUi.CreateLabel((Transform)(object)_presetListContent, "Empty", "No presets saved yet.", 15f, (FontStyles)2, (TextAlignmentOptions)514);
				((Graphic)val).color = LuggageUi.CreamDim;
				LuggageUi.MakeNonCollapsing(((Component)val).gameObject, 32f);
			}
			else
			{
				for (int i = 0; i < list.Count; i++)
				{
					string preset = list[i];
					string label = (PresetStore.IsDefaultName(preset) ? "default (last used)" : preset);
					LuggageUi.CreateButton((Transform)(object)_presetListContent, label, (UnityAction)delegate
					{
						LoadPreset(preset);
					}, new Vector2(520f, 34f));
				}
			}
			UpdatePresetDropLabel();
			Canvas.ForceUpdateCanvases();
			LuggageUi.ApplyAllFonts((Transform)(object)_presetListContent);
		}

		private void LoadPreset(string name)
		{
			if (!PresetStore.Load(name, out var error))
			{
				if ((Object)(object)_help != (Object)null)
				{
					((TMP_Text)_help).text = error;
				}
				return;
			}
			_selectedPreset = PresetStore.Sanitize(name);
			if ((Object)(object)_presetNameField != (Object)null)
			{
				_presetNameField.SetTextWithoutNotify(_selectedPreset);
			}
			UpdatePresetDropLabel();
			ClosePresetList();
			RebuildLuggageRows();
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = "Loaded preset \"" + _selectedPreset + "\".";
			}
		}

		private void DeleteSelectedPreset()
		{
			string name = ((!string.IsNullOrEmpty(_selectedPreset)) ? _selectedPreset : (((Object)(object)_presetNameField != (Object)null) ? _presetNameField.text : string.Empty));
			if (!PresetStore.Delete(name, out var error))
			{
				if ((Object)(object)_help != (Object)null)
				{
					((TMP_Text)_help).text = error;
				}
				return;
			}
			if ((Object)(object)_help != (Object)null)
			{
				((TMP_Text)_help).text = "Deleted preset \"" + PresetStore.Sanitize(name) + "\".";
			}
			if (string.Equals(_selectedPreset, PresetStore.Sanitize(name), StringComparison.OrdinalIgnoreCase))
			{
				_selectedPreset = string.Empty;
			}
			UpdatePresetDropLabel();
			RebuildPresetList();
		}

		private void UpdatePresetDropLabel()
		{
			if (!((Object)(object)_presetDropLabel == (Object)null))
			{
				((TMP_Text)_presetDropLabel).text = (string.IsNullOrEmpty(_selectedPreset) ? "Load a preset..." : _selectedPreset);
			}
		}

		private void SyncSpawnSettings()
		{
			//IL_001e: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			if (_selectedPool.HasValue)
			{
				PoolSpawnSettings spawnSettings = LootStore.GetSpawnSettings(_selectedPool.Value);
				int maxSpotCount = LootStore.GetMaxSpotCount(_selectedPool.Value);
				int countValue = LootStore.GetCountValue(_selectedPool.Value);
				if ((Object)(object)_forceCountDropdown != (Object)null)
				{
					_forceCountDropdown.SetRange(1, maxSpotCount, countValue);
				}
				if ((Object)(object)_randomCountDropdown != (Object)null)
				{
					_randomCountDropdown.SetRange(1, maxSpotCount, countValue);
				}
				LuggageUi.SetToggleVisual(_forceCountToggle, spawnSettings.ForceCount);
				LuggageUi.SetToggleVisual(_randomCountToggle, spawnSettings.RandomCount);
				LuggageUi.SetToggleInteractable(_forceCountToggle, !spawnSettings.RandomCount);
				LuggageUi.SetToggleInteractable(_randomCountToggle, !spawnSettings.ForceCount);
				if ((Object)(object)_multiplierField != (Object)null)
				{
					_multiplierField.SetTextWithoutNotify(Mathf.Max(1, spawnSettings.Multiplier).ToString());
				}
				LuggageUi.SetToggleVisual(_shareToggle, spawnSettings.ShareWithParty);
				LuggageUi.SetToggleVisual(_repeatsToggle, spawnSettings.DisableDuplicates);
				LuggageUi.SetToggleInteractable(_shareToggle, !spawnSettings.DisableDuplicates);
				LuggageUi.SetToggleInteractable(_repeatsToggle, !spawnSettings.ShareWithParty);
				RefreshSpawnPreview();
			}
		}

		private void RefreshSpawnPreview()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_0144: 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_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_spawnPreview == (Object)null) && _selectedPool.HasValue)
			{
				SpawnPool value = _selectedPool.Value;
				PoolSpawnSettings spawnSettings = LootStore.GetSpawnSettings(value);
				int roomPlayerCount = LuggageSpawnPatches.GetRoomPlayerCount();
				int countValue = LootStore.GetCountValue(value);
				string text = (spawnSettings.ForceCount ? ("always uses " + countValue + " spot" + ((countValue == 1) ? "" : "s")) : ((!spawnSettings.RandomCount) ? "uses each luggage's vanilla spots" : ("randomly uses 1 to " + countValue + " spot" + ((countValue == 1) ? "" : "s"))));
				if (spawnSettings.Multiplier > 1)
				{
					text = text + " ×" + spawnSettings.Multiplier;
				}
				string text2 = (spawnSettings.ShareWithParty ? (" Then copies each item for every extra player (" + roomPlayerCount + " in room → ×" + roomPlayerCount + ").") : string.Empty);
				string text3 = string.Empty;
				if (spawnSettings.DisableDuplicates)
				{
					text3 += (LootStore.ShouldAllowRepeats(value, LootStore.GetWantedSpawnCount(value, countValue, countValue)) ? " No duplicates unless more items are needed than unique checked items." : " No duplicate items.");
				}
				else if (spawnSettings.Multiplier > 1 || spawnSettings.ForceCount || spawnSettings.RandomCount)
				{
					text3 += " Same item can drop more than once.";
				}
				((TMP_Text)_spawnPreview).text = text + "." + text2 + text3;
				((Graphic)_spawnPreview).color = (LootStore.HasSpawnEdits(value) ? LuggageUi.EditedColor : LuggageUi.CreamDim);
			}
		}

		private void RefreshLuggageMeta()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _luggageRows.Count; i++)
			{
				LuggageRow luggageRow = _luggageRows[i];
				if ((Object)(object)luggageRow == (Object)null || (Object)(object)luggageRow.MetaLabel == (Object)null)
				{
					continue;
				}
				int count = LootStore.GetEffectiveItems(luggageRow.Pool).Count;
				bool flag = LootStore.IsEdited(luggageRow.Pool);
				string text;
				if (!LootStore.HasVanillaSnapshot && !flag)
				{
					text = "vanilla pending";
				}
				else
				{
					text = count + ((count == 1) ? " item" : " items");
					PoolSpawnSettings spawnSettings = LootStore.GetSpawnSettings(luggageRow.Pool);
					if (spawnSettings.ForceCount)
					{
						text = text + "  ·  force " + LootStore.GetCountValue(luggageRow.Pool);
					}
					else if (spawnSettings.RandomCount)
					{
						text = text + "  ·  random 1-" + LootStore.GetCountValue(luggageRow.Pool);
					}
					else if (spawnSettings.Multiplier > 1)
					{
						text = text + "  ·  " + spawnSettings.Multiplier + "×";
					}
					if (spawnSettings.ShareWithParty)
					{
						text += "  ·  party";
					}
					if (flag)
					{
						text += "  ·  edited";
					}
				}
				((TMP_Text)luggageRow.MetaLabel).text = text;
				((Graphic)luggageRow.MetaLabel).color = (flag ? LuggageUi.EditedColor : LuggageUi.CreamDim);
			}
		}

		private LootItemRow FindLootRow(ushort id)
		{
			for (int i = 0; i < _lootRows.Count; i++)
			{
				if ((Object)(object)_lootRows[i] != (Object)null && _lootRows[i].ItemId == id)
				{
					return _lootRows[i];
				}
			}
			return null;
		}

		private void RefreshLootVisuals()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: 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)
			if (!_selectedPool.HasValue)
			{
				return;
			}
			Dictionary<ushort, LootEntry> dictionary = new Dictionary<ushort, LootEntry>();
			List<LootEntry> effectiveItems = LootStore.GetEffectiveItems(_selectedPool.Value);
			for (int i = 0; i < effectiveItems.Count; i++)
			{
				dictionary[effectiveItems[i].Id] = effectiveItems[i];
			}
			for (int j = 0; j < _lootRows.Count; j++)
			{
				LootItemRow lootItemRow = _lootRows[j];
				if (!((Object)(object)lootItemRow == (Object)null))
				{
					LootEntry value;
					bool flag = dictionary.TryGetValue(lootItemRow.ItemId, out value) && value.Weight > 0;
					bool flag2 = flag && value.IsCustom;
					lootItemRow.Enabled = flag;
					lootItemRow.Custom = flag2;
					LuggageUi.SetToggleVisual(lootItemRow.EnabledToggle, flag);
					if ((Object)(object)lootItemRow.NameLabel != (Object)null)
					{
						((Graphic)lootItemRow.NameLabel).color = ((!flag) ? LuggageUi.CreamDim : (flag2 ? LuggageUi.EditedColor : LuggageUi.Cream));
					}
					if (flag && (Object)(object)lootItemRow.WeightField != (Object)null)
					{
						lootItemRow.WeightField.SetTextWithoutNotify(value.Weight.ToString());
					}
				}
			}
			RefreshDetailMeta();
		}

		private void RefreshDetailMeta()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_00a9: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			if (!_selectedPool.HasValue)
			{
				return;
			}
			SpawnPool value = _selectedPool.Value;
			if ((Object)(object)_detailTitle != (Object)null)
			{
				((TMP_Text)_detailTitle).text = LuggageCatalog.GetDisplayName(value);
			}
			int num = 0;
			for (int i = 0; i < _lootRows.Count; i++)
			{
				if ((Object)(object)_lootRows[i] != (Object)null && _lootRows[i].Enabled)
				{
					num++;
				}
			}
			int totalWeight = LootStore.GetTotalWeight(value);
			bool flag = LootStore.IsEdited(value);
			if ((Object)(object)_detailMeta != (Object)null)
			{
				((TMP_Text)_detailMeta).text = num + " on  ·  " + _lootRows.Count + " in game  ·  total weight " + totalWeight + (flag ? "  ·  edited" : string.Empty);
				((Graphic)_detailMeta).color = (flag ? LuggageUi.EditedColor : LuggageUi.CreamDim);
			}
			RefreshOdds();
		}

		private void RefreshOdds()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!_selectedPool.HasValue)
			{
				return;
			}
			int totalWeight = LootStore.GetTotalWeight(_selectedPool.Value);
			for (int i = 0; i < _lootRows.Count; i++)
			{
				LootItemRow lootItemRow = _lootRows[i];
				if ((Object)(object)lootItemRow?.OddsLabel == (Object)null)
				{
					continue;
				}
				if (!lootItemRow.Enabled)
				{
					((TMP_Text)lootItemRow.OddsLabel).text = "off";
					continue;
				}
				int result = 0;
				if ((Object)(object)lootItemRow.WeightField != (Object)null)
				{
					int.TryParse(lootItemRow.WeightField.text, out result);
				}
				((TMP_Text)lootItemRow.OddsLabel).text = FormatOdds(result, totalWeight);
			}
		}

		private static string FormatOdds(int weight, int total)
		{
			if (weight <= 0 || total <= 0)
			{
				return "0%";
			}
			return (100f * (float)weight / (float)total).ToString("0.#") + "%";
		}

		private void FilterLuggage(string filter)
		{
			_listFilter = filter ?? string.Empty;
			string text = _listFilter.Trim();
			for (int i = 0; i < _luggageRows.Count; i++)
			{
				LuggageRow luggageRow = _luggageRows[i];
				if (!((Object)(object)luggageRow == (Object)null))
				{
					string text2 = (((Object)(object)luggageRow.NameLabel != (Object)null) ? ((TMP_Text)luggageRow.NameLabel).text : string.Empty);
					bool flag = text.Length == 0 || text2.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0;
					if (((Component)luggageRow).gameObject.activeSelf != flag)
					{
						((Component)luggageRow).gameObject.SetActive(flag);
					}
				}
			}
		}

		private void FilterLoot(string filter)
		{
			_detailFilter = filter ?? string.Empty;
			string text = _detailFilter.Trim();
			for (int i = 0; i < _lootRows.Count; i++)
			{
				LootItemRow lootItemRow = _lootRows[i];
				if (!((Object)(object)lootItemRow == (Object)null))
				{
					string text2 = (((Object)(object)lootItemRow.NameLabel != (Object)null) ? ((TMP_Text)lootItemRow.NameLabel).text : ItemCatalog.GetName(lootItemRow.ItemId));
					bool flag = text.Length == 0 || text2.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0;
					if (((Component)lootItemRow).gameObject.activeSelf != flag)
					{
						((Component)lootItemRow).gameObject.SetActive(flag);
					}
				}
			}
		}

		private void DeactivateSearches()
		{
			if ((Object)(object)_listSearch != (Object)null)
			{
				_listSearch.DeactivateInputField(false);
			}
			if ((Object)(object)_detailSearch != (Object)null)
			{
				_detailSearch.DeactivateInputField(false);
			}
			if ((Object)(object)_presetNameField != (Object)null)
			{
				_presetNameField.DeactivateInputField(false);
			}
			if ((Object)(object)_multiplierField != (Object)null)
			{
				_multiplierField.DeactivateInputField(false);
			}
			LuggageUi.ReleaseUiFocus();
		}

		private void Update()
		{
			//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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!_visible)
			{
				return;
			}
			if (_listenHotkey != 0)
			{
				if (Input.GetKeyDown((KeyCode)27))
				{
					FinishListenMenuKey((KeyCode)0);
					return;
				}
				KeyCode val = ReadPressedKey();
				if ((int)val > 0)
				{
					FinishListenMenuKey(val);
				}
			}
			else if (Input.GetKeyDown((KeyCode)27))
			{
				if (_selectedPool.HasValue)
				{
					ShowListPage();
				}
				else
				{
					CloseInternal();
				}
			}
		}

		private void LateUpdate()
		{
			if (_visible)
			{
				HoldFrozenLook();
			}
		}

		private void CaptureFrozenLook()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if (!((Object)(object)localCharacter?.data == (Object)null))
			{
				_frozenLookValues = localCharacter.data.lookValues;
				_hasFrozenLook = true;
			}
		}

		private void HoldFrozenLook()
		{
			//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)
			if (_hasFrozenLook)
			{
				Character localCharacter = Character.localCharacter;
				if (!((Object)(object)localCharacter?.data == (Object)null))
				{
					localCharacter.data.lookValues = _frozenLookValues;
				}
			}
		}

		private static void ApplyMenuInputBlock(bool block)
		{
			GUIManager instance = GUIManager.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				GameAccess.SetMenuWindowFlags(instance, block, block);
			}
		}
	}
}