using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExtraPotions.Kindle.Config;
using ExtraPotions.Kindle.Recipes;
using ExtraPotions.Kindle.Repair;
using ExtraPotions.Kindle.Runtime.Salvage;
using ExtraPotions.Kindle.Salvage;
using ExtraPotions.Meadworks.Contracts;
using ExtraPotions.Meadworks.Crucible;
using ExtraPotions.Meadworks.Crucible.UI;
using HarmonyLib;
using Jotunn.Extensions;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using YamlDotNet.Serialization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: IgnoresAccessChecksTo("assembly_utils")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ExtraPotions")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (C) 2026 expDARE (ExtraPotions Meadworks)")]
[assembly: AssemblyFileVersion("0.1.25.0")]
[assembly: AssemblyInformationalVersion("0.1.25")]
[assembly: AssemblyProduct("Kindle")]
[assembly: AssemblyTitle("Kindle")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.25.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ExtraPotions.Kindle.Runtime
{
	public static class BatchAmount
	{
		private static Recipe recipe;

		public static int Value { get; private set; } = 1;

		public static Recipe Current => recipe;

		internal static void Reset()
		{
			recipe = null;
			Value = 1;
		}

		public static bool Applies(InventoryGui gui, Player player)
		{
			if (!KindleBatch.Active || SalvageTabCapability.Active || !KindleBatch.Config.Get<bool>(Batch.Enabled) || (Object)(object)gui == (Object)null || (Object)(object)player == (Object)null || !gui.InCraftTab())
			{
				return false;
			}
			CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
			if (!((Object)(object)currentCraftingStation == (Object)null))
			{
				return !currentCraftingStation.m_upgrader;
			}
			return true;
		}

		public static void Follow(Player player, Recipe selected)
		{
			if ((Object)(object)selected != (Object)(object)recipe)
			{
				recipe = selected;
				Value = 1;
			}
			if ((Object)(object)recipe != (Object)null && Value > 1 && !CanMake(player, recipe, Value))
			{
				Value = Limit(player, recipe);
			}
		}

		public static bool CanStepUp(Player player)
		{
			if ((Object)(object)recipe != (Object)null)
			{
				return CanMake(player, recipe, Value + 1);
			}
			return false;
		}

		public static int NextCraft(InventoryGui gui, Player player)
		{
			if (Applies(gui, player))
			{
				return Value;
			}
			if (!ZInput.GetButton("AltPlace") && !ZInput.GetButton("JoyLStick") && !gui.m_touchMultiCrafting)
			{
				return 1;
			}
			return gui.m_multiCraftAmount;
		}

		public static void Set(int typed)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)recipe == (Object)null))
			{
				Value = Mathf.Clamp(typed, 1, Limit(localPlayer, recipe));
			}
		}

		public static bool CanMake(Player player, Recipe made, int amount)
		{
			if (amount <= 1)
			{
				return true;
			}
			if (amount > KindleBatch.Config.Get<int>(Batch.MaxAmount))
			{
				return false;
			}
			return BatchCheck.HaveAndFit(player, made, amount);
		}

		public static int Limit(Player player, Recipe made)
		{
			int num = 1;
			int num2 = KindleBatch.Config.Get<int>(Batch.MaxAmount);
			while (num < num2)
			{
				int num3 = (num + num2 + 1) / 2;
				if (CanMake(player, made, num3))
				{
					num = num3;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return num;
		}
	}
	internal static class BatchCheck
	{
		private const float MaxAge = 0.25f;

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

		private static Recipe forRecipe;

		private static CraftingStation forStation;

		private static Player forPlayer;

		private static int forChange = -1;

		private static float since = float.MinValue;

		public static bool HaveAndFit(Player player, Recipe made, int amount)
		{
			Expire(player, made);
			if (answers.TryGetValue(amount, out var value))
			{
				return value;
			}
			value = Ask(player, made, amount);
			answers[amount] = value;
			return value;
		}

		private static bool Ask(Player player, Recipe made, int amount)
		{
			if (!player.NoCostCheat() && (!((Object)(object)ZoneSystem.instance != (Object)null) || !ZoneSystem.instance.GetGlobalKey((GlobalKeys)25)) && !player.HaveRequirements(made, false, 1, amount))
			{
				return false;
			}
			return ((Humanoid)player).GetInventory().CanAddItem(((Component)made.m_item).gameObject, made.m_amount * amount);
		}

		private static void Expire(Player player, Recipe made)
		{
			CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
			float unscaledTime = Time.unscaledTime;
			if (!((Object)(object)made == (Object)(object)forRecipe) || !((Object)(object)currentCraftingStation == (Object)(object)forStation) || !((Object)(object)player == (Object)(object)forPlayer) || KindleBatch.InventoryChanges != forChange || !(unscaledTime - since < 0.25f))
			{
				answers.Clear();
				forRecipe = made;
				forStation = currentCraftingStation;
				forPlayer = player;
				forChange = KindleBatch.InventoryChanges;
				since = unscaledTime;
			}
		}
	}
	public static class BatchDrive
	{
		private static int gameAmount = 5;

		private static bool driving;

		private static int started;

		public static void Remember(InventoryGui gui)
		{
			gameAmount = gui.m_multiCraftAmount;
			driving = false;
			started = 0;
		}

		public static void Drive(InventoryGui gui, int amount)
		{
			gui.m_multiCraftAmount = amount;
			gui.m_touchMultiCrafting = amount > 1;
			driving = true;
		}

		public static void Release(InventoryGui gui)
		{
			if (driving)
			{
				driving = false;
				gui.m_multiCraftAmount = gameAmount;
				gui.m_touchMultiCrafting = false;
			}
		}

		public static void Started(InventoryGui gui, int amount)
		{
			started = amount;
			gui.m_multiCrafting = amount > 1;
		}

		public static void Forget()
		{
			started = 0;
		}

		public static void Restore(InventoryGui gui)
		{
			if (started > 0)
			{
				gui.m_multiCraftAmount = started;
				gui.m_multiCrafting = started > 1;
			}
		}
	}
	public static class CraftSpeed
	{
		private static float craft = 2f;

		private static float multi = 6f;

		private static float upgrader = 8f;

		private static float perLevel = 1f;

		public static void Remember(InventoryGui gui)
		{
			craft = gui.m_craftDuration;
			multi = gui.m_multiCraftDuration;
			upgrader = gui.m_upgraderDuration;
			perLevel = gui.m_upgraderDurationPerLevel;
		}

		public static void Apply(InventoryGui gui)
		{
			float craftSpeed = KindleBatch.Config.CraftSpeed;
			bool instantCrafting = KindleBatch.Config.InstantCrafting;
			gui.m_craftDuration = KindleCheats.CraftDuration(craft, craftSpeed, instantCrafting);
			gui.m_multiCraftDuration = KindleCheats.CraftDuration(multi, craftSpeed, instantCrafting);
			gui.m_upgraderDuration = KindleCheats.CraftDuration(upgrader, craftSpeed, instantCrafting);
			gui.m_upgraderDurationPerLevel = KindleCheats.CraftDuration(perLevel, craftSpeed, instantCrafting);
		}

		internal static void ApplySafe(InventoryGui gui)
		{
			gui.m_craftDuration = craft;
			gui.m_multiCraftDuration = multi;
			gui.m_upgraderDuration = upgrader;
			gui.m_upgraderDurationPerLevel = perLevel;
		}
	}
	public static class KindleBatch
	{
		internal static KindleConfig Config;

		internal static int InventoryChanges;

		private static MeadworksLog log;

		private static Harmony patches;

		private static InventoryGui owner;

		private static KitStepper stepper;

		private static RectTransform craft;

		private static Vector2 originalMin;

		private static Vector2 originalMax;

		private static float trim;

		private static bool laidOut;

		private const float CaptionPadding = 12f;

		private const float MinRowHeight = 30f;

		public static bool Active
		{
			get
			{
				if (Config != null && Plugin.GameplayAvailable && Plugin.AllowsUi && Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return Object.op_Implicit((Object)(object)ZNet.instance);
				}
				return false;
			}
		}

		public static int Amount => BatchAmount.Value;

		public static bool Shown
		{
			get
			{
				if (stepper != null)
				{
					return stepper.Shown;
				}
				return false;
			}
		}

		public static int NextCraft(InventoryGui gui, Player player)
		{
			if (!Object.op_Implicit((Object)(object)gui) || !Object.op_Implicit((Object)(object)player))
			{
				return 1;
			}
			return BatchAmount.NextCraft(gui, player);
		}

		public static void Initialize(KindleConfig config, MeadworksLog logger)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			Shutdown();
			Config = config;
			log = logger;
			patches = new Harmony("com.meadworks.kindle.batch");
			patches.CreateClassProcessor(typeof(KindleBatchPatches)).Patch();
			if (Object.op_Implicit((Object)(object)InventoryGui.instance))
			{
				Remember(InventoryGui.instance);
			}
		}

		internal static void Guard(Action action)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				MeadworksLog obj = log;
				if (obj != null)
				{
					obj.Warning("Batch crafting: " + ex.GetType().Name + ": " + ex.Message);
				}
			}
		}

		internal static void Remember(InventoryGui gui)
		{
			ClearUi();
			owner = gui;
			BatchDrive.Remember(gui);
			CraftSpeed.Remember(gui);
			BatchAmount.Reset();
		}

		internal static void BeforeRecipe(InventoryGui gui, Player player)
		{
			if ((Object)(object)owner != (Object)(object)gui)
			{
				Remember(gui);
			}
			if (!Active)
			{
				BatchDrive.Release(gui);
				CraftSpeed.ApplySafe(gui);
				return;
			}
			CraftSpeed.Apply(gui);
			if (!BatchAmount.Applies(gui, player))
			{
				BatchDrive.Release(gui);
				return;
			}
			BatchAmount.Follow(player, ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe);
			BatchDrive.Drive(gui, BatchAmount.Value);
		}

		internal static void Refresh(InventoryGui gui, Player player)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			if (!Active)
			{
				RestoreCraft();
				return;
			}
			if ((Object)(object)owner != (Object)(object)gui)
			{
				Remember(gui);
			}
			if (stepper == null && Object.op_Implicit((Object)(object)gui.m_craftButton))
			{
				craft = (RectTransform)((Component)gui.m_craftButton).transform;
				originalMin = craft.offsetMin;
				originalMax = craft.offsetMax;
				Rect rect = craft.rect;
				float height = ((Rect)(ref rect)).height;
				float num = RowHeight(craft, height);
				trim = (height - num) * 0.5f;
				stepper = KitStepper.Create((RectTransform)((Transform)craft).parent, "Kindle_batch", Vector2.zero, num, 1, 9999);
				if (stepper == null)
				{
					return;
				}
				stepper.Changed += BatchAmount.Set;
			}
			bool num2 = BatchAmount.Applies(gui, player) && gui.m_craftTimer < 0f;
			Show(num2);
			if (!num2 || stepper == null)
			{
				return;
			}
			bool flag = Object.op_Implicit((Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe);
			int num3 = ((!flag) ? 1 : BatchAmount.Limit(player, ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe));
			stepper.Follow(num3);
			stepper.Set(BatchAmount.Value);
			((Selectable)stepper.Less).interactable = flag && BatchAmount.Value > 1;
			((Selectable)stepper.More).interactable = flag && BatchAmount.CanStepUp(player);
			stepper.Field.SetUsable(flag);
			stepper.PadSteps = ZInput.IsGamepadActive() && gui.m_activeGroup == 3;
			if (flag)
			{
				TMP_Text componentInChildren = ((Component)gui.m_craftButton).GetComponentInChildren<TMP_Text>(true);
				if (componentInChildren != null)
				{
					componentInChildren.text = Localization.instance.Localize("$inventory_craftbutton");
				}
			}
		}

		private static float RowHeight(RectTransform button, float native)
		{
			TMP_Text componentInChildren = ((Component)button).GetComponentInChildren<TMP_Text>(true);
			float num = (((Object)(object)componentInChildren == (Object)null) ? 0f : componentInChildren.fontSize);
			float num2 = Mathf.Max(30f, num + 12f);
			if (!(native > 0f))
			{
				return num2;
			}
			return Mathf.Min(num2, native);
		}

		private static void Show(bool show)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			if (stepper != null && Object.op_Implicit((Object)(object)craft))
			{
				float num = (show ? (stepper.Root.sizeDelta.x + 6f) : 0f);
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(originalMin.x + num, originalMin.y + trim);
				Vector2 val2 = default(Vector2);
				((Vector2)(ref val2))..ctor(originalMax.x, originalMax.y - trim);
				if (craft.offsetMin != val)
				{
					craft.offsetMin = val;
				}
				if (craft.offsetMax != val2)
				{
					craft.offsetMax = val2;
				}
				laidOut = true;
				RectTransform root = stepper.Root;
				Vector2 anchorMin = (root.anchorMax = craft.anchorMin);
				root.anchorMin = anchorMin;
				root.pivot = new Vector2(0f, 0f);
				root.anchoredPosition = new Vector2(originalMin.x, originalMin.y + trim);
				float x = root.sizeDelta.x;
				Rect rect = craft.rect;
				root.sizeDelta = new Vector2(x, ((Rect)(ref rect)).height);
				stepper.Show(show);
			}
		}

		private static void RestoreCraft()
		{
			//IL_0018: 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 (laidOut && Object.op_Implicit((Object)(object)craft))
			{
				craft.offsetMin = originalMin;
				craft.offsetMax = originalMax;
			}
			laidOut = false;
			KitStepper obj = stepper;
			if (obj != null)
			{
				obj.Show(false);
			}
		}

		public static void Tick()
		{
			if (!Active)
			{
				RestoreCraft();
			}
			else if ((Object)(object)owner != (Object)(object)InventoryGui.instance && Object.op_Implicit((Object)(object)InventoryGui.instance))
			{
				Guard(delegate
				{
					Remember(InventoryGui.instance);
				});
			}
		}

		private static void ClearUi()
		{
			RestoreCraft();
			KitStepper obj = stepper;
			if (obj != null)
			{
				obj.Destroy();
			}
			stepper = null;
			craft = null;
			trim = 0f;
		}

		public static void Shutdown()
		{
			if (Object.op_Implicit((Object)(object)owner))
			{
				BatchDrive.Release(owner);
				CraftSpeed.ApplySafe(owner);
			}
			ClearUi();
			owner = null;
			BatchDrive.Forget();
			BatchAmount.Reset();
			Harmony obj = patches;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			patches = null;
			Config = null;
			log = null;
		}
	}
	[HarmonyPatch]
	internal static class KindleBatchPatches
	{
		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		[HarmonyPostfix]
		private static void Awake(InventoryGui __instance)
		{
			KindleBatch.Guard(delegate
			{
				KindleBatch.Remember(__instance);
			});
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipe")]
		[HarmonyPrefix]
		private static void BeforeRecipe(InventoryGui __instance, Player player)
		{
			KindleBatch.Guard(delegate
			{
				KindleBatch.BeforeRecipe(__instance, player);
			});
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipe")]
		[HarmonyPostfix]
		private static void AfterRecipe(InventoryGui __instance, Player player)
		{
			KindleBatch.Guard(delegate
			{
				KindleBatch.Refresh(__instance, player);
			});
		}

		[HarmonyPatch(typeof(InventoryGui), "OnCraftPressed")]
		[HarmonyPrefix]
		private static void BeforePressed(InventoryGui __instance, out int __state)
		{
			__state = 0;
			BatchDrive.Forget();
			if (KindleBatch.Active && !(__instance.m_craftTimer >= 0f) && BatchAmount.Applies(__instance, Player.m_localPlayer))
			{
				BatchAmount.Follow(Player.m_localPlayer, ((RecipeDataPair)(ref __instance.m_selectedRecipe)).Recipe);
				BatchDrive.Drive(__instance, BatchAmount.Value);
				__state = BatchAmount.Value;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnCraftPressed")]
		[HarmonyPostfix]
		private static void AfterPressed(InventoryGui __instance, int __state)
		{
			if (__state > 0 && __instance.m_craftTimer >= 0f)
			{
				BatchDrive.Started(__instance, __state);
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void BeforeCraft(InventoryGui __instance)
		{
			BatchDrive.Restore(__instance);
		}

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		[HarmonyFinalizer]
		private static void AfterCraft()
		{
			BatchDrive.Forget();
		}

		[HarmonyPatch(typeof(Inventory), "Changed")]
		[HarmonyPrefix]
		private static void Changed()
		{
			KindleBatch.InventoryChanges++;
		}
	}
	public static class KindleCarts
	{
		[HarmonyPatch(typeof(Vagon), "Awake")]
		private static class AwakePatch
		{
			[HarmonyPostfix]
			private static void Postfix(Vagon __instance)
			{
				Apply(__instance);
			}
		}

		[HarmonyPatch(typeof(Vagon), "Interact")]
		private static class InteractPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(Vagon __instance, Humanoid character, bool hold, bool alt, ref bool __result)
			{
				if (hold || !alt || !Enabled)
				{
					return true;
				}
				Apply(__instance);
				CraftingStation component = ((Component)__instance).GetComponent<CraftingStation>();
				if (!IsCart(component))
				{
					return true;
				}
				if (!settings.TryUseCheat((KindleSetting)(object)Cart.CartWorkbench))
				{
					return true;
				}
				__result = component.Interact(character, false, false);
				return false;
			}
		}

		[HarmonyPatch(typeof(Vagon), "GetHoverText")]
		private static class HoverPatch
		{
			[HarmonyPostfix]
			private static void Postfix(Vagon __instance, ref string __result)
			{
				if (Enabled && IsCart(((Component)__instance).GetComponent<CraftingStation>()))
				{
					__result = __result + Localization.instance.Localize("\n[<color=yellow><b>$KEY_AltPlace + $KEY_Use</b></color>] ") + KindleText.Text("cartcraft");
				}
			}
		}

		[HarmonyPatch(typeof(CraftingStation), "GetLevel")]
		private static class LevelPatch
		{
			[HarmonyPostfix]
			private static void Postfix(CraftingStation __instance, ref int __result)
			{
				if (Enabled && IsCart(__instance))
				{
					__result += Math.Max(1, settings.Get<int>(Cart.CartStationLevel)) - 1;
				}
			}
		}

		private static readonly HashSet<CraftingStation> added = new HashSet<CraftingStation>();

		private static KindleConfig? settings;

		private static MeadworksLog? log;

		private static Harmony? patches;

		private static float nextScan;

		private static bool previousEnabled;

		private static float previousRange;

		internal static bool Enabled
		{
			get
			{
				if (Plugin.Ready && settings != null)
				{
					return settings.Get<bool>(Cart.CartWorkbench);
				}
				return false;
			}
		}

		public static void Initialize(KindleConfig config, MeadworksLog logger)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			Shutdown();
			settings = config;
			log = logger;
			nextScan = 0f;
			settings.Changed += OnSettingsChanged;
			patches = new Harmony("com.meadworks.kindle.carts");
			Type[] array = new Type[4]
			{
				typeof(AwakePatch),
				typeof(InteractPatch),
				typeof(HoverPatch),
				typeof(LevelPatch)
			};
			foreach (Type type in array)
			{
				patches.CreateClassProcessor(type).Patch();
			}
		}

		private static void OnSettingsChanged(object sender, EventArgs args)
		{
			try
			{
				foreach (Vagon item in new List<Vagon>(Vagon.m_instances))
				{
					Apply(item);
				}
			}
			catch (Exception ex)
			{
				MeadworksLog? obj = log;
				if (obj != null)
				{
					obj.Warning("Cart station refresh refused: " + ex.GetType().Name);
				}
			}
		}

		public static void Tick()
		{
			if (settings == null)
			{
				return;
			}
			bool enabled = Enabled;
			float num = settings.Get<float>(Cart.CartStationRange);
			if (enabled == previousEnabled && num == previousRange && Time.unscaledTime < nextScan)
			{
				return;
			}
			previousEnabled = enabled;
			previousRange = num;
			nextScan = Time.unscaledTime + 0.5f;
			foreach (Vagon item in new List<Vagon>(Vagon.m_instances))
			{
				Apply(item);
			}
			added.RemoveWhere((CraftingStation station) => (Object)(object)station == (Object)null);
		}

		public static void Shutdown()
		{
			Harmony? obj = patches;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			patches = null;
			if (settings != null)
			{
				settings.Changed -= OnSettingsChanged;
			}
			foreach (CraftingStation item in added)
			{
				if (Object.op_Implicit((Object)(object)item))
				{
					Object.Destroy((Object)(object)item);
				}
			}
			added.Clear();
			settings = null;
			log = null;
			previousEnabled = false;
			previousRange = 0f;
			nextScan = 0f;
		}

		internal static bool IsCart(CraftingStation station)
		{
			if (Object.op_Implicit((Object)(object)station))
			{
				return added.Contains(station);
			}
			return false;
		}

		internal static void Apply(Vagon cart)
		{
			if (settings == null || !Object.op_Implicit((Object)(object)cart) || !Object.op_Implicit((Object)(object)cart.m_nview) || cart.m_nview.GetZDO() == null)
			{
				return;
			}
			CraftingStation component = ((Component)cart).GetComponent<CraftingStation>();
			if (!Enabled)
			{
				if (IsCart(component))
				{
					added.Remove(component);
					Object.Destroy((Object)(object)component);
				}
				return;
			}
			if (Object.op_Implicit((Object)(object)component))
			{
				if (IsCart(component))
				{
					component.m_rangeBuild = settings.Get<float>(Cart.CartStationRange);
				}
				return;
			}
			GameObject val = (Object.op_Implicit((Object)(object)ZNetScene.instance) ? ZNetScene.instance.GetPrefab("piece_workbench") : null);
			CraftingStation val2 = (Object.op_Implicit((Object)(object)val) ? val.GetComponentInChildren<CraftingStation>(true) : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				MeadworksLog? obj = log;
				if (obj != null)
				{
					obj.Warning("The workbench prefab has no crafting station; carts stay plain carts.");
				}
			}
			else
			{
				component = ((Component)cart).gameObject.AddComponent<CraftingStation>();
				Copy(val2, component, ((Component)cart).transform);
				added.Add(component);
			}
		}

		private static void Copy(CraftingStation from, CraftingStation to, Transform cart)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			to.m_name = from.m_name;
			to.m_icon = from.m_icon;
			to.m_discoverRange = from.m_discoverRange;
			to.m_rangeBuild = settings.Get<float>(Cart.CartStationRange);
			to.m_extraRangePerLevel = from.m_extraRangePerLevel;
			to.m_craftRequireRoof = false;
			to.m_craftRequireFire = false;
			to.m_roofCheckPoint = cart;
			to.m_connectionPoint = null;
			to.m_showBasicRecipies = from.m_showBasicRecipies;
			to.m_useDistance = Mathf.Max(from.m_useDistance, 4f);
			to.m_craftingSkill = from.m_craftingSkill;
			to.m_hoverOffset = from.m_hoverOffset;
			to.m_hasCraftTab = from.m_hasCraftTab;
			to.m_canRepair = from.m_canRepair;
			to.m_upgrader = false;
			to.m_craftItemEffects = from.m_craftItemEffects;
			to.m_craftItemDoneEffects = from.m_craftItemDoneEffects;
			to.m_repairItemDoneEffects = from.m_repairItemDoneEffects;
			to.m_craftItemDoneFailEffects = from.m_craftItemDoneFailEffects;
		}
	}
	public static class KindleStationReach
	{
		[HarmonyPatch(typeof(CraftingStation), "InUseDistance")]
		private static class DistancePatch
		{
			[HarmonyPostfix]
			private static void Postfix(CraftingStation __instance, Humanoid human, ref bool __result)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				if (__result || !Object.op_Implicit((Object)(object)__instance) || !Object.op_Implicit((Object)(object)human) || (Object)(object)human != (Object)(object)Player.m_localPlayer)
				{
					return;
				}
				try
				{
					float multiplier = Multiplier;
					if (multiplier > 1f)
					{
						__result = Vector3.Distance(((Component)human).transform.position, ((Component)__instance).transform.position) < __instance.m_useDistance * multiplier;
					}
				}
				catch (Exception ex)
				{
					KindleSalvage.Warn("Station use distance: " + ex.GetType().Name + ": " + ex.Message);
				}
			}
		}

		private static KindleConfig? settings;

		private static Harmony? patches;

		private static float Multiplier
		{
			get
			{
				if (settings == null || !Plugin.GameplayAvailable)
				{
					return 1f;
				}
				return settings.Get<float>(Stations.UseDistance);
			}
		}

		public static void Initialize(KindleConfig config)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Shutdown();
			settings = config;
			patches = new Harmony("com.meadworks.kindle.stationreach");
			patches.CreateClassProcessor(typeof(DistancePatch)).Patch();
		}

		public static void Shutdown()
		{
			Harmony? obj = patches;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			patches = null;
			settings = null;
		}
	}
	public static class KindleVirtualStation
	{
		[HarmonyPatch(typeof(Player), "SetCraftingStation")]
		private static class RememberPatch
		{
			[HarmonyPostfix]
			private static void Postfix(Player __instance, CraftingStation station)
			{
				//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)
				try
				{
					if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)station) && !((Object)(object)station == (Object)(object)active) && !KindleCarts.IsCart(station))
					{
						ZNetView componentInParent = ((Component)station).GetComponentInParent<ZNetView>();
						ZDO val = ((Object.op_Implicit((Object)(object)componentInParent) && componentInParent.IsValid()) ? componentInParent.GetZDO() : null);
						if (val != null)
						{
							remembered = val.m_uid;
						}
					}
				}
				catch (Exception ex)
				{
					KindleSalvage.Warn("Virtual Workbench: " + ex.GetType().Name + ": " + ex.Message);
				}
			}
		}

		[HarmonyPatch(typeof(CraftingStation), "InUseDistance")]
		private static class DistancePatch
		{
			[HarmonyPrefix]
			private static bool Prefix(CraftingStation __instance, Humanoid human, ref bool __result)
			{
				if ((Object)(object)active == (Object)null || (Object)(object)__instance != (Object)(object)active || (Object)(object)human != (Object)(object)Player.m_localPlayer || !Enabled)
				{
					return true;
				}
				__result = true;
				return false;
			}
		}

		private static KindleConfig? settings;

		private static Harmony? patches;

		private static ZDOID remembered = ZDOID.None;

		private static CraftingStation? active;

		internal static bool Enabled
		{
			get
			{
				if (Plugin.GameplayAvailable && settings != null)
				{
					return settings.Get<bool>(VirtualWorkbench.Enabled);
				}
				return false;
			}
		}

		public static void Initialize(KindleConfig config)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Shutdown();
			settings = config;
			patches = new Harmony("com.meadworks.kindle.virtualstation");
			patches.CreateClassProcessor(typeof(RememberPatch)).Patch();
			patches.CreateClassProcessor(typeof(DistancePatch)).Patch();
		}

		public static void Shutdown()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Release(close: true);
			Harmony? obj = patches;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			patches = null;
			settings = null;
			remembered = ZDOID.None;
		}

		public static void Tick()
		{
			//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)
			if (settings == null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)active != (Object)null)
			{
				if (!Object.op_Implicit((Object)(object)localPlayer) || (Object)(object)localPlayer.GetCurrentCraftingStation() != (Object)(object)active)
				{
					active = null;
				}
				else if (!Enabled)
				{
					Release(close: true);
				}
			}
			if (!Object.op_Implicit((Object)(object)localPlayer) || InventoryGui.IsVisible() || !MeadworksInput.Allows((InputContext)0))
			{
				return;
			}
			KeyboardShortcut val = settings.Shortcut(VirtualWorkbench.Key);
			if (((KeyboardShortcut)(ref val)).IsDown())
			{
				if (!Enabled)
				{
					((Character)localPlayer).Message((MessageType)2, KindleText.Text("virtualoff"), 0, (Sprite)null, false);
				}
				else
				{
					Open(localPlayer);
				}
			}
		}

		private static void Open(Player player)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!((Character)player).IsDead() && !((Character)player).IsTeleporting() && !((Character)player).InCutscene() && !((Character)player).InPlaceMode())
			{
				CraftingStation val = Find(remembered);
				if (!Object.op_Implicit((Object)(object)val))
				{
					((Character)player).Message((MessageType)2, KindleText.Text("virtualnone"), 0, (Sprite)null, false);
				}
				else if (val.CheckUsable(player, true))
				{
					active = val;
					player.SetCraftingStation(val);
					InventoryGui.instance.Show((Container)null, 3);
				}
			}
		}

		private static CraftingStation? Find(ZDOID id)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (id == ZDOID.None || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			GameObject val = ZNetScene.instance.FindInstance(id);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			return val.GetComponentInChildren<CraftingStation>();
		}

		private static void Release(bool close)
		{
			Player localPlayer = Player.m_localPlayer;
			if (close && Object.op_Implicit((Object)(object)active) && Object.op_Implicit((Object)(object)localPlayer) && (Object)(object)localPlayer.GetCurrentCraftingStation() == (Object)(object)active)
			{
				localPlayer.SetCraftingStation((CraftingStation)null);
				if (Object.op_Implicit((Object)(object)InventoryGui.instance) && InventoryGui.IsVisible())
				{
					InventoryGui.instance.Hide();
				}
			}
			active = null;
		}
	}
	public sealed class KindleConfig
	{
		public const string LockedValuesKey = "Locked Player Values";

		private const string Product = "com.meadworks.kindle";

		private const float RefreshSeconds = 0.5f;

		private static readonly HashSet<KindleSetting> Shortcuts = BuildShortcuts();

		private readonly ConfigFile file;

		private readonly Dictionary<KindleSetting, ConfigEntryBase> entries = new Dictionary<KindleSetting, ConfigEntryBase>();

		private readonly Dictionary<ConfigEntryBase, KindleSetting> settingsByEntry = new Dictionary<ConfigEntryBase, KindleSetting>();

		private readonly ConfigurationManagerAttributes nearbyTag = new ConfigurationManagerAttributes();

		private float nextRefresh;

		public PadButton? GamepadSortButton
		{
			get
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				KindleSetting<string> gamepadSortButton = RecipeList.GamepadSortButton;
				string text = Get<string>(gamepadSortButton);
				if (text.Length == 0)
				{
					return null;
				}
				PadButton value = default(PadButton);
				if (GamepadMap.TryParse(text, ref value))
				{
					return value;
				}
				if (!GamepadMap.TryParse(gamepadSortButton.Default, ref value))
				{
					return null;
				}
				return value;
			}
		}

		public float CraftSpeed => Get<float>(Batch.CraftSpeed);

		public bool InstantCrafting => Get<bool>(Batch.InstantCrafting);

		public bool CartWorkbench => Get<bool>(Cart.CartWorkbench);

		public LockList Locks => LockList.Empty;

		public event EventHandler? Changed;

		private static HashSet<KindleSetting> BuildShortcuts()
		{
			_ = KindleSettings.All;
			return new HashSet<KindleSetting>
			{
				(KindleSetting)(object)RecipeList.SearchKey,
				(KindleSetting)(object)RecipeList.FavouriteRecipeKey,
				(KindleSetting)(object)Salvage.SalvageKey,
				(KindleSetting)(object)VirtualWorkbench.Key
			};
		}

		private void OnSettingChanged(object sender, SettingChangedEventArgs args)
		{
			this.Changed?.Invoke(this, EventArgs.Empty);
		}

		private KindleConfig(ConfigFile file, MeadworksLog log)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			KindleConfig kindleConfig = this;
			this.file = file;
			bool saveOnConfigSet = file.SaveOnConfigSet;
			file.SaveOnConfigSet = false;
			try
			{
				foreach (KindleSetting item in KindleSettings.All)
				{
					BindSetting(item);
				}
				ConfigDescription description = entries[(KindleSetting)(object)Tracker.CountNearbyChests].Description;
				typeof(ConfigDescription).GetField("<Tags>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(description, description.Tags.Concat(new object[1] { nearbyTag }).ToArray());
				ConfigurationManagerAttributes val = new ConfigurationManagerAttributes
				{
					Browsable = false,
					ReadOnly = true
				};
				ConfigFileExtensions.BindConfig<string>(file, "Server", "Locked Player Values", "", "Retained compatibility carrier. Client-local settings always use their own values.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, val);
				MeadworksConfig.EnsureSchema(file, 1, (IReadOnlyList<MigrationStep>)(object)new MigrationStep[1]
				{
					new MigrationStep(0, 1, (Action)delegate
					{
						kindleConfig.MigrateDefaults(log);
					})
				});
			}
			finally
			{
				file.SaveOnConfigSet = saveOnConfigSet;
			}
			file.Save();
			file.SettingChanged += OnSettingChanged;
		}

		public static KindleConfig Bind(ConfigFile file, MeadworksLog log)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (file == null)
			{
				throw new ArgumentNullException("file");
			}
			if (log == null)
			{
				throw new ArgumentNullException("log");
			}
			KindleConfig kindleConfig = new KindleConfig(file, log);
			foreach (KeyValuePair<KindleSetting, ConfigEntryBase> item in kindleConfig.entries.Where<KeyValuePair<KindleSetting, ConfigEntryBase>>((KeyValuePair<KindleSetting, ConfigEntryBase> p) => (int)p.Key.Scope > 0))
			{
				MeadworksBlockedOptions.Track("com.meadworks.kindle", item.Value, Map(item.Key.Scope), true);
			}
			kindleConfig.Refresh();
			log.Verbose("Configuration bound: " + Count((SettingScope)0) + " Local, " + Count((SettingScope)1) + " ServerAuthoritative, " + Count((SettingScope)2) + " Cheat.");
			return kindleConfig;
		}

		public static ConfigScope Map(SettingScope scope)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected I4, but got Unknown
			return (ConfigScope)((int)scope switch
			{
				0 => 0, 
				1 => 1, 
				2 => 2, 
				_ => throw new ArgumentException("Unknown scope.", "scope"), 
			});
		}

		public ConfigEntryBase Entry(KindleSetting setting)
		{
			if (!entries.TryGetValue(setting ?? throw new ArgumentNullException("setting"), out ConfigEntryBase value))
			{
				throw new ArgumentException("Not a Kindle setting.", "setting");
			}
			return value;
		}

		public T Get<T>(KindleSetting<T> setting)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			if (Shortcuts.Contains((KindleSetting)(object)setting))
			{
				throw new ArgumentException(((KindleSetting)setting).Id + " is a keyboard shortcut; use Shortcut.", "setting");
			}
			ConfigEntry<T> val = (ConfigEntry<T>)(object)Entry((KindleSetting)(object)setting);
			SettingScope scope = ((KindleSetting)setting).Scope;
			if ((int)scope != 1)
			{
				if ((int)scope == 2)
				{
					return KindleCheats.Effective<T>(setting, CheatLocked(), val.Value);
				}
				return setting.Normalize(val.Value);
			}
			return setting.Normalize(MeadworksConfig.Effective<T>(val, "com.meadworks.kindle", (ConfigScope)1, setting.Default, true));
		}

		public KeyboardShortcut Shortcut(KindleSetting<string> setting)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!Shortcuts.Contains((KindleSetting)(object)setting))
			{
				throw new ArgumentException(((KindleSetting)setting).Id + " is not a keyboard shortcut.", "setting");
			}
			return ((ConfigEntry<KeyboardShortcut>)(object)Entry((KindleSetting)(object)setting)).Value;
		}

		public bool IsLocked(KindleSetting setting)
		{
			return false;
		}

		public bool TryUseCheat(KindleSetting cheat, string? label = null)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			if (cheat == null || (int)cheat.Scope != 2)
			{
				throw new ArgumentException("Expected a Kindle cheat.", "cheat");
			}
			return MeadworksBlockedOptions.TryUse("com.meadworks.kindle", cheat.Id, (ConfigScope)2, label, true);
		}

		public bool TryChange(KindleSetting setting, string? label = null)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (setting == null)
			{
				throw new ArgumentNullException("setting");
			}
			if ((object)setting == Tracker.CountNearbyChests && !KindleTracker.NearbyAvailable)
			{
				if ((Object)(object)MessageHud.instance != (Object)null && MeadworksHeadless.AllowsUi)
				{
					MessageHud.instance.ShowMessage((MessageType)2, KindleText.Text("needs_burrow"), 0, (Sprite)null, false, true);
				}
				return false;
			}
			if ((int)setting.Scope != 0)
			{
				return MeadworksBlockedOptions.TryEdit("com.meadworks.kindle", setting.Id, Map(setting.Scope), label, true);
			}
			return true;
		}

		public void Tick(float now)
		{
			if (!(now < nextRefresh))
			{
				nextRefresh = now + 0.5f;
				Refresh();
			}
		}

		public void Shutdown()
		{
			file.SettingChanged -= OnSettingChanged;
			this.Changed = null;
			foreach (ConfigEntryBase item in entries.Values.Where((ConfigEntryBase e) => (int)settingsByEntry[e].Scope > 0))
			{
				MeadworksBlockedOptions.Untrack(item);
			}
		}

		private void Refresh()
		{
			nearbyTag.ReadOnly = (KindleTracker.NearbyAvailable ? ((bool?)null) : new bool?(true));
		}

		private void MigrateDefaults(MeadworksLog log)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			foreach (KeyValuePair<KindleSetting<string>, string> change in KindleDefaultsMigration.Changes)
			{
				ConfigEntryBase val = entries[(KindleSetting)(object)change.Key];
				object obj;
				if (!(val is ConfigEntry<KeyboardShortcut> val2))
				{
					obj = val.BoxedValue as string;
				}
				else
				{
					KeyboardShortcut value = val2.Value;
					obj = ((KeyboardShortcut)(ref value)).Serialize();
				}
				string text = (string)obj;
				string text2 = KindleDefaultsMigration.Migrate(change.Key, text);
				if (text2 != null)
				{
					val.BoxedValue = ((val is ConfigEntry<KeyboardShortcut>) ? ((object)KeyboardShortcut.Deserialize(text2)) : text2);
					list.Add(((KindleSetting)change.Key).Id);
				}
			}
			if (list.Count > 0)
			{
				log.Info("Moved unchanged old input defaults to the new defaults: " + string.Join(", ", list) + ". Customized values were kept.");
			}
		}

		private static bool CheatLocked()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			return (int)MeadworksAuthority.Decide("com.meadworks.kindle", (ConfigScope)2, true).Source == 2;
		}

		private void BindSetting(KindleSetting setting)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntryBase val;
			if ((object)setting == Server.LockedPlayerSettings)
			{
				val = (ConfigEntryBase)(object)MeadworksConfig.BindHidden<string>(file, setting.Section, setting.Key, (string)setting.DefaultValue, setting.Description, (ConfigScope)1, (AcceptableValueBase)null);
			}
			else if (Shortcuts.Contains(setting))
			{
				val = (ConfigEntryBase)(object)MeadworksConfig.Bind<KeyboardShortcut>(file, setting.Section, setting.Key, KeyboardShortcut.Deserialize((string)setting.DefaultValue), Describe(setting, null), Map(setting.Scope));
			}
			else if (!(setting is KindleSetting<bool> setting2))
			{
				if (!(setting is KindleSetting<int> val2))
				{
					if (!(setting is KindleSetting<float> val3))
					{
						if (!(setting is KindleSetting<string> setting3))
						{
							if (!(setting is KindleSetting<RecipeView> setting4))
							{
								if (!(setting is KindleSetting<TrackerFont> setting5))
								{
									if (!(setting is KindleSetting<SalvageRounding> setting6))
									{
										throw new NotSupportedException(setting.Id + ": unsupported value type " + setting.ValueType.Name + ".");
									}
									val = (ConfigEntryBase)(object)Bind<SalvageRounding>(setting6, null);
								}
								else
								{
									val = (ConfigEntryBase)(object)Bind<TrackerFont>(setting5, null);
								}
							}
							else
							{
								val = (ConfigEntryBase)(object)Bind<RecipeView>(setting4, null);
							}
						}
						else
						{
							val = (ConfigEntryBase)(object)Bind<string>(setting3, null);
						}
					}
					else
					{
						val = (ConfigEntryBase)(object)Bind<float>(val3, (AcceptableValueBase?)(object)new AcceptableValueRange<float>((float)((KindleSetting)val3).Minimum, (float)((KindleSetting)val3).Maximum));
					}
				}
				else
				{
					val = (ConfigEntryBase)(object)Bind<int>(val2, (AcceptableValueBase?)(object)new AcceptableValueRange<int>((int)((KindleSetting)val2).Minimum, (int)((KindleSetting)val2).Maximum));
				}
			}
			else
			{
				val = (ConfigEntryBase)(object)Bind<bool>(setting2, null);
			}
			entries.Add(setting, val);
			settingsByEntry.Add(val, setting);
		}

		private ConfigDescription Describe(KindleSetting setting, AcceptableValueBase? acceptable, string? text = null)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Expected O, but got Unknown
			ConfigDependency val = null;
			if ((object)setting == Tracker.MaxTracked || (object)setting == Tracker.CountNearbyChests || (object)setting == Tracker.HideInCombat || (object)setting == Tracker.HideWithMap || (object)setting == Tracker.Font || (object)setting == Tracker.FontSize || (object)setting == Tracker.HaveColour || (object)setting == Tracker.MissingColour || (object)setting == Tracker.ReadyColour || (object)setting == Tracker.BackgroundOpacity)
			{
				val = new ConfigDependency((Func<bool>)(() => Get<bool>(Tracker.Enabled)), (Func<string>)(() => "Requires " + ((KindleSetting)Tracker.Enabled).Section + ": " + ((KindleSetting)Tracker.Enabled).Key + "."), (Func<bool>)null);
			}
			if ((object)setting == RecipeList.FavouritesFirst || (object)setting == RecipeList.FavouriteRecipeKey)
			{
				val = new ConfigDependency((Func<bool>)(() => Get<bool>(RecipeList.Favourites)), (Func<string>)(() => "Requires " + ((KindleSetting)RecipeList.Favourites).Section + ": " + ((KindleSetting)RecipeList.Favourites).Key + "."), (Func<bool>)null);
			}
			if ((object)setting == RecipeList.SearchKey)
			{
				val = new ConfigDependency((Func<bool>)(() => Get<bool>(RecipeList.Search)), (Func<string>)(() => "Requires " + ((KindleSetting)RecipeList.Search).Section + ": " + ((KindleSetting)RecipeList.Search).Key + "."), (Func<bool>)null);
			}
			if ((object)setting == RecipeList.GamepadSortButton)
			{
				val = new ConfigDependency((Func<bool>)(() => Get<bool>(RecipeList.GamepadControls)), (Func<string>)(() => "Requires " + ((KindleSetting)RecipeList.GamepadControls).Section + ": " + ((KindleSetting)RecipeList.GamepadControls).Key + "."), (Func<bool>)null);
			}
			if ((object)setting == Batch.MaxAmount)
			{
				val = new ConfigDependency((Func<bool>)(() => Get<bool>(Batch.Enabled)), (Func<string>)(() => "Requires " + ((KindleSetting)Batch.Enabled).Section + ": " + ((KindleSetting)Batch.Enabled).Key + "."), (Func<bool>)null);
			}
			if ((object)setting == VirtualWorkbench.Key)
			{
				val = new ConfigDependency((Func<bool>)(() => Get<bool>(VirtualWorkbench.Enabled)), (Func<string>)(() => "Requires " + ((KindleSetting)VirtualWorkbench.Enabled).Section + ": " + ((KindleSetting)VirtualWorkbench.Enabled).Key + "."), (Func<bool>)null);
			}
			if ((object)setting == Salvage.SalvageKey)
			{
				val = new ConfigDependency((Func<bool>)(() => Get<bool>(Salvage.Enabled)), (Func<string>)(() => "Requires " + ((KindleSetting)Salvage.Enabled).Section + ": " + ((KindleSetting)Salvage.Enabled).Key + "."), (Func<bool>)null);
			}
			return new ConfigDescription(text ?? setting.Description, acceptable, (val == null) ? Array.Empty<object>() : new object[1] { val });
		}

		private ConfigEntry<T> Bind<T>(KindleSetting<T> setting, AcceptableValueBase? acceptable)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//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)
			if ((int)((KindleSetting)setting).Scope != 2)
			{
				return MeadworksConfig.Bind<T>(file, ((KindleSetting)setting).Section, ((KindleSetting)setting).Key, setting.Default, Describe((KindleSetting)(object)setting, acceptable), Map(((KindleSetting)setting).Scope));
			}
			return MeadworksConfig.BindCheat<T>(file, ((KindleSetting)setting).Section, ((KindleSetting)setting).Key, setting.Safe, ((KindleSetting)setting).Description, acceptable);
		}

		private static int Count(SettingScope scope)
		{
			//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)
			return KindleSettings.All.Count((KindleSetting s) => s.Scope == scope);
		}
	}
	internal static class InscribeDetails
	{
		private static Tuple<Func<object, string>, Func<object, string>, Func<object, Tuple<string, string, float, string, string, string>[]>> Resolve()
		{
			if (!Plugin.IsReady)
			{
				return null;
			}
			Tuple<Func<object, string>, Func<object, string>, Func<object, Tuple<string, string, float, string, string, string>[]>> result = default(Tuple<Func<object, string>, Func<object, string>, Func<object, Tuple<string, string, float, string, string, string>[]>>);
			if (!Plugin.Services.Capabilities.TryResolve<Tuple<Func<object, string>, Func<object, string>, Func<object, Tuple<string, string, float, string, string, string>[]>>>("meadworks.items.decoration", ItemDecorationContract.ContractVersion, ref result))
			{
				return null;
			}
			return result;
		}

		internal static string Name(ItemData item, string fallback)
		{
			try
			{
				string text = Resolve()?.Item1(item);
				return string.IsNullOrEmpty(text) ? fallback : text;
			}
			catch (Exception)
			{
				return fallback;
			}
		}

		internal static string Lines(ItemData item)
		{
			try
			{
				Tuple<string, string, float, string, string, string>[] array = Resolve()?.Item3(item);
				if (array == null)
				{
					return "";
				}
				HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
				List<string> list = new List<string>();
				Tuple<string, string, float, string, string, string>[] array2 = array;
				foreach (Tuple<string, string, float, string, string, string> tuple in array2)
				{
					if (list.Count == 128)
					{
						break;
					}
					if (tuple != null && tuple.Item1 != null && tuple.Item1.StartsWith("inscribe.", StringComparison.Ordinal) && hashSet.Add(tuple.Item1) && !float.IsNaN(tuple.Item3) && !float.IsInfinity(tuple.Item3) && !string.IsNullOrEmpty(tuple.Item6))
					{
						list.Add(tuple.Item6);
					}
				}
				return string.Join("\n", list);
			}
			catch (Exception)
			{
				return "";
			}
		}
	}
	public sealed class KindleImportValue
	{
		public string SourceId { get; }

		public string TargetId { get; }

		public string SourceValue { get; }

		public string Value { get; }

		public string CurrentValue { get; }

		internal KindleImportValue(string source, string target, string original, string value, string current)
		{
			SourceId = source;
			TargetId = target;
			SourceValue = original;
			Value = value;
			CurrentValue = current;
		}
	}
	public sealed class KindleImportPreview
	{
		internal KindleReferenceImport Owner { get; }

		internal IReadOnlyDictionary<string, string> Sources { get; }

		internal IReadOnlyList<string> PrepareErrors { get; }

		internal long Generation { get; }

		public ConversionPreview Preview { get; }

		public IReadOnlyList<KindleImportValue> Values { get; }

		public IReadOnlyList<string> Errors { get; }

		public IReadOnlyList<string> Skipped { get; }

		public IReadOnlyList<string> Normalizations { get; }

		public IReadOnlyList<ConversionConflict> Conflicts => Preview.Conflicts;

		public IReadOnlyList<ConversionConflict> BindingConflicts => Preview.BindingConflicts;

		public string SourceSha256 { get; }

		public string TargetSha256 { get; }

		internal KindleImportPreview(KindleReferenceImport owner, ConversionPreview plan, IEnumerable<KindleImportValue> values, IEnumerable<string> errors, IEnumerable<string> prepareErrors, IEnumerable<string> skipped, IEnumerable<string> normalizations, IReadOnlyDictionary<string, string> sources, string sourceHash, string targetHash, long generation)
		{
			Owner = owner;
			Preview = plan;
			Values = Array.AsReadOnly(values.ToArray());
			Errors = Array.AsReadOnly(errors.ToArray());
			PrepareErrors = Array.AsReadOnly(prepareErrors.ToArray());
			Skipped = Array.AsReadOnly(skipped.ToArray());
			Normalizations = Array.AsReadOnly(normalizations.ToArray());
			Sources = new ReadOnlyDictionary<string, string>(sources.ToDictionary<KeyValuePair<string, string>, string, string>((KeyValuePair<string, string> p) => p.Key, (KeyValuePair<string, string> p) => p.Value, StringComparer.OrdinalIgnoreCase));
			SourceSha256 = sourceHash;
			TargetSha256 = targetHash;
			Generation = generation;
		}

		public override string ToString()
		{
			List<string> list = new List<string> { KindleText.Text("import_review") };
			list.AddRange(Values.Select((KindleImportValue v) => v.SourceId + " → " + v.TargetId + ": " + v.CurrentValue + " → " + v.Value + " (source: " + v.SourceValue + ")"));
			list.AddRange(Normalizations.Select((string v) => "Normalized: " + v));
			list.AddRange(Skipped.Select((string v) => "Skipped: " + v));
			list.AddRange(Errors.Select((string v) => "Invalid: " + v));
			list.AddRange(Conflicts.Select((ConversionConflict c) => "Choice required: " + c.TargetId + " = " + string.Join(" or ", c.Choices.Select((ConversionValue v) => v.SourceId))));
			list.AddRange(BindingConflicts.Select((ConversionConflict c) => "Shortcut collision: " + c.TargetId + "; replace binding:<target>=<shortcut>"));
			list.AddRange(from p in Sources
				where !p.Key.EndsWith(".cfg", StringComparison.OrdinalIgnoreCase)
				select "Salvage file: " + Path.GetFileName(p.Key) + " → " + Path.GetFileName(p.Key).Replace("OpenKeep.", "Kindle."));
			list.Add("Overrides: binding:<Section.Key>=<shortcut>; conflicts: <Section.Key>=<source id>.");
			list.Add("Source SHA256: " + SourceSha256);
			list.Add("Target SHA256: " + TargetSha256);
			return string.Join("\n", list);
		}
	}
	public sealed class KindleImportResult
	{
		public int Written { get; }

		public bool BackedUp { get; }

		public string SourceSha256 { get; }

		public string TargetSha256 { get; }

		public IReadOnlyList<string> Backups { get; }

		public IReadOnlyList<string> Messages { get; }

		internal KindleImportResult(ConversionResult result, string sourceHash, string targetHash, IEnumerable<string> backups, IEnumerable<string> messages)
		{
			Written = result.Written;
			BackedUp = result.BackedUp;
			SourceSha256 = sourceHash;
			TargetSha256 = targetHash;
			Backups = Array.AsReadOnly(backups.ToArray());
			Messages = Array.AsReadOnly(messages.ToArray());
		}

		public override string ToString()
		{
			return string.Join("\n", new string[1] { "Applied " + Written + " settings; config backup " + (BackedUp ? "created" : "no config changes") }.Concat(Messages).Concat(Backups.Select((string p) => "Backup: " + p)).Concat(new string[2]
			{
				"Source SHA256: " + SourceSha256,
				"Target SHA256: " + TargetSha256
			}));
		}
	}
	internal static class KindleAlmanac
	{
		internal const int MaxBytes = 1048576;

		internal static string ReadText(string path)
		{
			using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
			if (fileStream.Length > 1048576)
			{
				throw new InvalidDataException("Registered text exceeds 1 MiB.");
			}
			using StreamReader streamReader = new StreamReader(fileStream, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true), detectEncodingFromByteOrderMarks: true);
			return streamReader.ReadToEnd();
		}

		internal static string Hash(string text)
		{
			using SHA256 sHA = SHA256.Create();
			return Hex(sHA.ComputeHash(Encoding.UTF8.GetBytes(text)));
		}

		internal static string FileHash(string path)
		{
			if (!File.Exists(path))
			{
				return "missing";
			}
			using FileStream inputStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
			using SHA256 sHA = SHA256.Create();
			return Hex(sHA.ComputeHash(inputStream));
		}

		private static string Hex(byte[] bytes)
		{
			return string.Concat(bytes.Select((byte b) => b.ToString("X2", CultureInfo.InvariantCulture)));
		}

		internal static string SetHash(IEnumerable<KeyValuePair<string, string>> files)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (KeyValuePair<string, string> item in files.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> p) => p.Key, StringComparer.Ordinal))
			{
				stringBuilder.Append(item.Key.Length).Append(':').Append(item.Key)
					.Append(item.Value.Length)
					.Append(':')
					.Append(item.Value);
			}
			return Hash(stringBuilder.ToString());
		}

		internal static IEnumerable<KeyValuePair<string, string>> Ordered(IEnumerable<KeyValuePair<string, string>> files)
		{
			return files.OrderBy<KeyValuePair<string, string>, int>((KeyValuePair<string, string> p) => (!Path.GetFileName(p.Key).Equals("Kindle.Salvage.yml", StringComparison.OrdinalIgnoreCase)) ? 1 : 0).ThenBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> p) => Path.GetFileName(p.Key), StringComparer.OrdinalIgnoreCase);
		}

		internal static void Authority()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			if (!Plugin.IsReady || !Plugin.Ready)
			{
				throw new InvalidOperationException("Kindle configuration owner is unavailable.");
			}
			AuthorityDecision val = MeadworksAuthority.Decide("com.meadworks.kindle", (ConfigScope)1, true);
			if ((int)Plugin.Session.Role == 3 || !val.Allowed || val.RequiresServerAmendment)
			{
				throw new InvalidOperationException("Apply this import on the authority machine; this client cannot replace server-controlled configuration.");
			}
		}

		internal static string Temporary(string path, string text)
		{
			if (Encoding.UTF8.GetByteCount(text) > 1048576)
			{
				throw new InvalidDataException("Registered text exceeds 1 MiB.");
			}
			string text2 = path + ".import-" + Guid.NewGuid().ToString("N") + ".tmp";
			try
			{
				using (FileStream fileStream = new FileStream(text2, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					using (StreamWriter streamWriter = new StreamWriter(fileStream, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false), 1024, leaveOpen: true))
					{
						streamWriter.Write(text);
						streamWriter.Flush();
					}
					fileStream.Flush(flushToDisk: true);
				}
				return text2;
			}
			catch
			{
				if (File.Exists(text2))
				{
					File.Delete(text2);
				}
				throw;
			}
		}

		internal static string Backup(string path)
		{
			return path + ".import-" + DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture) + "-" + Guid.NewGuid().ToString("N") + ".bak";
		}
	}
	public sealed class KindleReferenceImport : IDisposable
	{
		private sealed class ImportTarget : IValidatedConversionTarget, IConversionTarget
		{
			private readonly KindleReferenceImport owner;

			private readonly KindleImportPreview preview;

			private readonly IConversionTarget target;

			internal readonly List<string> Backups = new List<string>();

			private bool backupRequested;

			private bool written;

			public int SchemaVersion => target.SchemaVersion;

			internal ImportTarget(KindleReferenceImport owner, KindleImportPreview preview)
			{
				this.owner = owner;
				this.preview = preview;
				target = MeadworksConversion.Target(owner.config);
			}

			private ConfigEntryBase[] Entries(IReadOnlyDictionary<string, object> values)
			{
				List<ConfigEntryBase> list = new List<ConfigEntryBase>();
				ConfigEntryMetadata val2 = default(ConfigEntryMetadata);
				foreach (KeyValuePair<string, object> value in values)
				{
					KindleSetting setting = ((IEnumerable<KindleSetting>)KindleSettings.All).SingleOrDefault((Func<KindleSetting, bool>)((KindleSetting s) => s.Id == value.Key)) ?? throw new ArgumentException("Unknown Kindle import target: " + value.Key);
					ConfigEntryBase val = owner.settingsEntry(setting);
					if (!MeadworksConfig.TryGetMetadata(val, ref val2) || val2.ProductId != "com.meadworks.kindle" || !val2.Decision.Allowed || val2.Decision.RequiresServerAmendment || owner.settings.IsLocked(setting))
					{
						throw new InvalidOperationException("An import target is now locked: " + value.Key);
					}
					object obj = (val.SettingType.IsInstanceOfType(value.Value) ? value.Value : TomlTypeConverter.ConvertToValue(Convert.ToString(value.Value, CultureInfo.InvariantCulture), val.SettingType));
					if (val.Description.AcceptableValues != null && !val.Description.AcceptableValues.IsValid(obj))
					{
						throw new ArgumentException("Invalid Kindle import target value: " + value.Key);
					}
					list.Add(val);
				}
				return list.Distinct().ToArray();
			}

			public void Validate(IReadOnlyDictionary<string, object> values)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				if (written)
				{
					throw new InvalidOperationException("This Kindle configuration import has already been applied.");
				}
				owner.Admission(preview);
				((IValidatedConversionTarget)target).Validate(values);
				Entries(values);
			}

			public void Backup()
			{
				owner.Admission(preview);
				if (!File.Exists(owner.config.ConfigFilePath))
				{
					throw new InvalidOperationException("Save Kindle configuration before importing; a target backup is required.");
				}
				backupRequested = true;
			}

			private void VerifiedBackup()
			{
				string configFilePath = owner.config.ConfigFilePath;
				string directoryName = Path.GetDirectoryName(configFilePath);
				string searchPattern = Path.GetFileName(configFilePath) + ".import-*.bak";
				string[] files = Directory.GetFiles(directoryName, searchPattern);
				string text = KindleAlmanac.FileHash(configFilePath);
				target.Backup();
				string[] array = Directory.GetFiles(directoryName, searchPattern).Except<string>(files, StringComparer.OrdinalIgnoreCase).ToArray();
				if (array.Length != 1 || KindleAlmanac.FileHash(array[0]) != text)
				{
					throw new IOException("The exact target backup could not be verified.");
				}
				Backups.Add(array[0]);
			}

			public void WriteAtomic(IReadOnlyDictionary<string, object> values)
			{
				Validate(values);
				if (!backupRequested)
				{
					throw new InvalidOperationException("Kindle import requires a backup.");
				}
				ConfigEntryBase[] array = Entries(values);
				if (array.Length == 0)
				{
					return;
				}
				try
				{
					if (!MeadworksConfig.AmendBatch("com.meadworks.kindle", (IReadOnlyList<ConfigEntryBase>)array, (Action)delegate
					{
						owner.Admission(preview);
						Entries(values);
						VerifiedBackup();
						target.WriteAtomic(values);
						written = true;
					}, "Kindle import").Applied || !written)
					{
						throw new InvalidOperationException("Current authority or synchronization refused the Kindle import before writing.");
					}
				}
				catch (Exception innerException) when (written)
				{
					throw new IOException("Kindle settings were saved locally, but synchronization did not complete. Salvage files and the import marker were not updated; review synchronization before continuing.", innerException);
				}
			}
		}

		private readonly ConfigFile config;

		private readonly ConfigEntry<string> marker;

		private readonly ConfigEntry<bool> apply;

		private readonly ConfigEntry<bool> preview;

		private readonly ConfigEntry<string> choices;

		private readonly Dictionary<string, KindleSetting> mappings = new Dictionary<string, KindleSetting>(StringComparer.Ordinal);

		private readonly ConfigConverter converter;

		private readonly MeadworksLog log;

		private readonly KindleConfig settings;

		private readonly int thread = Thread.CurrentThread.ManagedThreadId;

		private IDisposable registration;

		private bool disposed;

		private Player lastPlayer;

		private bool offered;

		public string ReportPath => Path.Combine(Paths.ConfigPath, "Meadworks", "kindle", "import-report.txt");

		public string SourcePath => Path.Combine(Paths.ConfigPath, "milkyteam.openkeep.cfg");

		public KindleReferenceImport(ConfigFile config, KindleConfig settings, MeadworksLog log)
		{
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Expected O, but got Unknown
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Expected O, but got Unknown
			this.config = config;
			this.log = log;
			this.settings = settings;
			marker = MeadworksConfig.BindHidden<string>(config, "Import", "Imported Sources", "", "Managed by Kindle.", (ConfigScope)0, (AcceptableValueBase)null);
			preview = MeadworksConfig.Bind<bool>(config, "Import", "Preview OpenKeep", false, "Write a preview report without changing any source or target settings. Resets after running.", (ConfigScope)0, (AcceptableValueBase)null);
			apply = MeadworksConfig.Bind<bool>(config, "Import", "Apply OpenKeep", false, "Apply the previewed reference settings with a target backup. Source files remain intact. Resets after running.", (ConfigScope)0, (AcceptableValueBase)null);
			choices = MeadworksConfig.Bind<string>(config, "Import", "Binding Overrides", "", "Replacement shortcuts as Section.Key=value, separated by semicolons, for collisions shown by Preview.", (ConfigScope)0, (AcceptableValueBase)null);
			foreach (KindleSetting item in KindleSettings.All)
			{
				string text = ((item.Section == "Recipe List") ? "12. Recipe List" : ((item.Section == "Batch Crafting") ? "10. Batch Crafting" : ((item.Section == "Recipe Tracker") ? "13. Recipe Tracker" : ((item.Section == "Salvage") ? "3. Salvage" : ((item.Section == "Cart Workbench") ? "6. Carts" : "")))));
				if (text.Length != 0 && (object)item != RecipeList.FavouriteRecipeKey && (object)item != RecipeList.IgnoreAccents && (object)item != RecipeList.SortButton && (object)item != RecipeList.GamepadSortButton)
				{
					mappings.Add("OpenKeep." + text + "." + item.Key, item);
				}
			}
			mappings.Add("OpenKeep.2. Stow.Favourite Item Key", (KindleSetting)(object)RecipeList.FavouriteRecipeKey);
			IEnumerable<ConversionRule> enumerable = mappings.Select<KeyValuePair<string, KindleSetting>, ConversionRule>((KeyValuePair<string, KindleSetting> pair) => new ConversionRule(pair.Key, pair.Value.Id, IsShortcut(pair.Value) ? "KeyboardShortcut" : pair.Value.ValueType.Name, string.Join(",", pair.Value.Choices), false, IsShortcut(pair.Value)));
			converter = new ConfigConverter(new ConversionMapping(1, "OpenKeep", 0, enumerable));
			registration = MeadworksConversion.Register(new ConversionRegistration("kindle.openkeep", "com.meadworks.kindle", "milkyteam.openkeep", "OpenKeep", (Func<bool>)(() => !disposed && (File.Exists(SourcePath) || Directory.GetFiles(Paths.ConfigPath, "OpenKeep.Salvage*.yml").Length != 0)), (Func<object>)(() => Preview()), (Func<object, IReadOnlyDictionary<string, string>, bool, object>)delegate(object document, IReadOnlyDictionary<string, string> resolutions, bool backup)
			{
				if (!backup)
				{
					throw new InvalidOperationException("Kindle import requires a backup.");
				}
				Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
				Dictionary<string, string> dictionary2 = new Dictionary<string, string>(StringComparer.Ordinal);
				foreach (KeyValuePair<string, string> resolution in resolutions)
				{
					if (resolution.Key.StartsWith("binding:", StringComparison.Ordinal))
					{
						dictionary2.Add(resolution.Key.Substring(8), resolution.Value);
					}
					else if (KindleSettings.All.Any((KindleSetting s) => s.Id == resolution.Key && IsShortcut(s)) && !mappings.ContainsKey(resolution.Value))
					{
						dictionary2.Add(resolution.Key, resolution.Value);
					}
					else
					{
						dictionary.Add(resolution.Key, resolution.Value);
					}
				}
				return Apply((document as KindleImportPreview) ?? throw new ArgumentException("Wrong Kindle import preview."), dictionary, dictionary2);
			}));
		}

		private void Check()
		{
			if (disposed || Thread.CurrentThread.ManagedThreadId != thread)
			{
				throw new InvalidOperationException("Kindle imports require their live owning thread.");
			}
		}

		public void Dispose()
		{
			if (!disposed)
			{
				disposed = true;
				registration?.Dispose();
				registration = null;
			}
		}

		private static bool IsShortcut(KindleSetting setting)
		{
			if ((object)setting != RecipeList.SearchKey && (object)setting != RecipeList.FavouriteRecipeKey)
			{
				return (object)setting == Salvage.SalvageKey;
			}
			return true;
		}

		public static bool DeclareAndYield()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			if (!Plugin.Services.StepAside.Declared("com.meadworks.kindle").Any())
			{
				List<SourceMod> list = new List<SourceMod>();
				if (Chainloader.PluginInfos.TryGetValue("milkyteam.openkeep", out var value) && value.Metadata.Version >= new Version(2, 0))
				{
					list.Add(new SourceMod(value.Metadata.GUID, "OpenKeep"));
				}
				foreach (PluginInfo info in Chainloader.PluginInfos.Values)
				{
					if ((info.Metadata.GUID == "com.ab5olutezer0.valheim.craftingsearch" || string.Equals(info.Metadata.Name, "Crafting Search", StringComparison.OrdinalIgnoreCase) || string.Equals(((object)info.Instance)?.GetType().Assembly.GetName().Name, "CraftingSearch", StringComparison.OrdinalIgnoreCase)) && !list.Any((SourceMod s) => s.Guid == info.Metadata.GUID))
					{
						list.Add(new SourceMod(info.Metadata.GUID, "Crafting Search"));
					}
				}
				MeadworksStepAside.Declare("com.meadworks.kindle", "Kindle", (IEnumerable<SourceMod>)list);
			}
			return MeadworksStepAside.ShouldYield("com.meadworks.kindle");
		}

		public void Tick(bool active)
		{
			if (!offered)
			{
				offered = true;
				if (marker.Value.Length == 0 && File.Exists(Path.Combine(Paths.ConfigPath, "milkyteam.openkeep.cfg")))
				{
					Run(write: false);
				}
			}
			if (preview.Value || apply.Value)
			{
				Run(apply.Value);
			}
			if (!active)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer == (Object)(object)lastPlayer)
			{
				return;
			}
			lastPlayer = localPlayer;
			(string, string)[] array = new(string, string)[3]
			{
				("favouriteRecipes", "favoriteRecipes"),
				("favouriteRecipesOnly", "favoriteRecipesOnly"),
				("trackedRecipes", "trackedRecipes")
			};
			for (int i = 0; i < array.Length; i++)
			{
				var (text, text2) = array[i];
				if (!localPlayer.m_customData.ContainsKey("Kindle." + text2) && localPlayer.m_customData.TryGetValue("OpenKeep." + text, out var value))
				{
					localPlayer.m_customData["Kindle." + text2] = value;
				}
			}
			string text3 = default(string);
			if (!localPlayer.TryGetUniqueKeyValue("kindle_sort_desc", ref text3) && !localPlayer.m_customData.ContainsKey("Kindle.importedCraftingSearch") && localPlayer.TryGetUniqueKeyValue("craftingsearch_desc", ref text3))
			{
				localPlayer.AddUniqueKeyValue("kindle_sort_desc", "1");
				localPlayer.m_customData["Kindle.importedCraftingSearch"] = "1";
			}
		}

		public KindleImportPreview Preview()
		{
			//IL_0105: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Invalid comparison between Unknown and I4
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Invalid comparison between Unknown and I4
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			Check();
			string hash;
			Dictionary<string, string> dictionary = ReadSources(out hash);
			if (dictionary.Count == 0)
			{
				throw new InvalidOperationException("No OpenKeep settings or salvage files were found to import.");
			}
			IReadOnlyList<KeyValuePair<string, string>> readOnlyList2;
			if (!dictionary.TryGetValue(SourcePath, out var value))
			{
				IReadOnlyList<KeyValuePair<string, string>> readOnlyList = Array.Empty<KeyValuePair<string, string>>();
				readOnlyList2 = readOnlyList;
			}
			else
			{
				readOnlyList2 = CfgText.Read(value, "OpenKeep");
			}
			IReadOnlyList<KeyValuePair<string, string>> raw = readOnlyList2;
			List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			List<string> list4 = new List<string>();
			foreach (KeyValuePair<string, string> item in raw)
			{
				if (!mappings.TryGetValue(item.Key, out KindleSetting value2))
				{
					list3.Add(item.Key + ": no Kindle mapping");
					continue;
				}
				if ((object)value2 == RecipeList.FavouriteRecipeKey && item.Value == "F")
				{
					list3.Add(item.Key + ": default reference F binding retained as Kindle's configured binding");
					continue;
				}
				AuthorityDecision val = MeadworksAuthority.Decide("com.meadworks.kindle", KindleConfig.Map(value2.Scope), true);
				if (settings.IsLocked(value2) || (int)val.Source == 1 || (int)val.Source == 2)
				{
					list3.Add(item.Key + ": target is locked or server-provided");
					continue;
				}
				try
				{
					Type valueType = value2.ValueType;
					object result;
					object obj = (IsShortcut(value2) ? ((object)KeyboardShortcut.Deserialize(item.Value)) : ((!valueType.IsEnum) ? TomlTypeConverter.ConvertToValue(item.Value, valueType) : (Enum.TryParse(valueType, item.Value, ignoreCase: true, out result) ? result : value2.DefaultValue)));
					object obj2 = (IsShortcut(value2) ? obj : value2.NormalizeBoxed(obj));
					object obj3;
					if (!IsShortcut(value2))
					{
						obj3 = Convert.ToString(obj2, CultureInfo.InvariantCulture) ?? "";
					}
					else
					{
						KeyboardShortcut val2 = (KeyboardShortcut)obj2;
						obj3 = ((KeyboardShortcut)(ref val2)).Serialize();
					}
					string text = (string)obj3;
					if (text != item.Value)
					{
						list4.Add(item.Key + ": " + item.Value + " -> " + text + " (normalized)");
					}
					list.Add(new KeyValuePair<string, string>(item.Key, text));
				}
				catch (Exception ex)
				{
					list2.Add(item.Key + ": " + ex.GetBaseException().Message);
				}
			}
			ConversionPreview val3 = converter.Preview((IEnumerable<KeyValuePair<string, string>>)list);
			list2.AddRange(val3.Errors);
			Dictionary<string, string> dictionary2 = ReadTargetYaml();
			foreach (KeyValuePair<string, string> item2 in dictionary.Where((KeyValuePair<string, string> p) => p.Key != SourcePath))
			{
				dictionary2[Destination(item2.Key)] = ImportedText(item2.Key, item2.Value);
			}
			if (dictionary2.Count != 0)
			{
				SalvageModel salvageModel = new SalvageModel();
				salvageModel.LoadAll(KindleAlmanac.Ordered(dictionary2));
				list2.AddRange(salvageModel.Errors);
			}
			string[] prepareErrors = list2.ToArray();
			try
			{
				ValidateFinalBindings(val3, ReadOverrides());
			}
			catch (Exception ex2)
			{
				list2.Add(ex2.GetBaseException().Message);
			}
			IEnumerable<KindleImportValue> values = val3.Values.Select((ConversionValue v) => new KindleImportValue(v.SourceId, v.TargetId, raw.First<KeyValuePair<string, string>>((KeyValuePair<string, string> p) => p.Key == v.SourceId).Value, Convert.ToString(v.Value, CultureInfo.InvariantCulture) ?? "", config[config.Keys.Single((ConfigDefinition k) => k.Section + "." + k.Key == v.TargetId)].GetSerializedValue()));
			return new KindleImportPreview(this, val3, values, list2, prepareErrors, list3, list4, dictionary, hash, TargetHash(), Plugin.Session.Generation);
		}

		private Dictionary<string, string> ReadOverrides()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			string[] array = choices.Value.Split(';');
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num > 0)
				{
					dictionary[text.Substring(0, num).Trim()] = text.Substring(num + 1).Trim();
				}
			}
			return dictionary;
		}

		private Dictionary<string, string> ReadSources(out string hash)
		{
			List<string> list = Directory.GetFiles(Paths.ConfigPath, "OpenKeep.Salvage*.yml").OrderBy<string, string>((string p) => p, StringComparer.Ordinal).ToList();
			if (File.Exists(SourcePath))
			{
				list.Insert(0, SourcePath);
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			foreach (string item in list)
			{
				string text = KindleAlmanac.FileHash(item);
				string value = KindleAlmanac.ReadText(item);
				if (KindleAlmanac.FileHash(item) != text)
				{
					throw new InvalidOperationException("Source changed while preparing the import.");
				}
				dictionary.Add(item, value);
				dictionary2.Add(item, text);
			}
			hash = KindleAlmanac.SetHash(dictionary2);
			return dictionary;
		}

		private Dictionary<string, string> ReadTargetYaml()
		{
			return Directory.GetFiles(Paths.ConfigPath, "Kindle.Salvage*.yml").ToDictionary<string, string, string>((string p) => p, (string p) => KindleAlmanac.ReadText(p), StringComparer.OrdinalIgnoreCase);
		}

		private static string Destination(string source)
		{
			return Path.Combine(Paths.ConfigPath, Path.GetFileName(source).Replace("OpenKeep.", "Kindle."));
		}

		private static string ImportedText(string path, string text)
		{
			return "# Imported from " + Path.GetFileName(path) + "; source preserved.\n" + text;
		}

		private string TargetHash()
		{
			List<KeyValuePair<string, string>> list = (from k in config.Keys.OrderBy<ConfigDefinition, string>((ConfigDefinition k) => k.Section, StringComparer.Ordinal).ThenBy<ConfigDefinition, string>((ConfigDefinition k) => k.Key, StringComparer.Ordinal)
				select new KeyValuePair<string, string>(k.Section.Length + ":" + k.Section + k.Key.Length + ":" + k.Key, TomlTypeConverter.ConvertToString(config[k].BoxedValue, config[k].SettingType))).ToList();
			list.Add(new KeyValuePair<string, string>("config-bytes", KindleAlmanac.FileHash(config.ConfigFilePath)));
			list.Add(new KeyValuePair<string, string>("yaml-set", KindleAlmanac.SetHash(ReadTargetYaml())));
			return KindleAlmanac.SetHash(list);
		}

		private void Admission(KindleImportPreview document, bool target = true)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			Check();
			if (document == null || document.Owner != this)
			{
				throw new ArgumentException("Preview belongs to another Kindle importer.");
			}
			KindleAlmanac.Authority();
			if (Plugin.Session.Generation != document.Generation)
			{
				throw new InvalidOperationException("Session changed; preview again.");
			}
			ReadSources(out string hash);
			if (hash != document.SourceSha256)
			{
				throw new InvalidOperationException("Source files changed; preview again.");
			}
			if (target && TargetHash() != document.TargetSha256)
			{
				throw new InvalidOperationException("Target configuration or salvage files changed; preview again.");
			}
			foreach (ConversionValue value in document.Preview.Values)
			{
				KindleSetting val = KindleSettings.All.Single((KindleSetting s) => s.Id == value.TargetId);
				AuthorityDecision val2 = MeadworksAuthority.Decide("com.meadworks.kindle", KindleConfig.Map(val.Scope), true);
				if (settings.IsLocked(val) || !val2.Allowed || val2.RequiresServerAmendment)
				{
					throw new InvalidOperationException("An import target is now locked: " + value.TargetId);
				}
			}
		}

		public KindleImportResult Apply(KindleImportPreview document, IReadOnlyDictionary<string, string> sourceChoices, IReadOnlyDictionary<string, string> bindingOverrides = null)
		{
			Admission(document);
			if (document.PrepareErrors.Count != 0)
			{
				throw new ArgumentException(string.Join("; ", document.PrepareErrors));
			}
			if (bindingOverrides == null)
			{
				bindingOverrides = new Dictionary<string, string>();
			}
			ValidateFinalBindings(document.Preview, bindingOverrides);
			ImportTarget importTarget = new ImportTarget(this, document);
			ConversionResult val = converter.Apply(document.Preview, (IConversionTarget)(object)importTarget, sourceChoices, bindingOverrides);
			List<string> list = new List<string>();
			List<string> list2 = importTarget.Backups.ToList();
			try
			{
				CopyYaml(document, list, list2);
				Admission(document, target: false);
			}
			catch (Exception ex)
			{
				throw new InvalidOperationException("Configuration committed " + val.Written + " settings before YAML/source verification stopped: " + ex.GetBaseException().Message + ". Backups: " + string.Join(", ", list2), ex);
			}
			marker.Value = "OpenKeep";
			return new KindleImportResult(val, document.SourceSha256, TargetHash(), list2, list);
		}

		private void Run(bool write)
		{
			List<string> list = new List<string> { "Kindle OpenKeep import: " + (write ? "apply" : "preview") };
			try
			{
				KindleImportPreview kindleImportPreview = Preview();
				list.AddRange(kindleImportPreview.Normalizations);
				list.AddRange(kindleImportPreview.Values.Select((KindleImportValue v) => v.SourceId + " -> " + v.TargetId + " = " + v.Value));
				list.AddRange(kindleImportPreview.Errors);
				list.AddRange(kindleImportPreview.Skipped);
				list.AddRange(kindleImportPreview.BindingConflicts.Select((ConversionConflict c) => "Shortcut collision: " + c.TargetId + " (set Binding Overrides)"));
				list.Add("Source SHA256: " + kindleImportPreview.SourceSha256 + "; target SHA256: " + kindleImportPreview.TargetSha256);
				if (write)
				{
					KindleImportResult kindleImportResult = Apply(kindleImportPreview, new Dictionary<string, string>(), ReadOverrides());
					list.AddRange(kindleImportResult.Messages);
					list.Add("Applied " + kindleImportResult.Written + " settings; target backup: " + kindleImportResult.BackedUp);
				}
				else
				{
					list.Add("Preview only; no settings changed.");
				}
			}
			catch (Exception ex)
			{
				list.Add("Import stopped: " + ex.GetType().Name + ": " + ex.Message);
			}
			finally
			{
				ConfigEntry<bool> obj = preview;
				bool value = (apply.Value = false);
				obj.Value = value;
				Directory.CreateDirectory(Path.GetDirectoryName(ReportPath));
				File.WriteAllLines(ReportPath, list);
				log.Info(list[list.Count - 1] + " Report: " + ReportPath);
			}
		}

		private void ValidateFinalBindings(ConversionPreview plan, IReadOnlyDictionary<string, string> overrides)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			foreach (KindleSetting item in KindleSettings.All.Where(IsShortcut))
			{
				dictionary[item.Id] = settingsEntry(item).GetSerializedValue();
			}
			foreach (ConversionValue value in plan.Values)
			{
				if (dictionary.ContainsKey(value.TargetId))
				{
					dictionary[value.TargetId] = Convert.ToString(value.Value, CultureInfo.InvariantCulture) ?? "";
				}
			}
			foreach (KeyValuePair<string, string> @override in overrides)
			{
				if (dictionary.ContainsKey(@override.Key))
				{
					dictionary[@override.Key] = @override.Value;
				}
			}
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>(StringComparer.Ordinal);
			HotkeyChord val = default(HotkeyChord);
			foreach (KeyValuePair<string, string> item2 in dictionary)
			{
				if (!HotkeyChord.TryParse(item2.Value, ref val))
				{
					throw new ArgumentException("Unknown shortcut: " + item2.Key);
				}
				if (!val.IsNone)
				{
					dictionary2[item2.Key] = string.Join(" + ", new string[1] { val.Main }.Concat(val.Modifiers.OrderBy<string, string>((string m) => m, StringComparer.Ordinal)));
				}
			}
			IGrouping<string, KeyValuePair<string, string>>[] array = (from @group in dictionary2.GroupBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> pair) => pair.Value, StringComparer.OrdinalIgnoreCase)
				where @group.Count() > 1
				select @group).ToArray();
			if (array.Length == 0)
			{
				return;
			}
			throw new ArgumentException("Final shortcut collision: " + string.Join("; ", array.Select((IGrouping<string, KeyValuePair<string, string>> group) => group.Key + " -> " + string.Join(", ", group.Select((KeyValuePair<string, string> pair) => pair.Key)))));
		}

		private ConfigEntryBase settingsEntry(KindleSetting setting)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			return config[new ConfigDefinition(setting.Section, setting.Key)];
		}

		private void CopyYaml(KindleImportPreview document, List<string> report, List<string> backups)
		{
			string text = TargetHash();
			foreach (KeyValuePair<string, string> item in document.Sources.Where<KeyValuePair<string, string>>((KeyValuePair<string, string> p) => p.Key != SourcePath))
			{
				Admission(document, target: false);
				if (TargetHash() != text)
				{
					throw new InvalidOperationException("Target changed during YAML import.");
				}
				string text2 = Destination(item.Key);
				string text3 = ImportedText(item.Key, item.Value);
				string text4 = (File.Exists(text2) ? KindleAlmanac.ReadText(text2) : null);
				string text5 = KindleAlmanac.Temporary(text2, text3);
				string text6 = null;
				try
				{
					Admission(document, target: false);
					if (TargetHash() != text)
					{
						throw new InvalidOperationException("Target changed at YAML publication.");
					}
					if (text4 != null)
					{
						text6 = KindleAlmanac.Backup(text2);
						File.Replace(text5, text2, text6);
						backups.Add(text6);
					}
					else
					{
						File.Move(text5, text2);
					}
					if (KindleAlmanac.ReadText(text2) != text3)
					{
						throw new IOException("Imported YAML verification failed; backup: " + text6);
					}
					text = TargetHash();
					report.Add("Copied " + Path.GetFileName(text2) + ((text6 != null) ? " (existing target backed up)" : " (new target; no previous bytes)"));
				}
				finally
				{
					if (File.Exists(text5))
					{
						File.Delete(text5);
					}
				}
			}
		}
	}
	internal sealed class KindleSyncReceipt
	{
		private ZNet network;

		private ZRpc server;

		private string epoch = "";

		private long world;

		internal long CurrentGeneration
		{
			get
			{
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Invalid comparison between Unknown and I4
				if (!Plugin.IsReady || (Object)(object)network == (Object)null || server == null || !server.IsConnected() || network != ZNet.instance || network.IsServer() || server != network.GetServerRPC())
				{
					return -1L;
				}
				SessionSnapshot session = Plugin.Session;
				if ((int)session.Role != 3 || !session.AuthorityReady || session.WorldId == 0L || string.IsNullOrEmpty(session.SessionId))
				{
					return -1L;
				}
				if (epoch.Length == 0)
				{
					epoch = session.SessionId;
					world = session.WorldId;
				}
				if (!(epoch == session.SessionId) || world != session.WorldId)
				{
					return -1L;
				}
				return session.Generation;
			}
		}

		internal void Observe()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Invalid comparison between Unknown and I4
			network = ZNet.instance;
			server = (((Object)(object)network != (Object)null && !network.IsServer()) ? network.GetServerRPC() : null);
			epoch = "";
			world = 0L;
			if (server != null && server.IsConnected() && Plugin.IsReady)
			{
				SessionSnapshot session = Plugin.Session;
				if ((int)session.Role == 3 && !string.IsNullOrEmpty(session.SessionId))
				{
					epoch = session.SessionId;
					world = session.WorldId;
				}
			}
		}
	}
	public static class KindleText
	{
		private static MeadworksTranslations catalog;

		public static long Revision
		{
			get
			{
				MeadworksTranslations obj = catalog;
				if (obj == null)
				{
					return -1L;
				}
				return obj.Translations.Revision;
			}
		}

		public static void Initialize(BepInPlugin metadata, ManualLogSource log)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			Assembly assembly = typeof(KindleText).Assembly;
			foreach (string item in MeadworksLanguages.Supported)
			{
				using Stream stream = assembly.GetManifestResourceStream("Kindle.localization." + item + ".json");
				if (stream != null)
				{
					using StreamReader streamReader = new StreamReader(stream);
					dictionary.Add(item, streamReader.ReadToEnd());
				}
			}
			catalog = MeadworksTranslations.Register(metadata, new ProductTranslations("kindle", (IReadOnlyDictionary<string, string>)dictionary), (string)null, log);
		}

		public static void Notice(string text, bool top = false)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			if (!((Object)(object)MessageHud.instance == (Object)null))
			{
				ProductRegistration source = Plugin.Source;
				if (source != null && source.IsActive && CrucibleUiPlugin.Active)
				{
					KitNotices.Show(source, new KitNotice(text, (KitNoticeKind)(!top), "", 0, (Sprite)null, true, false, true));
				}
				else
				{
					MessageHud.instance.ShowMessage((MessageType)(top ? 1 : 2), text, 0, (Sprite)null, false, true);
				}
			}
		}

		public static string Text(string key)
		{
			MeadworksTranslations obj = catalog;
			return ((obj != null) ? obj.Text(key) : null) ?? key;
		}

		public static string Format(string key, params object[] arguments)
		{
			MeadworksTranslations obj = catalog;
			return ((obj != null) ? obj.Format(key, arguments) : null) ?? key;
		}

		public static string Token(string key)
		{
			return "$meadworks_kindle_" + key;
		}

		public static void Tick()
		{
			MeadworksTranslations obj = catalog;
			if (obj != null)
			{
				obj.Update();
			}
		}

		public static void Shutdown()
		{
			MeadworksTranslations obj = catalog;
			if (obj != null)
			{
				obj.Dispose();
			}
			catalog = null;
		}
	}
	public static class SalvageStackCapability
	{
		public const string CanId = "meadworks.crafting.salvage_can";

		public const string ItemId = "meadworks.crafting.salvage_item";

		public static readonly Version ContractVersion = new Version(1, 0);

		public static readonly Func<object, bool> Can = delegate(object item)
		{
			ItemData val = (ItemData)((item is ItemData) ? item : null);
			return val != null && SalvageActions.CanSalvage(val);
		};

		public static readonly Func<object, object, bool> Salvage = delegate(object player, object item)
		{
			Player val = (Player)((player is Player) ? player : null);
			if (val != null)
			{
				ItemData val2 = (ItemData)((item is ItemData) ? item : null);
				if (val2 != null)
				{
					return SalvageActions.Salvage(val, val2);
				}
			}
			return false;
		};

		public static void Register(ProductRegistration registration)
		{
			if (registration == null)
			{
				throw new ArgumentNullException("registration");
			}
			registration.AddCapability<Func<object, bool>>("meadworks.crafting.salvage_can", ContractVersion, Can);
			registration.AddCapability<Func<object, object, bool>>("meadworks.crafting.salvage_item", ContractVersion, Salvage);
		}
	}
	public static class SalvageTabCapability
	{
		public const string Id = "meadworks.crafting.salvage_tab";

		public static readonly Version ContractVersion = new Version(1, 0);

		public static readonly Func<bool> Provider = () => Active;

		public static bool Active { get; internal set; }

		public static void Register(ProductRegistration registration)
		{
			if (registration == null)
			{
				throw new ArgumentNullException("registration");
			}
			registration.AddCapability<Func<bool>>("meadworks.crafting.salvage_tab", ContractVersion, Provider);
		}
	}
	[BepInPlugin("com.meadworks.kindle", "Kindle", "0.1.25")]
	[BepInDependency("com.meadworks.crucible", "0.3.32")]
	[BepInDependency("com.meadworks.crucible.ui", "0.3.21")]
	[BepInDependency("com.jotunn.jotunn", "2.30.2")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string Guid = "com.meadworks.kindle";

		public const string Name = "Kindle";

		public const string Version = "0.1.25";

		public const string Family = "Forge";

		private ProductRegistration? registration;

		private MeadworksLog? log;

		private KindleReferenceImport? referenceImport;

		private bool started;

		private long noticedSession = -1L;

		internal static ProductRegistration? Source { get; private set; }

		public static bool Ready { get; private set; }

		public static bool SteppedAside { get; private set; }

		public static bool GameplayAvailable
		{
			get
			{
				ConfigBlockReason val = default(ConfigBlockReason);
				if (Ready && !SteppedAside)
				{
					return MeadworksAuthority.ProductActive("com.meadworks.kindle", ref val);
				}
				return false;
			}
		}

		public static bool AllowsUi { get; private set; }

		public static KindleConfig? Settings { get; private set; }

		private void Awake()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			log = MeadworksLog.For(((BaseUnityPlugin)this).Logger, "Kindle");
			try
			{
				if (!Plugin.IsReady)
				{
					throw new InvalidOperationException("Required Crucible is not ready");
				}
				registration = Plugin.Services.Register(new ProductMetadata("com.meadworks.kindle", "Kindle", new Version("0.1.25"), new Version(0, 1), new Version(0, 1), (MultiplayerPolicy)1, "Forge"));
				Source = registration;
				AllowsUi = MeadworksHeadless.AllowsUi;
				Settings = KindleConfig.Bind(((BaseUnityPlugin)this).Config, log);
				KindleText.Initialize(((BaseUnityPlugin)this).Info.Metadata, ((BaseUnityPlugin)this).Logger);
				referenceImport = new KindleReferenceImport(((BaseUnityPlugin)this).Config, Settings, log);
				SalvageTabCapability.Register(registration);
				SalvageStackCapability.Register(registration);
				Ready = true;
				log.Info(AllowsUi ? "Kindle registered; crafting modules start after plugin discovery." : "Kindle registered on a headless process; no UI is created.");
			}
			catch (Exception ex)
			{
				Shutdown();
				log.Error((object)("Kindle initialization rejected: " + ex));
			}
		}

		private void Start()
		{
			if (!Ready || Settings == null || registration == null || log == null)
			{
				return;
			}
			try
			{
				SteppedAside = KindleReferenceImport.DeclareAndYield();
				KindleSalvage.Initialize(((BaseUnityPlugin)this).Config, registration, delegate(string message)
				{
					log.Warning(message);
				});
				if (!SteppedAside && AllowsUi)
				{
					KindleRecipes.Initialize(Settings, log);
					KindleBatch.Initialize(Settings, log);
					KindleTracker.Initialize(Settings, log);
					KindleCarts.Initialize(Settings, log);
					KindleVirtualStation.Initialize(Settings);
					KindleStationReach.Initialize(Settings);
					KindleRepair.Initialize();
					KindleRecipes.ToggleTracking = KindleTracker.Toggle;
					KindleRecipes.IsTracked = KindleTracker.IsTracked;
					Localization.OnLanguageChange = (Action)Delegate.Combine(Localization.OnLanguageChange, new Action(Relabel));
				}
				started = true;
			}
			catch (Exception ex)
			{
				log.Error((object)("Kindle modules rejected: " + ex.GetType().Name + ": " + ex.Message));
				Shutdown();
			}
		}

		private void Update()
		{
			if (!Ready)
			{
				return;
			}
			Settings?.Tick(Time.unscaledTime);
			KindleText.Tick();
			if (!started)
			{
				return;
			}
			referenceImport?.Tick(GameplayAvailable);
			if (SteppedAside && AllowsUi && InventoryGui.IsVisible() && (Object)(object)MessageHud.instance != (Object)null && noticedSession != Plugin.Session.Generation)
			{
				noticedSession = Plugin.Session.Generation;
				IReadOnlyList<SourceMod> present = MeadworksStepAside.Decide("com.meadworks.kindle").Present;
				MessageHud.instance.ShowMessage((MessageType)2, KindleText.Format("step_aside", string.Join(", ", present.Select((SourceMod source) => source.Name))), 0, (Sprite)null, false, true);
			}
			KindleSalvage.Tick();
			if (GameplayAvailable && AllowsUi)
			{
				KindleRecipes.Tick();
				KindleBatch.Tick();
				KindleTracker.Tick();
				KindleCarts.Tick();
				KindleVirtualStation.Tick();
			}
		}

		private void Relabel()
		{
			if (!GameplayAvailable || !AllowsUi)
			{
				return;
			}
			try
			{
				KindleSalvage.Tick();
				KindleRecipes.Relabel();
				KindleTracker.Relabel();
			}
			catch (Exception ex)
			{
				MeadworksLog? obj = log;
				if (obj != null)
				{
					obj.Warning("Kindle language refresh: " + ex.GetType().Name + ": " + ex.Message);
				}
			}
		}

		private void OnDestroy()
		{
			Shutdown();
		}

		private void Shutdown()
		{
			Localization.OnLanguageChange = (Action)Delegate.Remove(Localization.OnLanguageChange, new Action(Relabel));
			Ready = false;
			started = false;
			noticedSession = -1L;
			Action[] array = new Action[9]
			{
				KindleRepair.Shutdown,
				KindleRecipes.Shutdown,
				KindleBatch.Shutdown,
				KindleTracker.Shutdown,
				KindleCarts.Shutdown,
				KindleVirtualStation.Shutdown,
				KindleStationReach.Shutdown,
				KindleSalvage.Shutdown,
				KindleText.Shutdown
			};
			foreach (Action action in array)
			{
				try
				{
					action();
				}
				catch (Exception ex)
				{
					MeadworksLog? obj = log;
					if (obj != null)
					{
						obj.Warning("Kindle teardown: " + ex.GetType().Name);
					}
				}
			}
			referenceImport?.Dispose();
			referenceImport = null;
			Settings?.Shutdown();
			Settings = null;
			Source = null;
			ProductRegistration? obj2 = registration;
			if (obj2 != null)
			{
				obj2.Dispose();
			}
			registration = null;
			SteppedAside = false;
		}
	}
	public static class KindleRecipes
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static PopupButtonCallback <0>__Pop;

			public static EventHandler <1>__Changed;

			public static Func<RecipeDataPair, RecipeFacts?> <2>__Facts;
		}

		private static readonly string[] categoryIcons = new string[8] { "ArrowWood", "SwordIron", "Bow", "HelmetBronze", "ShieldWood", "Hammer", "CookedMeat", "Wood" };

		private static readonly Color categoryDim = new Color(0.5f, 0.5f, 0.5f, 0.75f);

		private static readonly KitListShrink categoryShrink = new KitListShrink();

		private static readonly List<KitIconButton> categoryButtons = new List<KitIconButton>();

		private static RectTransform categoryRow;

		private static RecipeCategory picked = (RecipeCategory)0;

		private static bool steady;

		private static bool steadySearch;

		private static bool steadyCategories;

		private static Vector2 steadyPosition;

		private static Vector2 steadySize;

		private static TrackLabelState shownTrack;

		private static GameObject hoveredRow;

		private static Recipe hoveredRecipe;

		private static KitIconButton favouriteButton;

		private static Button trackButton;

		private static RectTransform style;

		private static Sprite starSprite;

		private static Color starColour = new Color(1f, 0.713f, 0.361f, 1f);

		private static float nextStar;

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

		private static KindleConfig config;

		private static MeadworksLog log;

		private static Harmony patches;

		private static InventoryGui owner;

		private static Player cachedFor;

		private static FavouriteRecipes favourites = FavouriteRecipes.Parse((string)null, (string)null);

		private static readonly RecipeKeyIndex<Recipe> index = new RecipeKeyIndex<Recipe>((Func<Recipe, string>)Key, (Func<Recipe, bool>)((Recipe r) => Object.op_Implicit((Object)(object)r) && Object.op_Implicit((Object)(object)r.m_item)));

		private static KitSearchRow search;

		private static KitTileList tiles;

		private static KitLatch latch = new KitLatch();

		private static RecipeQuery query = RecipeQuery.All;

		private static string queryText = "";

		private static bool rebuilding;

		private static readonly Dictionary<string, KitIconButton> searchButtons = new Dictionary<string, KitIconButton>();

		private static Recipe keyRecipe;

		private static string keyText = "";

		private static readonly string[] viewKeys = new string[5] { "recipe_view_list", "recipe_view_compact", "recipe_view_small", "recipe_view_medium", "recipe_view_large" };

		private static readonly KitGlyph[] sortGlyphs;

		private static readonly string[] sortKeys;

		private static SearchButtonsState shownSearch;

		public static RecipeCategory PickedCategories
		{
			get
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)categoryRow) || !((Component)categoryRow).gameObject.activeSelf)
				{
					return (RecipeCategory)0;
				}
				return picked;
			}
		}

		private static Recipe Hovered
		{
			get
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				if (!Object.op_Implicit((Object)(object)hoveredRow) || !hoveredRow.activeInHierarchy || !RectTransformUtility.RectangleContainsScreenPoint((RectTransform)hoveredRow.transform, Vector2.op_Implicit(ZInput.pointerPosition)))
				{
					return null;
				}
				return hoveredRecipe;
			}
		}

		public static Action<Recipe, int, int, bool> ToggleTracking { get; set; }

		public static Func<Recipe, int, bool, bool> IsTracked { get; set; }

		public static bool Active
		{
			get
			{
				if (config != null && Plugin.GameplayAvailable && Plugin.AllowsUi && Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return Object.op_Implicit((Object)(object)ZNet.instance);
				}
				return false;
			}
		}

		public static RecipeQuery Query
		{
			get
			{
				if (search == null || !search.Shown)
				{
					return RecipeQuery.All;
				}
				return query;
			}
		}

		public static bool Upgrader
		{
			get
			{
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.GetCurrentCraftingStation()))
				{
					return Player.m_localPlayer.GetCurrentCraftingStation().m_upgrader;
				}
				return false;
			}
		}

		private static RecipeSort Sort
		{
			get
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				Player localPlayer = Player.m_localPlayer;
				string text = default(string);
				localPlayer.TryGetUniqueKeyValue("sortcraft", ref text);
				string text2 = default(string);
				return RecipeSorts.FromStored(text, localPlayer.TryGetUniqueKeyValue("kindle_sort_desc", ref text2));
			}
		}

		private static RecipeCategory CategoryOf(ItemData item)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_007d: Expected I4, but got Unknown
			SharedData val = item?.m_shared;
			if (val == null)
			{
				return (RecipeCategory)0;
			}
			ItemType itemType = val.m_itemType;
			switch (itemType - 1)
			{
			case 1:
				if (!(val.m_food > 0f) && !(val.m_foodStamina > 0f) && !(val.m_foodEitr > 0f) && !(val.m_foodRegen > 0f))
				{
					return (RecipeCategory)0;
				}
				return (RecipeCategory)64;
			case 0:
				return (RecipeCategory)128;
			case 3:
				return (RecipeCategory)4;
			case 5:
			case 6:
			case 10:
			case 16:
			case 17:
				return (RecipeCategory)8;
			case 8:
			case 22:
				return (RecipeCategory)1;
			case 4:
				return (RecipeCategory)16;
			case 18:
				return (RecipeCategory)32;
			default:
				if (item.IsWeapon())
				{
					return (RecipeCategory)2;
				}
				return (RecipeCategory)0;
			}
		}

		private static void BuildCategories()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)categoryRow) || search == null || !Object.op_Implicit((Object)(object)search.List))
			{
				return;
			}
			RectTransform list = search.List;
			GameObject val = new GameObject("Kindle_recipe_categories", new Type[1] { typeof(RectTransform) });
			val.layer = ((Component)list).gameObject.layer;
			categoryRow = (RectTransform)val.transform;
			((Transform)categoryRow).SetParent(((Transform)list).parent, false);
			((Transform)categoryRow).SetSiblingIndex(((Transform)search.Row).GetSiblingIndex() + 1);
			RectTransform obj = categoryRow;
			RectTransform obj2 = categoryRow;
			RectTransform obj3 = categoryRow;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0f, 1f);
			obj3.pivot = val2;
			Vector2 anchorMin = (obj2.anchorMax = val2);
			obj.anchorMin = anchorMin;
			for (int i = 0; i < RecipeCategories.All.Count; i++)
			{
				RecipeCategory category = RecipeCategories.All[i];
				string text = ((object)Unsafe.As<RecipeCategory, RecipeCategory>(ref category)/*cast due to .constrained prefix*/).ToString().ToLowerInvariant();
				KitIconButton val4 = KitIconButton.Create(categoryRow, "Kindle_recipe_category_" + text, (KitGlyph)0, Vector2.zero, 26f, (Action<KitClickKind>)delegate
				{
					Guard(delegate
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						PickCategory(category);
					});
				});
				if (val4 != null)
				{
					GameObject val5 = (Object.op_Implicit((Object)(object)ObjectDB.instance) ? ObjectDB.instance.GetItemPrefab(categoryIcons[i]) : null);
					ItemDrop val6 = (Object.op_Implicit((Object)(object)val5) ? val5.GetComponent<ItemDrop>() : null);
					if (Object.op_Implicit((Object)(object)val6))
					{
						val4.SetSprite(val6.m_itemData.GetIcon(), false);
					}
					val4.Tooltip(KindleText.Text("recipe_cat_" + text), KindleText.Text("recipe_cat_tip"));
					categoryButtons.Add(val4);
				}
			}
			val.SetActive(false);
		}

		private static void PickCategory(RecipeCategory category)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				picked = RecipeCategories.Toggle(picked, category);
				InventoryGui instance = InventoryGui.instance;
				ScrollRect val = ((Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)instance.m_recipeListRoot)) ? ((Component)instance.m_recipeListRoot).GetComponentInParent<ScrollRect>() : null);
				if (Object.op_Implicit((Object)(object)val))
				{
					val.verticalNormalizedPosition = 1f;
				}
				RefreshCategories();
				Rebuild();
			}
		}

		private static void TickRows(InventoryGui gui, bool showSearch)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			RectTransform list = search.List;
			bool flag = config.Get<bool>(RecipeList.Categories) && !CustomTabSelected(gui);
			if (flag)
			{
				BuildCategories();
			}
			bool flag2 = (Object.op_Implicit((Object)(object)categoryRow) ? (((Component)categoryRow).gameObject.activeSelf == flag) : (!flag));
			if (steady && Object.op_Implicit((Object)(object)list) && list.anchoredPosition == steadyPosition && list.sizeDelta == steadySize && showSearch == steadySearch && flag == steadyCategories && search.Shown == showSearch && flag2)
			{
				if (flag && Object.op_Implicit((Object)(object)categoryRow))
				{
					LayoutCategories();
					RefreshCategories();
				}
				return;
			}
			ShrinkForCategories(gui, list, on: false);
			search.Tick(showSearch);
			if (Object.op_Implicit((Object)(object)categoryRow))
			{
				if (((Component)categoryRow).gameObject.activeSelf != flag)
				{
					((Component)categoryRow).gameObject.SetActive(flag);
				}
				ShrinkForCategories(gui, list, flag);
				if (flag)
				{
					LayoutCategories();
					RefreshCategories();
				}
			}
			steady = Object.op_Implicit((Object)(object)list);
			if (steady)
			{
				steadyPosition = list.anchoredPosition;
				steadySize = list.sizeDelta;
				steadySearch = showSearch;
				steadyCategories = flag;
			}
		}

		private static void ShrinkForCategories(InventoryGui gui, RectTransform list, bool on)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)list) || (!on && !categoryShrink.Shrunk))
			{
				return;
			}
			KitShrinkResult val = categoryShrink.Apply(KitUnity.Vector(list.anchoredPosition), KitUnity.Vector(list.sizeDelta), on, 34f, 30f);
			if (Object.op_Implicit((Object)(object)categoryRow))
			{
				categoryRow.anchoredPosition = KitUnity.Vector(((KitShrinkResult)(ref val)).RowPosition);
				categoryRow.sizeDelta = KitUnity.Vector(((KitShrinkResult)(ref val)).RowSize);
			}
			if (((KitShrinkResult)(ref val)).Write)
			{
				list.anchoredPosition = KitUnity.Vector(((KitShrinkResult)(ref val)).ListPosition);
				list.sizeDelta = KitUnity.Vector(((KitShrinkResult)(ref val)).ListSize);
				if (Object.op_Implicit((Object)(object)gui))
				{
					gui.m_recipeListBaseSize = list.sizeDelta.y;
				}
			}
		}

		private static void LayoutCategories()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			int count = categoryButtons.Count;
			if (count != 0)
			{
				float x = categoryRow.sizeDelta.x;
				float num = Mathf.Floor(Mathf.Min(26f, (x - 2f * (float)(count - 1)) / (float)count));
				float num2 = ((count > 1) ? ((x - num * (float)count) / (float)(count - 1)) : 0f);
				for (int i = 0; i < count; i++)
				{
					RectTransform val = (RectTransform)((Component)categoryButtons[i].Button).transform;
					val.sizeDelta = new Vector2(num, num);
					val.anchoredPosition = new Vector2(Mathf.Round((float)i * (num + num2)), (0f - (30f - num)) / 2f);
				}
			}
		}

		private static void RefreshCategories()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_005c: 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)
			for (int i = 0; i < categoryButtons.Count && i < RecipeCategories.All.Count; i++)
			{
				KitIconButton val = categoryButtons[i];
				bool flag = RecipeCategories.IsPicked(picked, RecipeCategories.All[i]);
				if (val.On != flag)
				{
					val.SetOn(flag);
				}
				if (Object.op_Implicit((Object)(object)val.Glyph))
				{
					((Graphic)val.Glyph).color = (((int)picked == 0 || flag) ? Color.white : categoryDim);
				}
			}
		}

		private static void HideRows()
		{
			if (search != null)
			{
				steady = false;
				ShrinkForCategories(owner, search.List, on: false);
				if (Object.op_Implicit((Object)(object)categoryRow) && ((Component)categoryRow).gameObject.activeSelf)
				{
					((Component)categoryRow).gameObject.SetActive(false);
				}
				search.Tick(false);
			}
		}

		private static void DetachCategories()
		{
			steady = false;
			if (search != null)
			{
				ShrinkForCategories(owner, search.List, on: false);
			}
			categoryShrink.Reset();
			categoryButtons.Clear();
			if (Object.op_Implicit((Object)(object)categoryRow))
			{
				KitUnity.Retire(((Component)categoryRow).gameObject);
			}
			categoryRow = null;
		}

		private static void Star()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)starSprite) && !(Time.unscaledTime < nextStar))
			{
				nextStar = Time.unscaledTime + 2f;
				BuildUi val = (Object.op_Implicit((Object)(object)Hud.instance) ? Hud.instance.m_buildUi : null);
				BuildUiPieceButton val2 = ((Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.m_pieceButtonPrefab)) ? val.m_pieceButtonPrefab.GetComponent<BuildUiPieceButton>() : null);
				Image val3 = (Object.op_Implicit((Object)(object)val2) ? val2.m_favoriteStar : null);
				if (Object.op_Implicit((Object)(object)val3) && Object.op_Implicit((Object)(object)val3.sprite))
				{
					starSprite = val3.sprite;
					starColour = ((Graphic)val3).color;
				}
			}
		}

		private static void Decorate(InventoryGui gui)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			hoveredRow = null;
			Star();
			foreach (RecipeDataPair availableRecipe in gui.m_availableRecipes)
			{
				RecipeDataPair current = availableRecipe;
				GameObject row = ((RecipeDataPair)(ref current)).InterfaceElement;
				Recipe recipe = ((RecipeDataPair)(ref current)).Recipe;
				if (!Object.op_Implicit((Object)(object)row) || !Object.op_Implicit((Object)(object)recipe))
				{
					continue;
				}
				UIInputHandler obj = row.GetComponent<UIInputHandler>() ?? row.AddComponent<UIInputHandler>();
				int quality = Quality(((RecipeDataPair)(ref current)).ItemData);
				obj.m_onMiddleClick = delegate
				{
					Guard(delegate
					{
						ToggleFavourite(recipe);
					});
				};
				obj.m_onRightClick = delegate
				{
					Guard(delegate
					{
						Track(gui, recipe, quality);
					});
				};
				obj.m_onPointerEnter = (Action<UIInputHandler>)Delegate.Combine(obj.m_onPointerEnter, (Action<UIInputHandler>)delegate
				{
					hoveredRow = row;
					hoveredRecipe = recipe;
				});
				obj.m_onPointerExit = (Action<UIInputHandler>)Delegate.Combine(obj.m_onPointerExit, (Action<UIInputHandler>)delegate
				{
					if ((Object)(object)hoveredRow == (Object)(object)row)
					{
						hoveredRow = null;
					}
				});
				RectTransform val = (RectTransform)row.transform;
				tiles.Mark(val, Favourite(recipe), starSprite, (Color?)starColour);
				tiles.Greyed(val, !((RecipeDataPair)(ref current)).CanCraft);
				if (!RecipeViews.IsGrid(config.Get<RecipeView>(RecipeList.RecipeView)))
				{
					continue;
				}
				KitTileList obj2 = tiles;
				object obj3 = recipe.m_item?.m_itemData?.m_shared?.m_name;
				if (obj3 == null)
				{
					ItemDrop item = recipe.m_item;
					if (item == null)
					{
						obj3 = null;
					}
					else
					{
						GameObject gameObject = ((Component)item).gameObject;
						obj3 = ((gameObject != null) ? ((Object)gameObject).name : null);
					}
					if (obj3 == null)
					{
						obj3 = ((Object)recipe).name;
					}
				}
				obj2.Tooltip(val, Localize((string)obj3), (recipe.m_amount > 1) ? ("x" + recipe.m_amount) : "");
			}
		}

		private static void ToggleFavourite(Recipe recipe)
		{
			if (!Active || !Object.op_Implicit((Object)(object)recipe) || !config.Get<bool>(RecipeList.Favourites))
			{
				return;
			}
			ReadFavourites();
			bool num = favourites.Toggle(Key(recipe));
			WriteFavourites();
			string key = (num ? "recipe_favorite_on" : "recipe_favorite_off");
			object[] array = new object[1];
			object obj = recipe.m_item?.m_itemData?.m_shared?.m_name;
			if (obj == null)
			{
				ItemDrop item = recipe.m_item;
				if (item == null)
				{
					obj = null;
				}
				else
				{
					GameObject gameObject = ((Component)item).gameObject;
					obj = ((gameObject != null) ? ((Object)gameObject).name : null);
				}
				if (obj == null)
				{
					obj = ((Object)recipe).name;
				}
			}
			array[0] = Localize((string)obj);
			KindleText.Notice(KindleText.Format(key, array));
		}

		private static void Only(KitClickKind kind)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Invalid comparison between Unknown and I4
			//IL_00fd: 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_0102: Invalid comparison between Unknown and I4
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			if (!Active || !config.Get<bool>(RecipeList.Favourites))
			{
				return;
			}
			ReadFavourites();
			if ((int)kind == 1)
			{
				if (favourites.Count == 0)
				{
					Message("recipe_none");
				}
				else
				{
					if (!UnifiedPopup.IsAvailable())
					{
						return;
					}
					Player captured = Player.m_localPlayer;
					Action clear = delegate
					{
						Guard(delegate
						{
							if (Active && !((Object)(object)Player.m_localPlayer != (Object)(object)captured))
							{
								ReadFavourites();
								favourites.Clear();
								WriteFavourites();
								Message("recipe_cleared");
							}
						});
					};
					string text = KindleText.Text("recipe_only_topic");
					string text2 = KindleText.Format("recipe_clear_ask", favourites.Count);
					if (Plugin.Source == null || KitDialogs.Confirm(Plugin.Source, text, text2, clear, (Action)null, true) == null)
					{
						PopupButtonCallback val = delegate
						{
							UnifiedPopup.Pop();
							clear();
						};
						object obj = <>O.<0>__Pop;
						if (obj == null)
						{
							PopupButtonCallback val2 = UnifiedPopup.Pop;
							<>O.<0>__Pop = val2;
							obj = (object)val2;
						}
						UnifiedPopup.Push((PopupBase)new YesNoPopup(text, text2, val, (PopupButtonCallback)obj, true, false));
					}
				}
			}
			else
			{
				OnlyToggle val3 = favourites.ToggleOnly();
				if ((int)val3 != 2)
				{
					WriteFavourites();
				}
				Message(((int)val3 == 0) ? "recipe_only_on" : (((int)val3 == 1) ? "recipe_only_off" : "recipe_none"));
			}
		}

		private static void Message(string key)
		{
			KindleText.Notice(KindleText.Text(key));
		}

		private static void Track(InventoryGui gui, Recipe recipe, int quality)
		{
			if (Active && Object.op_Implicit((Object)(object)recipe) && config.Get<bool>(Tracker.Enabled))
			{
				int arg = ((!gui.InCraftTab() || !((Object)(object)Selected(gui) == (Object)(object)recipe)) ? 1 : KindleBatch.NextCraft(gui, Player.m_localPlayer));
				ToggleTracking?.Invoke(recipe, quality, arg, Upgrader);
			}
		}

		private static void RefreshActions(InventoryGui gui)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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_00ef: Expected O, but got Unknown
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)gui.m_variantButton))
			{
				HideActions();
				return;
			}
			style = (RectTransform)((Component)gui.m_variantButton).transform;
			Rect rect;
			if (favouriteButton == null || !Object.op_Implicit((Object)(object)favouriteButton.Button))
			{
				RectTransform val = (RectTransform)((Transform)style).parent;
				Vector2 zero = Vector2.zero;
				rect = style.rect;
				favouriteButton = KitIconButton.Create(val, "Kindle_favourite", (KitGlyph)10, zero, ((Rect)(ref rect)).height, (Action<KitClickKind>)delegate
				{
					Guard(delegate
					{
						ToggleFavourite(Selected(gui));
					});
				});
				RectTransform val2 = (RectTransform)((Transform)style).parent;
				string text = KindleText.Text("tracker_track");
				Action obj = delegate
				{
					Guard(delegate
					{
						Track(gui, Selected(gui), Quality(((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData));
					});
				};
				Vector2 zero2 = Vector2.zero;
				rect = style.rect;
				trackButton = KitButton.Create(val2, "Kindle_track", text, obj, zero2, new Vector2(80f, ((Rect)(ref rect)).height));
				if (favouriteButton != null)
				{
					favouriteButton.Tooltip(KindleText.Text("recipe_favorite_topic"), KindleText.Text("recipe_favorite_tip"));
				}
			}
			Recipe val3 = Selected(gui);
			int num;
			int num2;
			if (Object.op_Implicit((Object)(object)val3))
			{
				num = ((!CustomTabSelected(gui)) ? 1 : 0);
				if (num != 0 && config.Get<bool>(Tracker.Enabled))
				{
					num2 = ((ToggleTracking != null) ? 1 : 0);
					goto IL_015d;
				}
			}
			else
			{
				num = 0;
			}
			num2 = 0;
			goto IL_015d;
			IL_015d:
			bool flag = (byte)num2 != 0;
			bool flag2 = num != 0 && config.Get<bool>(RecipeList.Favourites);
			if (Object.op_Implicit((Object)(object)trackButton))
			{
				((Component)trackButton).gameObject.SetActive(flag);
			}
			if (favouriteButton != null && Object.op_Implicit((Object)(object)favouriteButton.Button))
			{
				((Component)favouriteButton.Button).gameObject.SetActive(flag2);
			}
			if (num == 0)
			{
				return;
			}
			float x = style.anchoredPosition.x;
			rect = style.rect;
			float num3 = x - ((Rect)(ref rect)).width * style.pivot.x;
			if (((Component)style).gameObject.activeSelf)
			{
				float num4 = num3;
				rect = style.rect;
				num3 = num4 + (((Rect)(ref rect)).width + 6f);
			}
			if (flag && Object.op_Implicit((Object)(object)trackButton))
			{
				bool flag3 = IsTracked?.Invoke(val3, Quality(((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData), Upgrader) ?? false;
				TrackLabelState val4 = default(TrackLabelState);
				((TrackLabelState)(ref val4))..ctor((object)trackButton, flag3, KindleText.Revision);
				if (!((TrackLabelState)(ref val4)).Equals(shownTrack))
				{
					shownTrack = val4;
					string text2 = KindleText.Text(flag3 ? "tracker_untrack" : "tracker_track");
					TMP_Text componentInChildren = ((Component)trackButton).GetComponentInChildren<TMP_Text>(true);
					if (componentInChildren != null)
					{
						componentInChildren.text = text2;
					}
					KitTooltip.Set(((Component)trackButton).gameObject, text2, text2);
				}
				num3 = PlaceAction((RectTransform)((Component)trackButton).transform, num3);
			}
			if (flag2 && favouriteButton != null)
			{
				Star();
				favouriteButton.SetSprite(starSprite, true);
				favouriteButton.SetOn(Favourite(val3));
				PlaceAction((RectTransform)((Component)favouriteButton.Button).transform, num3);
			}
		}

		private static float PlaceAction(RectTransform rect, float x)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = style.anchorMin;
			rect.anchorMax = style.anchorMax;
			Rect rect2 = rect.rect;
			rect.anchoredPosition = new Vector2(x + ((Rect)(ref rect2)).width * rect.pivot.x, style.anchoredPosition.y);
			rect2 = rect.rect;
			return x + ((Rect)(ref rect2)).width + 6f;
		}

		private static void HideActions()
		{
			if (Object.op_Implicit((Object)(object)trackButton))
			{
				((Component)trackButton).gameObject.SetActive(false);
			}
			if (favouriteButton != null && Object.op_Implicit((Object)(object)favouriteButton.Button))
			{
				((Component)favouriteButton.Button).gameObject.SetActive(false);
			}
		}

		private static void ClearActions()
		{
			if (Object.op_Implicit((Object)(object)trackButton))
			{
				Object.Destroy((Object)(object)((Component)trackButton).gameObject);
			}
			if (favouriteButton != null && Object.op_Implicit((Object)(object)favouriteButton.Button))
			{
				Object.Destroy((Object)(object)((Component)favouriteButton.Button).gameObject);
			}
			trackButton = null;
			favouriteButton = null;
			style = null;
			starSprite = null;
			nextStar = 0f;
			latched.Clear();
		}

		private static void InputTick()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (CustomTabSelected(InventoryGui.instance) || KitTextField.Typing)
			{
				return;
			}
			KeyboardShortcut val = config.Shortcut(RecipeList.SearchKey);
			if (((KeyboardShortcut)(ref val)).IsDown())
			{
				KitSearchRow obj = search;
				if (obj != null)
				{
					obj.Focus();
				}
			}
			if (Object.op_Implicit((Object)(object)Hovered))
			{
				val = config.Shortcut(RecipeList.FavouriteRecipeKey);
				if (((KeyboardShortcut)(ref val)).IsDown())
				{
					ToggleFavourite(Hovered);
				}
			}
		}

		private static bool Once(string button)
		{
			if (!ZInput.GetButton(button))
			{
				latched.Remove(button);
				return false;
			}
			if (ZInput.GetButtonDown(button))
			{
				return latched.Add(button);
			}
			return false;
		}

		internal static bool Gamepad(InventoryGui gui)
		{
			if (!Active || CustomTabSelected(gui))
			{
				return true;
			}
			if (KitTextField.Typing)
			{
				return false;
			}
			bool runGame = true;
			Guard(delegate
			{
				//IL_002b: 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_01ac: 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_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				if (config.Get<bool>(RecipeList.GamepadControls))
				{
					if (Once("JoyRStickUp"))
					{
						KitSearchRow obj = search;
						if (obj != null)
						{
							obj.Focus();
						}
					}
					if (Once("JoyRStickDown"))
					{
						Track(gui, Selected(gui), Quality(((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData));
					}
					if (Once("JoyRStickLeft"))
					{
						ToggleFavourite(Selected(gui));
					}
					if (Once("JoyRStickRight"))
					{
						Only((KitClickKind)0);
					}
					PadButton? gamepadSortButton = config.GamepadSortButton;
					if (gamepadSortButton.HasValue && Once(GamepadMap.ZInputName(gamepadSortButton.Value)))
					{
						CycleSort();
					}
				}
				if (tiles != null && tiles.Columns > 1)
				{
					runGame = false;
					int num = 0;
					int num2 = 0;
					if (ZInput.GetButtonDown("JoyLStickDown") || ZInput.GetButtonDown("JoyDPadDown"))
					{
						num2 = 1;
					}
					else if (ZInput.GetButtonDown("JoyLStickUp") || ZInput.GetButtonDown("JoyDPadUp"))
					{
						num2 = -1;
					}
					else if (ZInput.GetButtonDown("JoyLStickRight") || (!KindleBatch.Shown && ZInput.GetButtonDown("JoyDPadRight")))
					{
						num = 1;
					}
					else if (ZInput.GetButtonDown("JoyLStickLeft") || (!KindleBatch.Shown && ZInput.GetButtonDown("JoyDPadLeft")))
					{
						num = -1;
					}
					int selectedRecipeIndex = gui.GetSelectedRecipeIndex(false);
					if (selectedRecipeIndex >= 0 && gui.m_availableRecipes.Count != 0 && (num != 0 || num2 != 0))
					{
						GridCell val = tiles.Navigator((Func<int, bool>)null).Move(new GridCell(selectedRecipeIndex % tiles.Columns, selectedRecipeIndex / tiles.Columns), new GridCell(num, num2));
						gui.SetRecipe(((GridCell)(ref val)).Y * tiles.Columns + ((GridCell)(ref val)).X, true);
					}
				}
			});
			return runGame;
		}

		public static Recipe Selected(InventoryGui gui)
		{
			if (!Object.op_Implicit((Object)(object)gui))
			{
				return null;
			}
			return ((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe;
		}

		private static bool CustomTabSelected(InventoryGui gui)
		{
			if (Object.op_Implicit((Object)(object)gui) && Object.op_Implicit((Object)(object)gui.m_tabCraft))
			{
				Transform parent = ((Component)gui.m_tabCraft).transform.parent;
				return KitTabs.HasSelected((RectTransform)(object)((parent is RectTransform) ? parent : null));
			}
			return false;
		}

		public static int Quality(ItemData item)
		{
			if (item != null)
			{
				return item.m_quality + 1;
			}
			return 1;
		}

		public static string Key(Recipe recipe)
		{
			if (!Object.op_Implicit((Object)(object)recipe) || !Object.op_Implicit((Object)(object)recipe.m_item))
			{
				return "";
			}
			if (recipe == keyRecipe)
			{
				return keyText;
			}
			keyText = RecipeKeys.Of(((Object)recipe).name, ((Object)((Component)recipe.m_item).gameObject).name);
			keyRecipe = recipe;
			return keyText;
		}

		public static Recipe Find(string key)
		{
			if (!Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				return null;
			}
			return index.Find((object)ObjectDB.instance, (IReadOnlyList<Recipe>)ObjectDB.instance.m_recipes, key);
		}

		public static void Initialize(KindleConfig settings, MeadworksLog logger)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			Shutdown();
			config = settings;
			log = logger;
			config.Changed += Changed;
			patches = new Harmony("com.meadworks.kindle.recipes");
			patches.CreateClassProcessor(typeof(KindleRecipePatches)).Patch();
			patches.CreateClassProcessor(typeof(TypingStill)).Patch();
		}

		private static void Changed(object sender, EventArgs args)
		{
			Guard(delegate
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				shownSearch = default(SearchButtonsState);
				DetachCategories();
				KitSearchRow obj = search;
				if (obj != null)
				{
					obj.Detach();
				}
				search = null;
				searchButtons.Clear();
				query = RecipeQuery.Parse(queryText, config.Get<bool>(RecipeList.IgnoreAccents));
				Rebuild();
			});
		}

		internal static void Guard(Action action)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				MeadworksLog obj = log;
				if (obj != null)
				{
					obj.Warning("Recipe list: " + ex.GetType().Name + ": " + ex.Message);
				}
			}
		}

		private static void Bind(InventoryGui gui)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)owner == (Object)(object)gui))
			{
				ClearUi();
				owner = gui;
				queryText = "";
				query = RecipeQuery.All;
				latch = new KitLatch();
				picked = (RecipeCategory)0;
			}
		}

		private static void ReadFavourites()
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)cachedFor == (Object)(object)localPlayer))
			{
				cachedFor = localPlayer;
				localPlayer.m_customData.TryGetValue("Kindle.favoriteRecipes", out var value);
				localPlayer.m_customData.TryGetValue("Kindle.favoriteRecipesOnly", out var value2);
				favourites = FavouriteRecipes.Parse(value, value2);
			}
		}

		private static void WriteFavourites()
		{
			Dictionary<string, string> customData = Player.m_localPlayer.m_customData;
			Write(customData, "Kindle.favoriteRecipes", favourites.SerializeSet());
			Write(customData, "Kindle.favoriteRecipesOnly", favourites.SerializeOnly());
			Rebuild();
		}

		private static void Write(Dictionary<string, string> data, string key, string value)
		{
			if (value == null)
			{
				data.Remove(key);
			}
			else
			{
				data[key] = value;
			}
		}

		private static bool Favourite(Recipe recipe)
		{
			if (config.Get<bool>(RecipeList.Favourites))
			{
				return favourites.Contains(Key(recipe));
			}
			return false;
		}

		private static void CycleSort()
		{
			CycleSort((KitClickKind)0);
		}

		private static void CycleSort(KitClickKind kind)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (Active)
			{
				(string, bool) tuple = RecipeSorts.ToStored(((int)kind == 1) ? RecipeSorts.Previous(Sort) : RecipeSorts.Next(Sort));
				Player localPlayer = Player.m_localPlayer;
				localPlayer.RemoveUniqueKeyValue("sortcraft");
				localPlayer.RemoveUniqueKeyValue("kindle_sort_desc");
				if (tuple.Item1 != null)
				{
					localPlayer.AddUniqueKeyValue("sortcraft", tuple.Item1);
				}
				if (tuple.Item2)
				{
					localPlayer.AddUniqueKeyValue("kindle_sort_desc", "1");
				}
				Rebuild();
			}
		}

		public static void Rebuild()
		{
			if (!Active || rebuilding || !Object.op_Implicit((Object)(object)InventoryGui.instance) || !InventoryGui.IsVisible())
			{
				return;
			}
			Guard(delegate
			{
				rebuilding = true;
				try
				{
					InventoryGui.instance.UpdateCraftingPanel(false);
				}
				finally
				{
					rebuilding = false;
				}
			});
		}

		private static RecipeFacts Facts(RecipeDataPair pair)
		{
			//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_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			Recipe recipe = ((RecipeDataPair)(ref pair)).Recipe;
			if (!Object.op_Implicit((Object)(object)recipe) || !Object.op_Implicit((Object)(object)recipe.m_item))
			{
				return null;
			}
			RecipeMaterial[] array = recipe.m_resources.Where((Requirement r) => Object.op_Implicit((Object)(object)r.m_resItem)).Select((Func<Requirement, RecipeMaterial>)((Requirement r) => new RecipeMaterial(Localize(r.m_resItem.m_itemData?.m_shared?.m_name ?? ((Object)((Component)r.m_resItem).gameObject).name), ((Object)((Component)r.m_resItem).gameObject).name, r.GetAmount(Quality(((RecipeDataPair)(ref pair)).ItemData)), r.m_upgraderResource))).ToArray();
			string text = Localize(recipe.m_item.m_itemData?.m_shared?.m_name ?? ((Object)((Component)recipe.m_item).gameObject).name);
			return new RecipeFacts(Key(recipe), text, ((Object)((Component)recipe.m_item).gameObject).name, (IReadOnlyList<RecipeMaterial>)array, ((RecipeDataPair)(ref pair)).CanCraft, recipe.m_listSortWeight, ((RecipeDataPair)(ref pair)).ItemData?.m_quality ?? 0, CategoryOf(recipe.m_item.m_itemData));
		}

		private static string Localize(string text)
		{
			if (Localization.instance == null)
			{
				return text;
			}
			return Localization.instance.Localize(text);
		}

		internal static void Apply(InventoryGui gui)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (!Active || CustomTabSelected(gui))
			{
				return;
			}
			Prepare(gui);
			ReadFavourites();
			RecipePipeline.Apply<RecipeDataPair>((IList<RecipeDataPair>)gui.m_availableRecipes, (Func<RecipeDataPair, RecipeFacts>)Facts, new RecipeListState(Query, favourites, Sort, config.Get<bool>(RecipeList.Favourites), config.Get<bool>(RecipeList.FavouritesFirst), Upgrader, (CultureInfo)null, PickedCategories), (Action<RecipeDataPair>)delegate(RecipeDataPair pair)
			{
				if (Object.op_Implicit((Object)(object)((RecipeDataPair)(ref pair)).InterfaceElement))
				{
					Object.Destroy((Object)(object)((RecipeDataPair)(ref pair)).InterfaceElement);
				}
			});
			KitTileList obj = tiles;
			if (obj != null)
			{
				obj.Forget();
			}
			tiles = KitTileList.For(gui.m_recipeListRoot, gui.m_recipeListSpace, gui.m_recipeListBaseSize, (KitTileParts)null);
			if (tiles != null)
			{
				tiles.View = (KitTileView)config.Get<RecipeView>(RecipeList.RecipeView);
				tiles.Arrange((IList<RectTransform>)gui.m_availableRecipes.Where((RecipeDataPair p) => Object.op_Implicit((Object)(object)((RecipeDataPair)(ref p)).InterfaceElement)).Select((Func<RecipeDataPair, RectTransform>)((RecipeDataPair p) => (RectTransform)((RecipeDataPair)(ref p)).InterfaceElement.transform)).ToList());
				Decorate(gui);
			}
		}

		internal static void Prepare(InventoryGui gui)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			//IL_018b: Expected O, but got Unknown
			if (!Active)
			{
				return;
			}
			Bind(gui);
			ReadFavourites();
			KitTabs.RestoreEmptyRecipeCaption(gui, (Object)(object)((RecipeDataPair)(ref gui.m_selectedRecipe)).Recipe != (Object)null);
			if (search == null && !latch.Failed)
			{
				Transform val = (Object.op_Implicit((Object)(object)gui.m_recipeListRoot) ? ((Transform)gui.m_recipeListRoot).parent : null);
				object obj = (object)(Object.op_Implicit((Object)(object)val) ? /*isinst with value type is only supported in some contexts*/: null);
				List<KitSearchButton> list = new List<KitSearchButton>
				{
					new KitSearchButton
					{
						Id = "view",
						Glyph = (KitGlyph)0,
						Click = delegate(KitClickKind kind)
						{
							//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)
							Guard(delegate
							{
								//IL_0001: Unknown result type (might be due to invalid IL or missing references)
								CycleView(kind);
							});
						}
					}
				};
				if (config.Get<bool>(RecipeList.Favourites))
				{
					list.Add(new KitSearchButton
					{
						Id = "only",
						Glyph = (KitGlyph)10,
						Click = delegate(KitClickKind kind)
						{
							//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)
							Guard(delegate
							{
								//IL_0001: Unknown result type (might be due to invalid IL or missing references)
								Only(kind);
							});
						}
					});
				}
				if (config.Get<bool>(RecipeList.SortButton))
				{
					list.Add(new KitSearchButton
					{
						Id = "sort",
						Glyph = (KitGlyph)9,
						Click = delegate(KitClickKind kind)
						{
							//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)
							Guard(delegate
							{
								//IL_0001: Unknown result type (might be due to invalid IL or missing references)
								CycleSort(kind);
							});
						}
					});
				}
				search = KitSearchRow.Attach((RectTransform)obj, "Kindle_recipe_search", (IList<KitSearchButton>)list, latch, KindleText.Text("recipe_search"));
				if (search != null)
				{
					search.ListWritten += delegate(Vector2 size)
					{
						//IL_0006: Unknown result type (might be due to invalid IL or missing references)
						gui.m_recipeListBaseSize = size.y;
					};
					search.Field.ReportChat = true;
					search.Field.Text = queryText;
					search.Field.Changed += delegate(string text)
					{
						queryText = text;
						query = RecipeQuery.Parse(text, config.Get<bool>(RecipeList.IgnoreAccents));
						ScrollRect componentInParent = ((Component)gui.m_recipeListRoot).GetComponentInParent<ScrollRect>();
						if (Object.op_Implicit((Object)(object)componentInParent))
						{
							componentInParent.verticalNormalizedPosition = 1f;
						}
						Rebuild();
					};
					for (int num = 0; num < search.Buttons.Count; num++)
					{
						searchButtons[list[num].Id] = search.Buttons[num];
					}
					KitTooltip.Set(((Component)search.Field.Rect).gameObject, KindleText.Text("recipe_search_topic"), KindleText.Text("recipe_search_tip"));
				}
			}
			if (search != null)
			{
				search.ClearOnClose = config.Get<bool>(RecipeList.ClearSearchOnClose);
				TickRows(gui, config.Get<bool>(RecipeList.Search) && !CustomTabSelected(gui));
				RefreshSearch();
			}
		}

		private static void CycleView(KitClickKind kind)
		{
			//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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (Active && config.TryChange((KindleSetting)(object)RecipeList.RecipeView))
			{
				RecipeView val = config.Get<RecipeView>(RecipeList.RecipeView);
				config.Entry((KindleSetting)(object)RecipeList.RecipeView).BoxedValue = (((int)kind == 1) ? RecipeViews.Previous(val) : RecipeViews.Next(val));
			}
		}

		private static void RefreshSearch()
		{
			//IL_001c: 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_003f: Expected I4, but got Unknown
			//IL_003f: Expected I4, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			SearchButtonsState val = default(SearchButtonsState);
			((SearchButtonsState)(ref val))..ctor((object)search, favourites.OnlyFavourites(true), (int)config.Get<RecipeView>(RecipeList.RecipeView), config.IsLocked((KindleSetting)(object)RecipeList.RecipeView), (int)Sort, KindleText.Revision);
			if (!((SearchButtonsState)(ref val)).Equals(shownSearch))
			{
				shownSearch = val;
				if (searchButtons.TryGetValue("only", out KitIconButton value))
				{
					value.SetOn(((SearchButtonsState)(ref val)).Only);
					value.Tooltip(KindleText.Text("recipe_only_topic"), KindleText.Text("recipe_only_tip"));
				}
				if (searchButtons.TryGetValue("view", out KitIconButton value2))
				{
					value2.SetGlyph((KitGlyph)((SearchButtonsState)(ref val)).View);
					value2.Tooltip(KindleText.Text(viewKeys[((SearchButtonsState)(ref val)).View]), KindleText.Text("recipe_view_tip"));
					value2.SetUsable(!((SearchButtonsState)(ref val)).ViewLocked);
				}
				if (searchButtons.TryGetValue("sort", out KitIconButton value3))
				{
					value3.SetGlyph(sortGlyphs[((SearchButtonsState)(ref val)).Sort]);
					value3.Tooltip(KindleText.Format("sort_topic", KindleText.Text(sortKeys[((SearchButtonsState)(ref val)).Sort])), KindleText.Text("sort_tip"));
				}
			}
		}

		internal static void Closed()
		{
			KitSearchRow obj = search;
			if (obj != null)
			{
				obj.Closed();
			}
			if (config != null && config.Get<bool>(RecipeList.ClearSearchOnClose))
			{
				queryText = "";
				query = RecipeQuery.All;
			}
		}

		public static void Tick()
		{
			if (!Active)
			{
				HideRows();
				HideActions();
			}
			else if (Object.op_Implicit((Object)(object)InventoryGui.instance) && InventoryGui.IsVisible())
			{
				Guard(delegate
				{
					Prepare(InventoryGui.instance);
					RefreshActions(InventoryGui.instance);
					InputTick();
				});
			}
		}

		internal static void Relabel()
		{
			if (!Active)
			{
				return;
			}
			ClearUi();
			InventoryGui gui = InventoryGui.instance;
			if (Object.op_Implicit((Object)(object)gui) && InventoryGui.IsVisible() && !CustomTabSelected(gui))
			{
				Guard(delegate
				{
					gui.UpdateCraftingPanel(false);
					RefreshActions(gui);
					gui.UpdateRecipe(Player.m_localPlayer, 0f);
				});
			}
		}

		private static void ClearUi()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			shownSearch = default(SearchButtonsState);
			shownTrack = default(TrackLabelState);
			DetachCategories();
			KitSearchRow obj = search;
			if (obj != null)
			{
				obj.Detach();
			}
			search = null;
			KitTileList obj2 = tiles;
			if (obj2 != null)
			{
				obj2.Forget();
			}
			tiles = null;
			searchButtons.Clear();
			ClearActions();
			hoveredRow = null;
		}

		public static void Shutdown()
		{
			if (config != null)
			{
				config.Changed -= Changed;
			}
			Harmony obj = patches;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			patches = null;
			ClearUi();
			if (Object.op_Implicit((Object)(object)owner) && Object.op_Implicit((Object)(object)Player.m_localPlayer) && InventoryGui.IsVisible() && !CustomTabSelected(owner))
			{
				Guard(delegate
				{
					owner.UpdateCraftingPanel(false);
				});
			}
			owner = null;
			cachedFor = null;
			config = null;
			log = null;
			query = RecipeQuery.All;
			queryText = "";
		}

		static KindleRecipes()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_007e: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			KitGlyph[] array = new KitGlyph[5];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			sortGlyphs = (KitGlyph[])(object)array;
			sortKeys = new string[5] { "sort_default", "sort_az", "sort_za", "sort_type", "sort_weight" };
		}
	}
	[HarmonyPatch]
	internal static class KindleRecipePatches
	{
		[HarmonyPatch(typeof(InventoryGui), "UpdateCraftingPanel")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prepare(InventoryGui __instance)
		{
			KindleRecipes.Guard(delegate
			{
				KindleRecipes.Prepare(__instance);
			});
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateCraftingPanel")]
		[HarmonyPostfix]
		private static void Prepared(InventoryGui __instance)
		{
			KindleRecipes.Guard(delegate
			{
				KindleRecipes.Prepare(__instance);
			});
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeList")]
		[HarmonyPostfix]
		private static void Listed(InventoryGui __instance)
		{
			KindleRecipes.Guard(delegate
			{
				KindleRecipes.Apply(__instance);
			});
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeGamepadInput")]
		[HarmonyPrefix]
		private static bool Pad(InventoryGui __instance)
		{
			return KindleRecipes.Gamepad(__instance);
		}

		[HarmonyPatch(typeof(InventoryGui), "Hide")]
		[HarmonyPostfix]
		private static void Closed()
		{
			KindleRecipes.Guard(KindleRecipes.Closed);
		}
	}
	[HarmonyPatch(typeof(PlayerController), "TakeInput")]
	internal static class TypingStill
	{
		[HarmonyPostfix]
		private static void Postfix(ref bool __result)
		{
			if (__result && KitTextField.AnyFocused)
			{
				__result = false;
			}
		}
	}
	public static class KindleRepair
	{
		private static readonly List<ItemData> worn = new List<ItemData>();

		private static Harmony patches;

		private static float nextCount;

		private static int repairable;

		private static GameObject tipOwner;

		private static int tipShown;

		private static string tipLanguage;

		private static long tipRevision = -1L;

		private static bool Active
		{
			get
			{
				if (Plugin.GameplayAvailable && Plugin.AllowsUi)
				{
					return Object.op_Implicit((Object)(object)Player.m_localPlayer);
				}
				return false;
			}
		}

		public static void Initialize()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			Shutdown();
			patches = new Harmony("com.meadworks.kindle.repair");
			patches.CreateClassProcessor(typeof(KindleRepairPatches)).Patch();
		}

		public static void Shutdown()
		{
			Harmony obj = patches;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			patches = null;
			nextCount = 0f;
			tipOwner = null;
		}

		internal static void Guard(Action action)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				KindleSalvage.Warn("Repair all: " + ex.GetType().Name + ": " + ex.Message);
			}
		}

		public static List<ItemData> Repairable(Player player)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			List<ItemData> list = new List<ItemData>();
			if (!Object.op_Implicit((Object)(object)player))
			{
				return list;
			}
			CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
			bool flag = player.NoCostCheat();
			if (!Object.op_Implicit((Object)(object)currentCraftingStation) && !flag)
			{
				return list;
			}
			if (Object.op_Implicit((Object)(object)currentCraftingStation) && !currentCraftingStation.CheckUsable(player, false))
			{
				return list;
			}
			worn.Clear();
			((Humanoid)player).GetInventory().GetWornItems(worn);
			foreach (ItemData item in worn)
			{
				RepairFacts val = Facts(item, currentCraftingStation, flag);
				if (RepairRule.Qualifies(ref val))
				{
					list.Add(item);
				}
			}
			return list;
		}

		public static RepairFacts Facts(ItemData item, CraftingStation station, bool noCost)
		{
			//IL_001d: 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)
			Recipe val = (Object.op_Implicit((Object)(object)ObjectDB.instance) ? ObjectDB.instance.GetRecipe(item) : null);
			return new RepairFacts
			{
				CanBeRepaired = item.m_shared.m_canBeReparied,
				NoCost = noCost,
				Station = (Object.op_Implicit((Object)(object)station) ? station.m_name : null),
				StationLevel = (Object.op_Implicit((Object)(object)station) ? station.GetLevel(true) : 0),
				HasRecipe = Object.op_Implicit((Object)(object)val),
				CraftingStation = ((Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.m_craftingStation)) ? val.m_craftingStation.m_name : null),
				RepairStation = ((Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.m_repairStation)) ? val.m_repairStation.m_name : null),
				MinStationLevel = (Object.op_Implicit((Object)(object)val) ? val.m_minStationLevel : 0),
				ItemWorldLevel = item.m_worldLevel,
				GameWorldLevel = Game.m_worldLevel
			};
		}

		internal static bool Pressed(InventoryGui gui)
		{
			//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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if (!Active)
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			CraftingStation currentCraftingStation = localPlayer.GetCurrentCraftingStation();
			List<ItemData> list = Repairable(localPlayer);
			foreach (ItemData item in list)
			{
				((Character)localPlayer).RaiseSkill((SkillType)107, 1f - item.m_durability / item.GetMaxDurability());
				item.m_durability = item.GetMaxDurability();
			}
			if (list.Count > 0 && Object.op_Implicit((Object)(object)currentCraftingStation))
			{
				currentCraftingStation.m_repairItemDoneEffects.Create(((Component)currentCraftingStation).transform.position, Quaternion.identity, (Transform)null, 1f, -1, default(ZDOID));
			}
			((Character)localPlayer).Message((MessageType)2, (list.Count == 0) ? KindleText.Text("repair_all_none") : ((list.Count == 1) ? KindleText.Text("repair_all_done_one") : KindleText.Format("repair_all_done", list.Count)), 0, (Sprite)null, false);
			if (gui.m_uiGroups != null && gui.m_uiGroups.Length > 3)
			{
				gui.SetActiveGroup(gui.m_uiGroups[3], true);
			}
			nextCount = 0f;
			gui.UpdateRepair();
			gui.UpdateCraftingPanel(false);
			return false;
		}

		internal static void StationOpened(CraftingStation station, Humanoid user, bool repeat, bool opened, bool ranOriginal)
		{
			if (!opened || !ranOriginal || repeat || !Active || !Object.op_Implicit((Object)(object)station) || !station.m_canRepair)
			{
				return;
			}
			KindleConfig? settings = Plugin.Settings;
			if (settings == null || !settings.Get<bool>(Repair.OnStationOpen) || (Object)(object)user != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			Player val = (Player)(object)((user is Player) ? user : null);
			if (val != null && !((Character)val).IsDead() && !((Character)val).InCutscene() && !((Character)val).IsTeleporting())
			{
				ZNetView component = ((Component)val).GetComponent<ZNetView>();
				if (Object.op_Implicit((Object)(object)component) && component.IsValid() && component.IsOwner() && !((Object)(object)val.GetCurrentCraftingStation() != (Object)(object)station) && station.InUseDistance((Humanoid)(object)val) && station.CheckUsable(val, false) && Object.op_Implicit((Object)(object)InventoryGui.instance) && InventoryGui.IsVisible() && Repairable(val).Count != 0)
				{
					Pressed(InventoryGui.instance);
				}
			}
		}

		internal static bool BeforeRepair(InventoryGui gui)
		{
			if (!Active || !Object.op_Implicit((Object)(object)gui.m_repairButton))
			{
				return true;
			}
			Player localPlayer = Player.m_localPlayer;
			CraftingStation currentCraftingStation = localPlayer.GetCurrentCraftingStation();
			if ((Object.op_Implicit((Object)(object)currentCraftingStation) ? currentCraftingStation.m_canRepair : localPlayer.NoCostCheat()) || !Object.op_Implicit((Object)(object)gui.m_crafting) || !((Component)gui.m_crafting).gameObject.activeInHierarchy)
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)gui.m_repairPanel))
			{
				((Component)gui.m_repairPanel).gameObject.SetActive(false);
			}
			if (Object.op_Implicit((Object)(object)gui.m_repairPanelSelection))
			{
				((Component)gui.m_repairPanelSelection).gameObject.SetActive(false);
			}
			return false;
		}

		internal static void AfterRepair(InventoryGui gui)
		{
			if (!Active || !Object.op_Implicit((Object)(object)gui.m_repairButton))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if (Time.unscaledTime >= nextCount)
			{
				nextCount = Time.unscaledTime + 0.25f;
				repairable = Repairable(localPlayer).Count;
			}
			Button repairButton = gui.m_repairButton;
			CraftingStation currentCraftingStation = localPlayer.GetCurrentCraftingStation();
			bool flag = localPlayer.NoCostCheat();
			bool flag2 = (Object.op_Implicit((Object)(object)currentCraftingStation) ? currentCraftingStation.m_canRepair : flag);
			bool flag3 = Object.op_Implicit((Object)(object)gui.m_crafting) && ((Component)gui.m_crafting).gameObject.activeInHierarchy;
			if (!flag2 && flag3 && !((Component)repairButton).gameObject.activeSelf)
			{
				((Component)repairButton).gameObject.SetActive(true);
			}
			if (((Component)repairButton).gameObject.activeSelf)
			{
				bool active = (((Selectable)repairButton).interactable = flag2 && repairable > 0);
				if (Object.op_Implicit((Object)(object)gui.m_repairButtonGlow))
				{
					((Component)gui.m_repairButtonGlow).gameObject.SetActive(active);
				}
				int num = (flag2 ? repairable : (-1));
				string text = ((Localization.instance != null) ? Localization.instance.GetSelectedLanguage() : "English");
				long revision = KindleText.Revision;
				if ((Object)(object)tipOwner != (Object)(object)((Component)repairButton).gameObject || num != tipShown || text != tipLanguage || revision != tipRevision)
				{
					string text2 = ((!flag2) ? KindleText.Text("station_needed") : ((repairable == 0) ? KindleText.Text("repair_all_tip_none") : ((repairable == 1) ? KindleText.Text("repair_all_tip_one") : KindleText.Format("repair_all_tip", repairable))));
					KitTooltip.Set(((Component)repairButton).gameObject, KindleText.Text("repair_all"), text2);
					tipOwner = ((Component)repairButton).gameObject;
					tipShown = num;
					tipLanguage = text;
					tipRevision = revision;
				}
			}
			Back(gui);
		}

		private static void Back(InventoryGui gui)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: 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)
			Transform repairPanel = gui.m_repairPanel;
			RectTransform val = (RectTransform)(object)((repairPanel is RectTransform) ? repairPanel : null);
			RectTransform val2 = (RectTransform)((Component)gui.m_repairButton).transform;
			if (!Object.op_Implicit((Object)(object)val) || !((Component)val).gameObject.activeInHierarchy || !((Component)val2).gameObject.activeInHierarchy)
			{
				return;
			}
			Transform parent = ((Transform)val).parent;
			RectTransform val3 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if (val3 == null)
			{
				return;
			}
			Rect rect = val2.rect;
			if (((Rect)(ref rect)).width < 1f)
			{
				return;
			}
			rect = val2.rect;
			if (!(((Rect)(ref rect)).height < 1f))
			{
				rect = val2.rect;
				float width = ((Rect)(ref rect)).width;
				rect = val2.rect;
				ValueTuple<float, float> valueTuple = StationStack.Backing(width, ((Rect)(ref rect)).height);
				float item = valueTuple.Item1;
				float item2 = valueTuple.Item2;
				rect = val.rect;
				if (Mathf.Abs(((Rect)(ref rect)).width - item) > 0.01f)
				{
					val.SetSizeWithCurrentAnchors((Axis)0, item);
				}
				rect = val.rect;
				if (Mathf.Abs(((Rect)(ref rect)).height - item2) > 0.01f)
				{
					val.SetSizeWithCurrentAnchors((Axis)1, item2);
				}
				rect = val2.rect;
				Vector3 val4 = ((Transform)val3).InverseTransformPoint(((Transform)val2).TransformPoint(Vector2.op_Implicit(((Rect)(ref rect)).center)));
				rect = val.rect;
				Vector2 val5 = Vector2.op_Implicit(val4 - ((Transform)val3).InverseTransformPoint(((Transform)val).TransformPoint(Vector2.op_Implicit(((Rect)(ref rect)).center))));
				if (((Vector2)(ref val5)).sqrMagnitude > 0.0001f)
				{
					val.anchoredPosition += val5;
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class KindleRepairPatches
	{
		[HarmonyPatch(typeof(CraftingStation), "Interact")]
		[HarmonyPrefix]
		private static void Opening(CraftingStation __instance, Humanoid user, bool repeat, out bool __state)
		{
			__state = !repeat && Object.op_Implicit((Object)(object)user) && (Object)(object)user == (Object)(object)Player.m_localPlayer && ((Object)(object)Player.m_localPlayer.GetCurrentCraftingStation() != (Object)(object)__instance || !InventoryGui.IsVisible());
		}

		[HarmonyPatch(typeof(CraftingStation), "Interact")]
		[HarmonyPostfix]
		private static void Opened(CraftingStation __instance, Humanoid user, bool repeat, bool __state, bool __runOriginal)
		{
			KindleRepair.Guard(delegate
			{
				KindleRepair.StationOpened(__instance, user, repeat, __state, __runOriginal);
			});
		}

		[HarmonyPatch(typeof(InventoryGui), "OnRepairPressed")]
		[HarmonyPrefix]
		private static bool Pressed(InventoryGui __instance)
		{
			bool run = true;
			KindleRepair.Guard(delegate
			{
				run = KindleRepair.Pressed(__instance);
			});
			return run;
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRepair")]
		[HarmonyPrefix]
		private static bool Repairing(InventoryGui __instance)
		{
			try
			{
				return KindleRepair.BeforeRepair(__instance);
			}
			catch (Exception ex)
			{
				KindleSalvage.Warn("Repair all: " + ex.GetType().Name + ": " + ex.Message);
				return true;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRepair")]
		[HarmonyPostfix]
		private static void Updated(InventoryGui __instance)
		{
			try
			{
				KindleRepair.AfterRepair(__instance);
			}
			catch (Exception ex)
			{
				KindleSalvage.Warn("Repair all: " + ex.GetType().Name + ": " + ex.Message);
			}
		}
	}
	public static class KindleSalvage
	{
		private readonly struct DrawKey : IEquatable<DrawKey>
		{
			private readonly ItemData item;

			private readonly CraftingStation station;

			private readonly int stack;

			private readonly int quality;

			private readonly int changes;

			private readonly int second;

			private readonly int generation;

			public DrawKey(ItemData item, CraftingStation station, int stack, int quality, int changes, int second, int generation)
			{
				this.item = item;
				this.station = station;
				this.stack = stack;
				this.quality = quality;
				this.changes = changes;
				this.second = second;
				this.generation = generation;
			}

			public bool Equals(DrawKey other)
			{
				if (item == other.item && station == other.station && stack == other.stack && quality == other.quality && changes == other.changes && second == other.second)
				{
					return generation == other.generation;
				}
				return false;
			}

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

			public override int GetHashCode()
			{
				return HashCode.Combine(stack, quality, changes, second, generation);
			}
		}

		private static bool initialized;

		private static bool wasActive;

		private static InventoryGui gui;

		private static KitGameTab tab;

		private static KitTileList layout;

		private static readonly List<KeyValuePair<ItemData, GameObject>> rows = new List<KeyValuePair<ItemData, GameObject>>();

		private static ItemData selected;

		private static int selectedIndex;

		private static Action<string> warning;

		private static Harmony patches;

		private static bool configurationDirty;

		private static DrawKey drawn;

		private static readonly Color BlockedName = new Color(0.6f, 0.6f, 0.6f, 1f);

		private static int drawGeneration = 1;

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

		private static readonly Dictionary<ItemData, Container> chestOf = new Dictionary<ItemData, Container>();

		private const string ChestColour = "#6fc3ff";

		private static int favouriteStamp;

		private static float nextFavouriteCheck;

		private static int chestStamp;

		private static float nextChestCheck;

		public static bool Ready
		{
			get
			{
				if (initialized && Plugin.GameplayAvailable && Plugin.AllowsUi && SalvageYaml.Ready && Plugin.IsReady && Plugin.Session.WorldId != 0L && (Object)(object)ZNet.instance != (Object)null && (Object)(object)Player.m_localPlayer != (Object)null && !((Character)Player.m_localPlayer).IsDead())
				{
					return !((Character)Player.m_localPlayer).IsTeleporting();
				}
				return false;
			}
		}

		public static bool Active
		{
			get
			{
				if (Ready && SalvageSettings.Enabled.Value && tab != null)
				{
					return tab.Selected;
				}
				return false;
			}
		}

		public static ItemData Selected => selected;

		public static IReadOnlyDictionary<string, string> Files => SalvageYaml.Files;

		public static void Initialize(ConfigFile config, ProductRegistration registration, Action<string> warn = null)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			Shutdown();
			warning = warn;
			initialized = true;
			SalvageYaml.Initialize(config, registration);
			if (Plugin.Settings != null)
			{
				Plugin.Settings.Changed += Changed;
			}
			if (Plugin.AllowsUi && !Plugin.SteppedAside)
			{
				patches = new Harmony("com.meadworks.kindle.salvage");
				patches.CreateClassProcessor(typeof(SalvageGuiPatches)).Patch();
			}
		}

		internal static void Warn(string text)
		{
			if (warned.Add(text))
			{
				if (warning != null)
				{
					warning(text);
				}
				else
				{
					Debug.LogWarning((object)("Kindle: " + text));
				}
			}
		}

		internal static void Guard(Action action)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				Warn("Salvage UI: " + ex.GetType().Name);
			}
		}

		internal static bool Guard(Func<bool> action)
		{
			try
			{
				return action();
			}
			catch (Exception ex)
			{
				Warn("Salvage UI: " + ex.GetType().Name);
				Deselect();
				return true;
			}
		}

		private static void Changed(object sender, EventArgs args)
		{
			configurationDirty = true;
			drawGeneration++;
		}

		public static void Reload()
		{
			SalvageYaml.Reload();
		}

		private static bool FavouritesChanged()
		{
			float unscaledTime = Time.unscaledTime;
			if (wasActive && unscaledTime < nextFavouriteCheck)
			{
				return false;
			}
			nextFavouriteCheck = unscaledTime + 0.25f;
			int num = SalvageInterop.FavouritesStamp();
			bool result = wasActive && num != favouriteStamp;
			favouriteStamp = num;
			return result;
		}

		private static bool ChestsChanged()
		{
			float unscaledTime = Time.unscaledTime;
			if (wasActive && unscaledTime < nextChestCheck)
			{
				return false;
			}
			nextChestCheck = unscaledTime + 0.5f;
			int num = SalvageChests.Stamp();
			bool result = wasActive && num != chestStamp;
			chestStamp = num;
			return result;
		}

		public static void Tick()
		{
			if (!initialized)
			{
				return;
			}
			SalvageChests.Tick();
			SalvageYaml.Tick();
			if (!Plugin.AllowsUi || Plugin.SteppedAside)
			{
				return;
			}
			Ensure(InventoryGui.instance);
			if (tab == null || !Object.op_Implicit((Object)(object)tab.Button))
			{
				SalvageTabCapability.Active = false;
				return;
			}
			tab.Refresh();
			bool flag = Ready && SalvageSettings.Enabled.Value;
			((Component)tab.Button).gameObject.SetActive(flag);
			TMP_Text componentInChildren = ((Component)tab.Button).GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = SalvageWords.Salvage;
			}
			if (!flag && tab.Selected)
			{
				Leave();
			}
			SalvageTabCapability.Active = Active && InventoryGui.IsVisible();
			bool flag2 = SalvageTabCapability.Active && FavouritesChanged();
			bool flag3 = SalvageTabCapability.Active && ChestsChanged();
			if (SalvageTabCapability.Active && (!wasActive || configurationDirty || flag2 || flag3))
			{
				configurationDirty = false;
				drawGeneration++;
				Rebuild();
			}
			wasActive = SalvageTabCapability.Active;
		}

		public static void Ensure(InventoryGui instance)
		{
			if (initialized && Plugin.AllowsUi && !Plugin.SteppedAside && !((Object)(object)instance == (Object)null) && !((Object)(object)instance.m_tabUpgrade == (Object)null) && (!((Object)(object)gui == (Object)(object)instance) || tab == null || !((Object)(object)tab.Button != (Object)null)))
			{
				Clear();
				KitTileList obj = layout;
				if (obj != null)
				{
					obj.Forget();
				}
				KitGameTab obj2 = tab;
				if (obj2 != null)
				{
					obj2.Dispose();
				}
				gui = instance;
				selected = null;
				selectedIndex = 0;
				wasActive = false;
				Transform parent = ((Component)instance.m_tabUpgrade).transform.parent;
				tab = KitTabs.Append((RectTransform)(object)((parent is RectTransform) ? parent : null), instance.m_tabUpgrade, "Kindle_SalvageTab", SalvageWords.Salvage, (Action)delegate
				{
					Select(instance);
				});
				layout = KitTileList.For(instance.m_recipeListRoot, instance.m_recipeListSpace, instance.m_recipeListBaseSize, (KitTileParts)null);
			}
		}

		private static void Select(InventoryGui instance)
		{
			if (!Ready || !SalvageSettings.Enabled.Value || (Object)(object)instance != (Object)(object)gui || instance.m_craftTimer >= 0f)
			{
				KitGameTab obj = tab;
				if (obj != null)
				{
					obj.Select(false);
				}
				return;
			}
			instance.OnTabCraftPressed();
			tab.Select(true);
			SalvageTabCapability.Active = true;
			if (instance.m_uiGroups != null && instance.m_uiGroups.Length > 3)
			{
				instance.SetActiveGroup(instance.m_uiGroups[3], true);
			}
			((Selectable)instance.m_tabCraft).interactable = true;
			((Selectable)instance.m_tabUpgrade).interactable = true;
			instance.UpdateCraftingPanel(false);
		}

		public static bool AnySalvageable(Player player)
		{
			if (Ready && SalvageSettings.Enabled.Value && (Object)(object)player != (Object)null)
			{
				return ((Humanoid)player).GetInventory().GetAllItems().Any((ItemData item) => SalvageInterop.ListedCell(player, item) && SalvageActions.CanSalvage(item));
			}
			return false;
		}

		public static void Open(InventoryGui instance, ItemData item)
		{
			Ensure(instance);
			if (tab != null && !((Object)(object)instance != (Object)(object)gui))
			{
				if (item != null)
				{
					selected = item;
				}
				Select(instance);
			}
		}

		public static void Deselect()
		{
			KitGameTab obj = tab;
			if (obj != null)
			{
				obj.Select(false);
			}
			SalvageTabCapability.Active = false;
			wasActive = false;
			Clear();
			drawGeneration++;
		}

		private static void Leave()
		{
			Deselect();
			if ((Object)(object)gui != (Object)null && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				gui.OnTabCraftPressed();
			}
		}

		public static bool BeforeCraftingPanel(InventoryGui instance, bool focusView)
		{
			Ensure(instance);
			if (!Active)
			{
				SalvageTabCapability.Active = false;
				return true;
			}
			SalvageTabCapability.Active = true;
			Player localPlayer = Player.m_localPlayer;
			CraftingStation currentCraftingStation = localPlayer.GetCurrentCraftingStation();
			bool flag = localPlayer.NoCostCheat() || ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey((GlobalKeys)25));
			((Component)instance.m_tabCraft).gameObject.SetActive((Object)(object)currentCraftingStation == (Object)null || currentCraftingStation.m_hasCraftTab);
			((Component)instance.m_tabUpgrade).gameObject.SetActive((Object)(object)currentCraftingStation != (Object)null || flag);
			((Selectable)instance.m_tabCraft).interactable = true;
			((Selectable)instance.m_tabUpgrade).interactable = true;
			Rebuild(focusView);
			return false;
		}

		public static void Rebuild()
		{
			if (Active && (Object)(object)gui != (Object)null)
			{
				Rebuild(center: false);
			}
		}

		private static void Rebuild(bool center)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			foreach (RecipeDataPair availableRecipe in gui.m_availableRecipes)
			{
				RecipeDataPair current = availableRecipe;
				if ((Object)(object)((RecipeDataPair)(ref current)).InterfaceElement != (Object)null)
				{
					Object.Destroy((Object)(object)((RecipeDataPair)(ref current)).InterfaceElement);
				}
			}
			gui.m_availableRecipes.Clear();
			gui.m_selectedRecipe = default(RecipeDataPair);
			Clear();
			foreach (ItemData item in ((Humanoid)Player.m_localPlayer).GetInventory().GetAllItemsInGridOrder())
			{
				if (SalvageInterop.ListedCell(Player.m_localPlayer, item))
				{
					AddRow(item, SalvageActions.WhyNot(item), null);
				}
			}
			foreach (KeyValuePair<Container, ItemData> item2 in SalvageChests.Items())
			{
				if (!chestOf.ContainsKey(item2.Value))
				{
					AddRow(item2.Value, SalvageRules.Blocker(Player.m_localPlayer, item2.Value, item2.Key.GetInventory()), item2.Key);
				}
			}
			if (layout != null)
			{
				layout.View = (KitTileView)0;
				layout.Arrange((IList<RectTransform>)rows.Select<KeyValuePair<ItemData, GameObject>, RectTransform>(delegate(KeyValuePair<ItemData, GameObject> r)
				{
					Transform transform = r.Value.transform;
					return (RectTransform)(object)((transform is RectTransform) ? transform : null);
				}).ToList());
			}
			int num = rows.FindIndex((KeyValuePair<ItemData, GameObject> r) => r.Key == selected);
			Choose((num >= 0) ? num : Mathf.Clamp(selectedIndex, 0, rows.Count - 1), center);
		}

		private static void AddRow(ItemData item, string blocked, Container chest)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			if (item?.m_shared == null || (blocked != null && (blocked == SalvageWords.Off || blocked == SalvageWords.Cannot || blocked == SalvageWords.NoRecipe)))
			{
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(gui.m_recipeElementPrefab, (Transform)(object)gui.m_recipeListRoot);
			((Object)val).name = "Kindle_SalvageRow";
			val.SetActive(true);
			Transform obj = val.transform.Find("icon");
			Image val2 = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.sprite = item.GetIcon();
				((Graphic)val2).color = Color.white;
				SalvageRarity.Apply(((Component)val2).gameObject, item);
			}
			Transform obj2 = val.transform.Find("name");
			TMP_Text val3 = ((obj2 != null) ? ((Component)obj2).GetComponent<TMP_Text>() : null);
			if ((Object)(object)val3 != (Object)null)
			{
				val3.text = ItemNames.DisplayName(item) + ((item.m_stack > 1) ? (" ×" + item.m_stack) : "") + ChestLabel(chest);
				((Graphic)val3).color = ((blocked == null) ? Color.white : BlockedName);
			}
			Transform obj3 = val.transform.Find("QualityLevel");
			TMP_Text val4 = ((obj3 != null) ? ((Component)obj3).GetComponent<TMP_Text>() : null);
			if ((Object)(object)val4 != (Object)null)
			{
				((Component)val4).gameObject.SetActive(item?.m_shared != null && item.m_shared.m_maxQuality > 1);
				val4.text = item.m_quality.ToString();
			}
			Transform obj4 = val.transform.Find("Durability");
			GuiBar val5 = ((obj4 != null) ? ((Component)obj4).GetComponent<GuiBar>() : null);
			if ((Object)(object)val5 != (Object)null)
			{
				bool flag = item?.m_shared != null && item.m_shared.m_useDurability && item.m_durability < item.GetMaxDurability();
				((Component)val5).gameObject.SetActive(flag);
				if (flag)
				{
					val5.SetValue(item.GetDurabilityPercentage());
				}
			}
			Button component = val.GetComponent<Button>();
			int index = rows.Count;
			if ((Object)(object)component != (Object)null)
			{
				component.onClick = new ButtonClickedEvent();
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					Choose(index, center: false);
				});
			}
			string text = ItemData.GetTooltip(item, item.m_quality, false, (float)Game.m_worldLevel, -1, false);
			if ((Object)(object)chest != (Object)null)
			{
				text = "<color=#6fc3ff>" + SalvageWords.FromChest + "</color>\n\n" + text;
			}
			KitTooltip.Set(val, ItemNames.DisplayName(item), (blocked == null) ? text : ("<color=#FF6A5A>" + blocked + "</color>\n\n" + text));
			rows.Add(new KeyValuePair<ItemData, GameObject>(item, val));
			if ((Object)(object)chest != (Object)null)
			{
				chestOf[item] = chest;
			}
		}

		private static string ChestLabel(Container chest)
		{
			if (!((Object)(object)chest == (Object)null))
			{
				return "  <size=80%><color=#6fc3ff>" + SalvageWords.FromChest + "</color></size>";
			}
			return "";
		}

		private static void Clear()
		{
			foreach (KeyValuePair<ItemData, GameObject> row in rows)
			{
				if ((Object)(object)row.Value != (Object)null)
				{
					row.Value.SetActive(false);
					Object.Destroy((Object)(object)row.Value);
				}
			}
			rows.Clear();
			chestOf.Clear();
		}

		private static void Choose(int index, bool center)
		{
			selected = null;
			drawGeneration++;
			for (int i = 0; i < rows.Count; i++)
			{
				Transform val = rows[i].Value.transform.Find("selected");
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(i == index);
				}
				if (i == index)
				{
					selected = rows[i].Key;
					selectedIndex = i;
				}
			}
			if (center && selected != null && (Object)(object)gui.m_recipeEnsureVisible != (Object)null)
			{
				? val2 = gui.m_recipeEnsureVisible;
				Transform transform = rows[index].Value.transform;
				((ScrollRectEnsureVisible)val2).CenterOnItem((RectTransform)(object)((transform is RectTransform) ? transform : null));
			}
			if (gui.m_uiGroups != null && gui.m_uiGroups.Length > 3)
			{
				gui.SetActiveGroup(gui.m_uiGroups[3], true);
			}
			if ((Object)(object)GamepadRumble.instance != (Object)null)
			{
				GamepadRumble.instance.PlayGlobalSelectVibration();
			}
		}

		public static bool Gamepad(InventoryGui instance)
		{
			if (!Active)
			{
				return true;
			}
			int num = ((ZInput.GetButtonDown("JoyLStickDown") || ZInput.GetButtonDown("JoyDPadDown")) ? 1 : ((ZInput.GetButtonDown("JoyLStickUp") || ZInput.GetButtonDown("JoyDPadUp")) ? (-1) : 0));
			if (num != 0 && rows.Count > 0)
			{
				Choose(Mathf.Clamp(selectedIndex + num, 0, rows.Count - 1), center: true);
			}
			return false;
		}

		public static bool Craft(InventoryGui instance)
		{
			if (!Active)
			{
				return true;
			}
			if (instance.m_craftTimer >= 0f || selected == null)
			{
				return false;
			}
			Player actor = Player.m_localPlayer;
			Action afterwards = delegate
			{
				//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_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)instance != (Object)null && (Object)(object)actor == (Object)(object)Player.m_localPlayer && Ready)
				{
					instance.m_craftItemEffects.Create(((Component)actor).transform.position, Quaternion.identity, (Transform)null, 1f, -1, default(ZDOID));
					instance.UpdateCraftingPanel(false);
				}
			};
			if (chestOf.TryGetValue(selected, out Container value))
			{
				SalvageChests.Confirm(actor, value, selected, afterwards);
			}
			else
			{
				SalvageActions.Confirm(actor, selected, afterwards);
			}
			return false;
		}

		public static void Hotkey(InventoryGui instance)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			if (!Ready || !SalvageSettings.Enabled.Value || !InventoryGui.IsVisible() || UnifiedPopup.IsVisible() || instance.m_dragItem != null || !MeadworksInput.Allows((InputContext)1) || !HotkeyRules.Pressed(MeadworksInput.Chord(Plugin.Settings.Shortcut(Salvage.SalvageKey)), MeadworksInput.Typing, (Func<string, bool>)((string key) => Enum.TryParse<KeyCode>(key, out KeyCode result) && Input.GetKeyDown(result)), (Func<string, bool>)delegate(string key)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (Enum.TryParse<KeyCode>(key, out result))
				{
					if (!HotkeyRules.ReadsThroughGame(key))
					{
						return Input.GetKey(result);
					}
					if (ZInput.GetKey(result, false))
					{
						return Input.GetKey(result);
					}
					return false;
				}
				return false;
			}))
			{
				return;
			}
			InventoryGrid playerGrid = instance.m_playerGrid;
			Vector3 pointerPosition = ZInput.pointerPosition;
			ItemData val = (((Object)(object)playerGrid != (Object)null) ? playerGrid.GetItem(new Vector2i((int)pointerPosition.x, (int)pointerPosition.y)) : null);
			if (val == null && (Object)(object)playerGrid != (Object)null && ZInput.IsGamepadActive())
			{
				val = playerGrid.GetGamepadSelectedItem();
			}
			if (val == null)
			{
				return;
			}
			SalvageActions.Confirm(Player.m_localPlayer, val, delegate
			{
				if ((Object)(object)instance != (Object)null && Ready)
				{
					instance.UpdateCraftingPanel(false);
				}
			});
		}

		public static bool BeforeRecipe(InventoryGui instance)
		{
			if (!Active || (Object)(object)instance != (Object)(object)gui || instance.m_craftTimer >= 0f)
			{
				return true;
			}
			if ((Object)(object)instance.m_craftProgressPanel != (Object)null && ((Component)instance.m_craftProgressPanel).gameObject.activeSelf)
			{
				((Component)instance.m_craftProgressPanel).gameObject.SetActive(false);
			}
			if (!((Component)instance.m_craftButton).gameObject.activeSelf)
			{
				((Component)instance.m_craftButton).gameObject.SetActive(true);
			}
			return false;
		}

		public static void Fill(InventoryGui instance, Player player)
		{
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			if (!Active || (Object)(object)player == (Object)null || (Object)(object)instance == (Object)null || instance.m_craftTimer >= 0f)
			{
				return;
			}
			ItemData val = selected;
			Container value = null;
			bool flag = val != null && chestOf.TryGetValue(val, out value);
			bool flag2 = val != null && ((!flag) ? ((Humanoid)player).GetInventory().ContainsItem(val) : (Object.op_Implicit((Object)(object)value) && value.GetInventory().ContainsItem(val)));
			DrawKey drawKey = new DrawKey(flag2 ? val : null, player.GetCurrentCraftingStation(), flag2 ? val.m_stack : 0, flag2 ? val.m_quality : 0, KindleBatch.InventoryChanges, (int)Time.fixedTime, drawGeneration);
			if (drawKey.Equals(drawn))
			{
				if (flag2)
				{
					SalvageRarity.Apply(((Component)instance.m_recipeIcon).gameObject, val);
				}
				return;
			}
			drawn = drawKey;
			Header(instance, player);
			TMP_Text componentInChildren = ((Component)instance.m_craftButton).GetComponentInChildren<TMP_Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = SalvageWords.Salvage;
			}
			if (!flag2)
			{
				((Behaviour)instance.m_recipeIcon).enabled = false;
				((Behaviour)instance.m_recipeName).enabled = false;
				GameObject[] recipeRequirementList = instance.m_recipeRequirementList;
				for (int i = 0; i < recipeRequirementList.Length; i++)
				{
					InventoryGui.HideRequirement(recipeRequirementList[i].transform);
				}
				((Behaviour)instance.m_recipeDecription).enabled = true;
				instance.m_recipeDecription.text = SalvageWords.Empty;
				((Selectable)instance.m_craftButton).interactable = false;
				KitTooltip.Set(((Component)instance.m_craftButton).gameObject, SalvageWords.Salvage, "");
				return;
			}
			((Behaviour)instance.m_recipeIcon).enabled = true;
			instance.m_recipeIcon.sprite = val.GetIcon();
			SalvageRarity.Apply(((Component)instance.m_recipeIcon).gameObject, val);
			((Behaviour)instance.m_recipeName).enabled = true;
			instance.m_recipeName.text = ItemNames.DisplayName(val) + ((val.m_stack > 1) ? (" ×" + val.m_stack) : "") + ChestLabel(flag ? value : null);
			((Behaviour)instance.m_recipeDecription).enabled = true;
			instance.m_recipeDecription.text = KitLocalize.Text(ItemData.GetTooltip(val, val.m_quality, false, (float)Game.m_worldLevel, -1, false));
			List<SalvageReturn> list = SalvageActions.Returns(val);
			GameObject[] recipeRequirementList2 = instance.m_recipeRequirementList;
			int num = ((recipeRequirementList2.Length != 0 && list.Count > recipeRequirementList2.Length) ? ((int)Time.fixedTime % Mathf.CeilToInt((float)list.Count / (float)recipeRequirementList2.Length) * recipeRequirementList2.Length) : 0);
			int j = 0;
			int num2 = num;
			while (num2 < list.Count && j < recipeRequirementList2.Length)
			{
				Transform transform = recipeRequirementList2[j].transform;
				SalvageReturn salvageReturn = list[num2];
				Image component = ((Component)transform.Find("res_icon")).GetComponent<Image>();
				TMP_Text component2 = ((Component)transform.Find("res_name")).GetComponent<TMP_Text>();
				TMP_Text component3 = ((Component)transform.Find("res_amount")).GetComponent<TMP_Text>();
				((Component)component).gameObject.SetActive(true);
				((Component)component2).gameObject.SetActive(true);
				((Component)component3).gameObject.SetActive(true);
				component.sprite = salvageReturn.Item.m_itemData.GetIcon();
				((Graphic)component).color = Color.white;
				component2.text = KitLocalize.Text(salvageReturn.Name);
				component3.text = (salvageReturn.IsCertain ? salvageReturn.Amount.ToString() : SalvageActions.Percent(salvageReturn.Chance));
				((Graphic)component3).color = Color.white;
				KitTooltip.Set(((Component)transform).gameObject, component2.text, "");
				num2++;
				j++;
			}
			for (; j < recipeRequirementList2.Length; j++)
			{
				InventoryGui.HideRequirement(recipeRequirementList2[j].transform);
			}
			string text = SalvageRules.Blocker(player, val, flag ? value.GetInventory() : null);
			if (text == null && list.Count == 0)
			{
				text = SalvageWords.Nothing;
			}
			if (text == null && !flag && !SalvageInventory.Fits(((Humanoid)player).GetInventory(), val, list))
			{
				text = SalvageWords.NoFit;
			}
			if (text == null && flag && SalvageChests.Busy)
			{
				text = SalvageWords.ChestWait;
			}
			((Selectable)instance.m_craftButton).interactable = text == null;
			KitTooltip.Set(((Component)instance.m_craftButton).gameObject, SalvageWords.Salvage, text ?? "");
		}

		private static void Header(InventoryGui instance, Player player)
		{
			CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
			if ((Object)(object)currentCraftingStation != (Object)null)
			{
				instance.m_craftingStationName.text = Localization.instance.Localize(currentCraftingStation.m_name);
				((Component)instance.m_craftingStationIcon).gameObject.SetActive(true);
				instance.m_craftingStationIcon.sprite = currentCraftingStation.m_icon;
				instance.m_craftingStationLevel.text = currentCraftingStation.GetLevel(true).ToString();
				((Component)instance.m_craftingStationLevelRoot).gameObject.SetActive(true);
			}
			else
			{
				instance.m_craftingStationName.text = Localization.instance.Localize("$hud_crafting");
				((Component)instance.m_craftingStationIcon).gameObject.SetActive(false);
				((Component)instance.m_craftingStationLevelRoot).gameObject.SetActive(false);
			}
			if ((Object)(object)instance.m_qualityPanel != (Object)null)
			{
				((Component)instance.m_qualityPanel).gameObject.SetActive(false);
			}
			((Component)instance.m_minStationLevelIcon).gameObject.SetActive(false);
			((Component)instance.m_variantButton).gameObject.SetActive(false);
			((Component)instance.m_itemCraftType).gameObject.SetActive(false);
		}

		public static void Shutdown()
		{
			bool active = Active;
			initialized = false;
			Deselect();
			if (Plugin.Settings != null)
			{
				Plugin.Settings.Changed -= Changed;
			}
			configurationDirty = false;
			Harmony obj = patches;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			patches = null;
			KitTileList obj2 = layout;
			if (obj2 != null)
			{
				obj2.Forget();
			}
			layout = null;
			KitGameTab obj3 = tab;
			if (obj3 != null)
			{
				obj3.Dispose();
			}
			tab = null;
			SalvageYaml.Shutdown();
			SalvageRarity.Shutdown();
			SalvageChests.Shutdown();
			selected = null;
			warning = null;
			warned.Clear();
			if (active && (Object)(object)gui != (Object)null && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				gui.OnTabCraftPressed();
			}
			gui = null;
		}
	}
	public static class KindleTracker
	{
		public const string DataKey = "Kindle.trackedRecipes";

		private static readonly List<TrackedRecipe> entries = new List<TrackedRecipe>();

		private static Player? loadedFor;

		private static KindleConfig? settings;

		private static MeadworksLog? log;

		private static Harmony? patches;

		private static TrackerPanel? panel;

		private static float lastThreat = -100f;

		private static float nextCount;

		private static int version;

		private static int builtVersion = -1;

		private static string builtStyle = "";

		internal static KindleConfig Settings => settings;

		internal static IReadOnlyList<TrackedRecipe> Entries
		{
			get
			{
				Load();
				return entries;
			}
		}

		internal static bool Active
		{
			get
			{
				if (Plugin.Ready && Plugin.AllowsUi && settings != null && Object.op_Implicit((Object)(object)ZNet.instance) && Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return !((Character)Player.m_localPlayer).IsDead();
				}
				return false;
			}
		}

		public static bool NearbyAvailable => TrackerCounts.NearbyAvailable;

		public static void Initialize(KindleConfig config, MeadworksLog logger)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			Shutdown();
			settings = config;
			log = logger;
			if (Plugin.AllowsUi)
			{
				patches = new Harmony("com.meadworks.kindle.tracker");
				patches.CreateClassProcessor(typeof(TrackerCraftWatch)).Patch();
			}
		}

		public static void Shutdown()
		{
			Harmony? obj = patches;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			patches = null;
			panel?.Dispose();
			panel = null;
			TrackerCounts.Shutdown();
			TrackerStyle.Shutdown();
			entries.Clear();
			loadedFor = null;
			settings = null;
			log = null;
			builtVersion = -1;
			builtStyle = "";
			nextCount = 0f;
			lastThreat = -100f;
		}

		private static void Load()
		{
			Player localPlayer = Player.m_localPlayer;
			if (loadedFor == localPlayer)
			{
				return;
			}
			loadedFor = localPlayer;
			entries.Clear();
			version++;
			lastThreat = -100f;
			TrackerCounts.Shutdown();
			if (!Object.op_Implicit((Object)(object)localPlayer) || !localPlayer.m_customData.TryGetValue("Kindle.trackedRecipes", out var value))
			{
				return;
			}
			foreach (string item in (from part in value.Split(',')
				select part.Trim()).Distinct<string>(StringComparer.Ordinal))
			{
				TrackedRecipe tracked = TrackedRecipe.Parse(item);
				if (tracked != null && !entries.Any((TrackedRecipe item) => item.Is(tracked.Key, tracked.Quality, tracked.Upgrader)))
				{
					entries.Add(tracked);
				}
			}
		}

		private static void Save()
		{
			if (!Active || loadedFor != Player.m_localPlayer)
			{
				return;
			}
			if (entries.Count == 0)
			{
				loadedFor.m_customData.Remove("Kindle.trackedRecipes");
			}
			else
			{
				loadedFor.m_customData["Kindle.trackedRecipes"] = string.Join(",", entries.Select((TrackedRecipe item) => item.ToString()));
			}
			version++;
		}

		private static int IndexOf(Recipe recipe, int quality, bool upgrader)
		{
			if (!Object.op_Implicit((Object)(object)recipe))
			{
				return -1;
			}
			Load();
			string key = KindleRecipes.Key(recipe);
			return entries.FindIndex((TrackedRecipe entry) => entry.Is(key, quality, upgrader));
		}

		public static bool IsTracked(Recipe recipe, int quality, bool upgrader)
		{
			return IndexOf(recipe, quality, upgrader) >= 0;
		}

		public static void Toggle(Recipe recipe, int quality, int amount, bool upgrader)
		{
			if (!Active || !settings.Get<bool>(Tracker.Enabled) || !Object.op_Implicit((Object)(object)recipe) || !Object.op_Implicit((Object)(object)recipe.m_item))
			{
				return;
			}
			int num = IndexOf(recipe, quality, upgrader);
			if (num >= 0)
			{
				Remove(num);
				return;
			}
			if (entries.Count >= settings.Get<int>(Tracker.MaxTracked))
			{
				Message(KindleText.Format("tracker_full", settings.Get<int>(Tracker.MaxTracked)));
				return;
			}
			string text = KindleRecipes.Key(recipe);
			if (text.Length != 0)
			{
				entries.Add(new TrackedRecipe(text, quality, amount, upgrader));
				Save();
				Message(KindleText.Format("tracker_tracking", DisplayName(recipe, quality)));
			}
		}

		internal static void Remove(int index)
		{
			Load();
			if (Active && index >= 0 && index < entries.Count)
			{
				TrackedRecipe trackedRecipe = entries[index];
				entries.RemoveAt(index);
				Save();
				if (Object.op_Implicit((Object)(object)trackedRecipe.Recipe))
				{
					Message(KindleText.Format("tracker_untracked", DisplayName(trackedRecipe.Recipe, trackedRecipe.Quality)));
				}
			}
		}

		internal static void Step(int index, int direction, bool tens)
		{
			Load();
			if (Active && index >= 0 && index < entries.Count)
			{
				int amount = entries[index].Amount;
				int num = ((!tens) ? (amount + direction) : ((direction > 0) ? ((amount / 10 + 1) * 10) : ((amount - 1) / 10 * 10)));
				entries[index].Amount = Mathf.Clamp(num, 1, 9999);
				Save();
			}
		}

		public static void Crafted(Recipe recipe, int quality, int crafts, bool upgrader)
		{
			if (!Active || !settings.Get<bool>(Tracker.UntrackWhenCrafted))
			{
				return;
			}
			int num = IndexOf(recipe, quality, upgrader);
			if (num >= 0)
			{
				entries[num].Amount -= Mathf.Max(1, crafts);
				if (entries[num].Amount <= 0)
				{
					entries.RemoveAt(num);
					Message(KindleText.Format("tracker_made", DisplayName(recipe, quality)), top: true);
				}
				Save();
			}
		}

		internal static string DisplayName(Recipe recipe, int quality)
		{
			if ((Object)(object)recipe == (Object)null)
			{
				return string.Empty;
			}
			object obj = recipe.m_item?.m_itemData?.m_shared?.m_name;
			if (obj == null)
			{
				ItemDrop item = recipe.m_item;
				if (item == null)
				{
					obj = null;
				}
				else
				{
					GameObject gameObject = ((Component)item).gameObject;
					obj = ((gameObject != null) ? ((Object)gameObject).name : null);
				}
				if (obj == null)
				{
					obj = ((Object)recipe).name ?? string.Empty;
				}
			}
			string text = (string)obj;
			string text2 = ((Localization.instance != null) ? Localization.instance.Localize(text) : text);
			if (quality <= 1)
			{
				return text2;
			}
			return KindleText.Format("tracker_upgrade", text2, quality);
		}

		private static void Message(string text, bool top = false)
		{
			KindleText.Notice(text, top);
		}

		internal static void Relabel()
		{
			builtVersion = -1;
			Tick();
		}

		public static void Tick()
		{
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Invalid comparison between Unknown and I4
			if (settings == null)
			{
				return;
			}
			Load();
			GameObject val = (Object.op_Implicit((Object)(object)Hud.instance) ? Hud.instance.m_rootObject : null);
			if (panel != null && !panel.BelongsTo(Object.op_Implicit((Object)(object)val) ? val.transform : null))
			{
				panel.Dispose();
				panel = null;
				builtVersion = -1;
			}
			bool flag = Active && settings.Get<bool>(Tracker.Enabled) && entries.Count > 0;
			if (Active && Player.m_localPlayer.IsTargeted())
			{
				lastThreat = Time.time;
			}
			if (settings.Get<bool>(Tracker.HideWithMap) && Minimap.IsOpen())
			{
				flag = false;
			}
			if (settings.Get<bool>(Tracker.HideInCombat) && Time.time - lastThreat < 5f)
			{
				flag = false;
			}
			if (panel == null && flag && Object.op_Implicit((Object)(object)val))
			{
				panel = TrackerPanel.Create(val.transform);
				builtVersion = -1;
			}
			if (panel == null)
			{
				return;
			}
			bool free = (int)ZCursor.LockState != 1 && ZCursor.IsVisible;
			panel.Update(flag, free);
			if (!flag)
			{
				return;
			}
			if (builtVersion != version)
			{
				panel.Rebuild(entries);
				builtVersion = version;
				nextCount = 0f;
			}
			if (Time.unscaledTime < nextCount)
			{
				return;
			}
			nextCount = Time.unscaledTime + 1.25f;
			try
			{
				string signature = TrackerStyle.Signature;
				if (signature != builtStyle)
				{
					builtStyle = signature;
					panel.Rebuild(entries);
				}
				TrackerCounts.Tick(entries);
				panel.Count();
			}
			catch (Exception ex)
			{
				MeadworksLog? obj = log;
				if (obj != null)
				{
					obj.Warning("Tracker refresh refused: " + ex.GetType().Name);
				}
			}
		}
	}
	internal sealed class TrackedRecipe
	{
		internal const int MaxAmount = 9999;

		internal string Key { get; }

		internal int Quality { get; }

		internal bool Upgrader { get; }

		internal int Amount { get; set; }

		internal Recipe? Recipe => KindleRecipes.Find(Key);

		internal TrackedRecipe(string key, int quality, int amount, bool upgrader)
		{
			Key = key;
			Quality = Math.Max(1, quality);
			Amount = Mathf.Clamp(amount, 1, 9999);
			Upgrader = upgrader;
		}

		internal bool Is(string key, int quality, bool upgrader)
		{
			if (Key == key && Quality == quality)
			{
				return Upgrader == upgrader;
			}
			return false;
		}

		public override string ToString()
		{
			return Key + "|" + Quality.ToString(CultureInfo.InvariantCulture) + "|" + Amount.ToString(CultureInfo.InvariantCulture) + (Upgrader ? "|u" : "");
		}

		internal static TrackedRecipe? Parse(string text)
		{
			string[] array = (text ?? "").Split('|');
			if (array.Length < 3 || array.Length > 4 || array[0].Length == 0 || !int.TryParse(array[1], out var result) || !int.TryParse(array[2], out var result2))
			{
				return null;
			}
			return new TrackedRecipe(array[0], result, result2, array.Length == 4 && array[3] == "u");
		}
	}
	internal sealed class TrackerPanel : IDisposable
	{
		private sealed class Entry
		{
			internal readonly int Index;

			private readonly TrackedRecipe tracked;

			private readonly Recipe recipe;

			private readonly RectTransform root;

			private readonly RectTransform header;

			private readonly Image icon;

			private readonly TMP_Text name;

			private readonly TMP_Text amount;

			private readonly List<TMP_Text> notes = new List<TMP_Text>();

			private readonly List<Material> materials = new List<Material>();

			private readonly KitIconButton remove;

			private readonly KitIconButton less;

			private readonly KitIconButton more;

			private readonly TrackerPanel panel;

			internal Entry(TrackerPanel panel, Transform parent, TrackedRecipe tracked, int index)
			{
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: 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_025d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0297: Unknown result type (might be due to invalid IL or missing references)
				//IL_031e: Unknown result type (might be due to invalid IL or missing references)
				//IL_035c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0430: Unknown result type (might be due to invalid IL or missing references)
				//IL_0453: Unknown result type (might be due to invalid IL or missing references)
				this.panel = panel;
				this.tracked = tracked;
				recipe = tracked.Recipe;
				Index = index;
				float size = TrackerStyle.Size;
				root = Node(parent, "Kindle_trackerEntry");
				header = Node((Transform)(object)root, "header");
				Image val = ((Component)header).gameObject.AddComponent<Image>();
				((Graphic)val).color = Color.clear;
				panel.hud.SetInteractive((Graphic)(object)val, true);
				KitWheel.Add(((Component)header).gameObject, (Action<int>)delegate(int direction)
				{
					KindleTracker.Step(index, direction, MeadworksInput.ShiftHeld);
				});
				remove = KitIconButton.Create(header, "remove", (KitGlyph)11, Vector2.zero, size * 0.85f, (Action<KitClickKind>)delegate
				{
					KindleTracker.Remove(index);
				});
				less = KitIconButton.Create(header, "less", (KitGlyph)12, Vector2.zero, size, (Action<KitClickKind>)delegate
				{
					KindleTracker.Step(index, -1, MeadworksInput.ShiftHeld);
				});
				more = KitIconButton.Create(header, "more", (KitGlyph)13, Vector2.zero, size, (Action<KitClickKind>)delegate
				{
					KindleTracker.Step(index, 1, MeadworksInput.ShiftHeld);
				});
				remove.Tooltip(KindleText.Text("tracker_untrack"), KindleTracker.DisplayName(recipe, tracked.Quality));
				less.Tooltip(KindleText.Text("tracker_track"), "−");
				more.Tooltip(KindleText.Text("tracker_track"), "+");
				KitIconButton[] array = (KitIconButton[])(object)new KitIconButton[2] { less, more };
				for (int num = 0; num < array.Length; num++)
				{
					array[num].Wheel((Action<int>)delegate(int direction)
					{
						KindleTracker.Step(index, direction, MeadworksInput.ShiftHeld);
					});
				}
				icon = Icon((Transform)(object)header, recipe.m_item.m_itemData.GetIcon(), "icon");
				name = Text((Transform)(object)header, "name", KindleTracker.DisplayName(recipe, tracked.Quality), size, TrackerStyle.Have);
				amount = Text((Transform)(object)header, "amount", "x" + tracked.Amount, size, TrackerStyle.Have);
				CraftingStation requiredStation = recipe.GetRequiredStation(tracked.Quality);
				if (Object.op_Implicit((Object)(object)requiredStation))
				{
					notes.Add(Text((Transform)(object)root, "station", KindleText.Format("tracker_station", Localization.instance.Localize(requiredStation.m_name), recipe.GetRequiredStationLevel(tracked.Quality)), size * 0.8f, TrackerStyle.Dim));
				}
				if (recipe.m_requireOnlyOneIngredient)
				{
					notes.Add(Text((Transform)(object)root, "anyone", KindleText.Text("tracker_anyone"), size * 0.8f, TrackerStyle.Dim));
				}
				foreach (Requirement item in recipe.m_resources.Where((Requirement requirement) => TrackerCounts.Shows(requirement, tracked)))
				{
					RectTransform parent2 = Node((Transform)(object)root, "material");
					materials.Add(new Material
					{
						Root = parent2,
						Requirement = item,
						Icon = Icon((Transform)(object)parent2, item.m_resItem.m_itemData.GetIcon(), "icon"),
						Label = Text((Transform)(object)parent2, "name", Localization.instance.Localize(item.m_resItem.m_itemData.m_shared.m_name), size * 0.9f, TrackerStyle.Have),
						Count = Text((Transform)(object)parent2, "count", "", size * 0.9f, TrackerStyle.Have)
					});
				}
			}

			internal float Width(bool open)
			{
				float size = TrackerStyle.Size;
				float num = size * 1.6f + 3f + name.preferredWidth;
				if (open || tracked.Amount > 1)
				{
					num += size * 1.6f + 3f;
				}
				if (open)
				{
					num += size * 2.85f + 9f;
				}
				return Math.Max(num, Math.Max((notes.Count == 0) ? 0f : (notes.Max((TMP_Text note) => note.preferredWidth) + size * 1.6f + 3f), (materials.Count == 0) ? 0f : materials.Max((Material material) => material.Label.preferredWidth + size * 4.65f + 12f)));
			}

			internal float Layout(float y, float width, bool open)
			{
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Expected O, but got Unknown
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Expected O, but got Unknown
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Expected O, but got Unknown
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Expected O, but got Unknown
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Expected O, but got Unknown
				//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Expected O, but got Unknown
				//IL_0231: Unknown result type (might be due to invalid IL or missing references)
				//IL_0259: Expected O, but got Unknown
				//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e1: Expected O, but got Unknown
				//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0328: Expected O, but got Unknown
				//IL_0333: Unknown result type (might be due to invalid IL or missing references)
				//IL_0359: Expected O, but got Unknown
				float size = TrackerStyle.Size;
				float num = 0f;
				KitIconButton[] array = (KitIconButton[])(object)new KitIconButton[3] { remove, less, more };
				for (int i = 0; i < array.Length; i++)
				{
					((Component)array[i].Button).gameObject.SetActive(open);
				}
				((Component)amount).gameObject.SetActive(open || tracked.Amount > 1);
				if (open)
				{
					PlaceRect((RectTransform)((Component)remove.Button).transform, num, 0f, size * 0.85f, size * 0.85f);
					num += size * 0.85f + 3f;
				}
				PlaceRect((RectTransform)((Component)icon).transform, num, 0f, size * 1.6f, size * 1.6f);
				num += size * 1.6f + 3f;
				float num2 = (open ? (size * 2f + 6f) : 0f) + ((open || tracked.Amount > 1) ? (size * 1.6f + 3f) : 0f);
				PlaceRect((RectTransform)name.transform, num, 0f, width - num - num2, size * 1.6f);
				num = width - num2;
				if (open)
				{
					PlaceRect((RectTransform)((Component)less.Button).transform, num, 0f, size, size);
					num += size + 3f;
				}
				PlaceRect((RectTransform)amount.transform, num, 0f, size * 1.6f, size * 1.6f);
				num += size * 1.6f + 3f;
				if (open)
				{
					PlaceRect((RectTransform)((Component)more.Button).transform, num, 0f, size, size);
				}
				PlaceRect(header, 0f, 0f, width, size * 1.6f);
				float num3 = size * 1.6f + 1f;
				foreach (TMP_Text note in notes)
				{
					PlaceRect((RectTransform)note.transform, size * 1.6f + 3f, num3, width - size * 1.6f - 3f, size);
					num3 += size + 1f;
				}
				foreach (Material material in materials)
				{
					PlaceRect(material.Root, 0f, num3, width, size * 1.25f);
					float num4 = size * 0.4f;
					PlaceRect((RectTransform)((Component)material.Icon).transform, num4, 0f, size * 1.25f, size * 1.25f);
					num4 += size * 1.25f + 6f;
					PlaceRect((RectTransform)material.Label.transform, num4, 0f, width - num4 - size * 3f - 6f, size * 1.25f);
					PlaceRect((RectTransform)material.Count.transform, width - size * 3f, 0f, size * 3f, size * 1.25f);
					material.Count.alignment = (TextAlignmentOptions)4100;
					num3 += size * 1.25f + 1f;
				}
				PlaceRect(root, 0f, y, width, num3);
				return num3;
			}

			internal void Count()
			{
				//IL_0082: 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_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				bool flag = true;
				bool flag2 = false;
				foreach (Material material in materials)
				{
					int num = TrackerCounts.Have(material.Requirement);
					int num2 = TrackerCounts.Need(material.Requirement, tracked);
					bool flag3 = num >= num2;
					material.Count.text = num + "/" + num2;
					TMP_Text count = material.Count;
					Color color = (((Graphic)material.Label).color = (flag3 ? TrackerStyle.Have : TrackerStyle.Missing));
					((Graphic)count).color = color;
					flag = flag && flag3;
					flag2 = flag2 || flag3;
				}
				((Graphic)name).color = ((recipe.m_requireOnlyOneIngredient ? flag2 : flag) ? TrackerStyle.Ready : TrackerStyle.Have);
				((Graphic)amount).color = TrackerStyle.Have;
				amount.text = "x" + tracked.Amount;
			}
		}

		private sealed class Material
		{
			internal RectTransform Root;

			internal Requirement Requirement;

			internal Image Icon;

			internal TMP_Text Label;

			internal TMP_Text Count;
		}

		private readonly KitHudPanel hud;

		private readonly Transform owner;

		private readonly TMP_Text title;

		private readonly RectTransform list;

		private readonly List<Entry> entries = new List<Entry>();

		private bool interactive;

		private TrackerPanel(KitHudPanel hud, Transform owner)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			this.hud = hud;
			this.owner = owner;
			title = Text((Transform)(object)hud.Content, "Kindle_trackerTitle", KindleText.Text("tracker_title"), TrackerStyle.Size * 0.8f, TrackerStyle.Dim);
			hud.SetInteractive((Graphic)(object)title, false);
			list = Node((Transform)(object)hud.Content, "Kindle_trackerEntries");
		}

		internal static TrackerPanel? Create(Transform root)
		{
			//IL_0010: 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)
			KitHudPanel val = KitHudPanel.Create(root, "Kindle_tracker", new Vector2(300f, 60f), new Vector2(20f, 330f), "com.meadworks.kindle", "Kindle_tracker");
			if (val != null)
			{
				return new TrackerPanel(val, root);
			}
			return null;
		}

		internal bool BelongsTo(Transform? root)
		{
			if (Object.op_Implicit((Object)(object)hud.Root))
			{
				return owner == root;
			}
			return false;
		}

		internal void Update(bool show, bool free)
		{
			hud.Update(show, free, 1f, KindleTracker.Settings.Get<float>(Tracker.BackgroundOpacity));
			if (interactive != free)
			{
				interactive = free;
				Layout();
			}
		}

		internal void Rebuild(IReadOnlyList<TrackedRecipe> tracked)
		{
			for (int num = ((Transform)list).childCount - 1; num >= 0; num--)
			{
				GameObject gameObject = ((Component)((Transform)list).GetChild(num)).gameObject;
				gameObject.SetActive(false);
				Object.Destroy((Object)(object)gameObject);
			}
			entries.Clear();
			title.font = TrackerStyle.Font;
			title.fontSize = TrackerStyle.Size * 0.8f;
			title.text = KindleText.Text("tracker_title");
			for (int i = 0; i < tracked.Count; i++)
			{
				if (Object.op_Implicit((Object)(object)tracked[i].Recipe))
				{
					entries.Add(new Entry(this, (Transform)(object)list, tracked[i], i));
				}
			}
			Layout();
		}

		internal void Count()
		{
			foreach (Entry entry in entries)
			{
				entry.Count();
			}
			Layout();
		}

		private void Layout()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_00ce: 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_0163: Unknown result type (might be due to invalid IL or missing references)
			float num = Math.Max(title.preferredWidth, (entries.Count == 0) ? 100f : entries.Max((Entry entry) => entry.Width(interactive)));
			num += 12f;
			float num2 = 6f;
			PlaceRect((RectTransform)title.transform, 6f, num2, num - 12f, TrackerStyle.Size);
			num2 += TrackerStyle.Size + 4f;
			PlaceRect(list, 6f, num2, num - 12f, 1f);
			float num3 = 0f;
			foreach (Entry entry in entries)
			{
				if (num3 > 0f)
				{
					Divider.Place(list, new Vector2(0f, 0f - num3), num - 12f, true, "Kindle_divider_" + entry.Index);
					num3 += 6f;
				}
				num3 += entry.Layout(num3, num - 12f, interactive) + 4f;
			}
			list.sizeDelta = new Vector2(num - 12f, num3);
			hud.Root.sizeDelta = new Vector2(num, num2 + num3 + 6f);
		}

		public void Dispose()
		{
			hud.Dispose();
		}

		private static RectTransform Node(Transform parent, string name)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			RectTransform val = (RectTransform)new GameObject(name, new Type[1] { typeof(RectTransform) }).transform;
			((Transform)val).SetParent(parent, false);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0f, 1f);
			val.pivot = val2;
			Vector2 anchorMin = (val.anchorMax = val2);
			val.anchorMin = anchorMin;
			return val;
		}

		private static TMP_Text Text(Transform parent, string name, string text, float size, Color color)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			TMP_Text obj = KitCanvas.Text(parent, name, text, size, color, (TextAlignmentOptions)4097, false);
			obj.font = TrackerStyle.Font;
			return obj;
		}

		private static void PlaceRect(RectTransform rect, float x, float y, float width, float height)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			rect.pivot = val;
			Vector2 anchorMin = (rect.anchorMax = val);
			rect.anchorMin = anchorMin;
			rect.anchoredPosition = new Vector2(x, 0f - y);
			rect.sizeDelta = new Vector2(width, height);
		}

		private static Image Icon(Transform parent, Sprite sprite, string name)
		{
			Image obj = ((Component)Node(parent, name)).gameObject.AddComponent<Image>();
			obj.sprite = sprite;
			obj.preserveAspect = true;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}
	}
	internal static class TrackerStyle
	{
		private static readonly string[] names = new string[3] { "Valheim-AveriaSansLibre", "Valheim-AveriaSerifLibre", "Valheim-Norsebold" };

		private static string loaded = "";

		private static TMP_FontAsset? resolved;

		private static TMP_FontAsset? ownedAsset;

		private static Font? ownedFont;

		internal static float Size => KindleTracker.Settings.Get<int>(Tracker.FontSize);

		internal static Color Dim => new Color(0.72f, 0.72f, 0.72f, 1f);

		internal static Color Have => Colour(Tracker.HaveColour, Color.white);

		internal static Color Missing => Colour(Tracker.MissingColour, new Color(1f, 0.42f, 0.35f));

		internal static Color Ready => Colour(Tracker.ReadyColour, new Color(1f, 0.713f, 0.361f));

		private static string Language
		{
			get
			{
				if (Localization.instance == null)
				{
					return "English";
				}
				return Localization.instance.GetSelectedLanguage();
			}
		}

		internal static string Signature => ((object)KindleTracker.Settings.Get<TrackerFont>(Tracker.Font)/*cast due to .constrained prefix*/).ToString() + "|" + Size + "|" + Language + "|" + (Object.op_Implicit((Object)(object)ObjectDB.instance) ? ObjectDB.instance.m_recipes.Count : 0);

		internal static TMP_FontAsset? Font
		{
			get
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Invalid comparison between Unknown and I4
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Expected I4, but got Unknown
				string text = ((object)KindleTracker.Settings.Get<TrackerFont>(Tracker.Font)/*cast due to .constrained prefix*/).ToString() + "|" + Language;
				if (loaded == text && Object.op_Implicit((Object)(object)resolved))
				{
					return resolved;
				}
				Shutdown();
				loaded = text;
				if (!FontResolver.UsesGameFont(Language))
				{
					FontChoice val = MeadworksFonts.Choose(Language);
					Font val2 = MeadworksFonts.For(Language, Mathf.RoundToInt(Size));
					if ((int)((FontChoice)(ref val)).Kind == 1)
					{
						ownedFont = val2;
					}
					if (Object.op_Implicit((Object)(object)val2))
					{
						try
						{
							ownedAsset = TMP_FontAsset.CreateFontAsset(val2);
							resolved = ownedAsset;
						}
						catch (Exception)
						{
							resolved = null;
						}
					}
				}
				else
				{
					TrackerFont val3 = KindleTracker.Settings.Get<TrackerFont>(Tracker.Font);
					TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
					foreach (TMP_FontAsset val4 in array)
					{
						if (Object.op_Implicit((Object)(object)val4) && ((Object)val4).name == names[Mathf.Clamp((int)val3, 0, names.Length - 1)])
						{
							resolved = val4;
							break;
						}
					}
				}
				if (!Object.op_Implicit((Object)(object)resolved))
				{
					resolved = KitCanvas.Font;
				}
				return resolved;
			}
		}

		private static Color Colour(KindleSetting<string> setting, Color fallback)
		{
			//IL_0016: 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)
			Color result = default(Color);
			if (!ColorUtility.TryParseHtmlString(KindleTracker.Settings.Get<string>(setting), ref result))
			{
				return fallback;
			}
			return result;
		}

		internal static void Shutdown()
		{
			if (Object.op_Implicit((Object)(object)ownedAsset))
			{
				Texture2D[] atlasTextures = ownedAsset.atlasTextures;
				foreach (Texture2D val in atlasTextures)
				{
					if (Object.op_Implicit((Object)(object)val))
					{
						Object.Destroy((Object)(object)val);
					}
				}
				if (Object.op_Implicit((Object)(object)((TMP_Asset)ownedAsset).material))
				{
					Object.Destroy((Object)(object)((TMP_Asset)ownedAsset).material);
				}
				Object.Destroy((Object)(object)ownedAsset);
			}
			if (Object.op_Implicit((Object)(object)ownedFont))
			{
				Object.Destroy((Object)(object)ownedFont);
			}
			ownedAsset = null;
			ownedFont = null;
			resolved = null;
			loaded = "";
		}
	}
	internal static class TrackerCounts
	{
		private sealed class Count
		{
			internal Task<int>? Pending;

			internal int? Available;
		}

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

		private static IAsyncResourceProvider? provider;

		private static CancellationTokenSource? cancellation;

		private static Player? actor;

		private static string session = "";

		private static long world;

		private static long generation;

		internal static bool NearbyAvailable
		{
			get
			{
				IAsyncResourceProvider val = default(IAsyncResourceProvider);
				if (Plugin.IsReady)
				{
					return Plugin.Services.Capabilities.TryResolve<IAsyncResourceProvider>("meadworks.resources.async", new Version(2, 0), ref val);
				}
				return false;
			}
		}

		internal static bool Shows(Requirement requirement, TrackedRecipe entry)
		{
			if (requirement != null && Object.op_Implicit((Object)(object)requirement.m_resItem) && requirement.m_upgraderResource == entry.Upgrader)
			{
				return requirement.GetAmount(entry.Quality) > 0;
			}
			return false;
		}

		internal static int Need(Requirement requirement, TrackedRecipe entry)
		{
			return (int)Math.Min(2147483647L, (long)requirement.GetAmount(entry.Quality) * (long)entry.Amount);
		}

		internal static int Have(Requirement requirement)
		{
			Player localPlayer = Player.m_localPlayer;
			if (!Object.op_Implicit((Object)(object)localPlayer) || requirement == null || !Object.op_Implicit((Object)(object)requirement.m_resItem))
			{
				return 0;
			}
			string name = ((Object)requirement.m_resItem).name;
			if (provider != null && counts.TryGetValue(name, out Count value) && value.Available.HasValue)
			{
				return value.Available.Value;
			}
			string text = requirement.m_resItem.m_itemData?.m_shared?.m_name ?? ((Object)requirement.m_resItem).name;
			if (((Humanoid)localPlayer).GetInventory() == null)
			{
				return 0;
			}
			return ((Humanoid)localPlayer).GetInventory().CountItems(text, -1, true);
		}

		internal static void Shutdown()
		{
			cancellation?.Cancel();
			cancellation?.Dispose();
			cancellation = null;
			counts.Clear();
			provider = null;
			actor = null;
			session = "";
			world = (generation = 0L);
		}

		internal static void Tick(IReadOnlyList<TrackedRecipe> tracked)
		{
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Expected O, but got Unknown
			SessionSnapshot val = Plugin.Session;
			IAsyncResourceProvider val2 = null;
			if (KindleTracker.Active && val.AuthorityReady && val.WorldId != 0L && !string.IsNullOrEmpty(val.SessionId) && KindleTracker.Settings.Get<bool>(Tracker.CountNearbyChests))
			{
				Plugin.Services.Capabilities.TryResolve<IAsyncResourceProvider>("meadworks.resources.async", new Version(2, 0), ref val2);
			}
			if (provider != val2 || actor != Player.m_localPlayer || session != val.SessionId || world != val.WorldId || generation != val.Generation)
			{
				Shutdown();
				provider = val2;
				actor = Player.m_localPlayer;
				session = val.SessionId;
				world = val.WorldId;
				generation = val.Generation;
				if (provider != null)
				{
					cancellation = new CancellationTokenSource();
				}
			}
			if (provider == null || !Object.op_Implicit((Object)(object)actor))
			{
				return;
			}
			string[] array = (from requirement in tracked.Where((TrackedRecipe entry) => Object.op_Implicit((Object)(object)entry.Recipe)).SelectMany((TrackedRecipe entry) => entry.Recipe.m_resources.Where((Requirement requirement) => Shows(requirement, entry)))
				select ((Object)requirement.m_resItem).name).Distinct<string>(StringComparer.Ordinal).ToArray();
			string[] array2 = counts.Keys.Except(array).ToArray();
			foreach (string key in array2)
			{
				counts.Remove(key);
			}
			array2 = array;
			foreach (string text in array2)
			{
				if (!counts.TryGetValue(text, out Count value))
				{
					counts.Add(text, value = new Count());
				}
				if (value.Pending != null)
				{
					if (!value.Pending.IsCompleted)
					{
						continue;
					}
					value.Available = ((value.Pending.Status == TaskStatus.RanToCompletion && value.Pending.Result >= 0) ? new int?(value.Pending.Result) : ((int?)null));
					value.Pending = null;
				}
				try
				{
					AsyncResourceContext val3 = new AsyncResourceContext(actor.GetPlayerID().ToString(CultureInfo.InvariantCulture), world, session, Guid.NewGuid().ToString("N"));
					value.Pending = provider.GetAvailableAsync(val3, text, cancellation.Token);
				}
				catch (Exception)
				{
					value.Available = null;
					value.Pending = null;
				}
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
	internal static class TrackerCraftWatch
	{
		internal sealed class Watch
		{
			internal Player Actor;

			internal Recipe Recipe;

			internal int Quality;

			internal int Crafts;

			internal int Before;

			internal bool Upgrader;
		}

		[HarmonyPrefix]
		[HarmonyPriority(200)]
		private static void Prefix(InventoryGui __instance, Player player, out Watch? __state)
		{
			__state = null;
			Recipe craftRecipe = __instance.m_craftRecipe;
			if (KindleTracker.Active && !((Object)(object)player != (Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)craftRecipe) && Object.op_Implicit((Object)(object)craftRecipe.m_item))
			{
				int num = ((__instance.m_craftUpgradeItem == null) ? 1 : (__instance.m_craftUpgradeItem.m_quality + 1));
				CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
				bool upgrader = Object.op_Implicit((Object)(object)currentCraftingStation) && currentCraftingStation.m_upgrader;
				if (KindleTracker.Settings.Get<bool>(Tracker.Enabled) && KindleTracker.IsTracked(craftRecipe, num, upgrader))
				{
					__state = new Watch
					{
						Actor = player,
						Recipe = craftRecipe,
						Quality = num,
						Upgrader = upgrader,
						Crafts = ((__instance.m_craftUpgradeItem != null || !__instance.m_multiCrafting) ? 1 : __instance.m_multiCraftAmount),
						Before = ((Humanoid)player).GetInventory().CountItems(craftRecipe.m_item.m_itemData.m_shared.m_name, num, false)
					};
				}
			}
		}

		[HarmonyPostfix]
		private static void Postfix(Player player, Watch? __state)
		{
			if (__state != null && (Object)(object)player == (Object)(object)__state.Actor && (Object)(object)player == (Object)(object)Player.m_localPlayer && ((Humanoid)player).GetInventory().CountItems(__state.Recipe.m_item.m_itemData.m_shared.m_name, __state.Quality, false) > __state.Before)
			{
				KindleTracker.Crafted(__state.Recipe, __state.Quality, __state.Crafts, __state.Upgrader);
			}
		}
	}
}
namespace ExtraPotions.Kindle.Runtime.Salvage
{
	public sealed class FractionOverride
	{
		public string Key { get; }

		public float Fraction { get; }

		public ItemMatcher Matcher { get; set; }

		public bool IsExact
		{
			get
			{
				if (Matcher != null)
				{
					return Matcher.IsExactName;
				}
				return false;
			}
		}

		public FractionOverride(string key, float fraction)
		{
			Key = key;
			Fraction = fraction;
		}

		public bool Matches(ItemData item)
		{
			if (Matcher != null)
			{
				return Matcher.Matches(item);
			}
			return false;
		}
	}
	public sealed class ItemGroups
	{
		private readonly Dictionary<string, List<ItemMatcher>> groups = new Dictionary<string, List<ItemMatcher>>(StringComparer.OrdinalIgnoreCase);

		public static ItemGroups Empty { get; } = new ItemGroups();

		public IEnumerable<string> Names => groups.Keys;

		public void Read(YamlNode groupsNode)
		{
			if (groupsNode == null || groupsNode.Kind == YamlNodeKind.Missing)
			{
				return;
			}
			foreach (KeyValuePair<string, YamlNode> entry in groupsNode.Entries)
			{
				if (entry.Value.TryStringList(out List<string> items))
				{
					groups[entry.Key] = ParseMembers(entry.Value, items);
				}
			}
			WarnUnknownGroups(groupsNode);
		}

		private List<ItemMatcher> ParseMembers(YamlNode node, List<string> members)
		{
			List<ItemMatcher> list = new List<ItemMatcher>();
			foreach (string member in members)
			{
				ItemMatcher itemMatcher = ItemMatcher.Parse(member, this);
				if (itemMatcher.Problem != null)
				{
					node.Warn("'" + member + "' is ignored: " + itemMatcher.Problem);
				}
				else
				{
					list.Add(itemMatcher);
				}
			}
			return list;
		}

		private void WarnUnknownGroups(YamlNode groupsNode)
		{
			foreach (KeyValuePair<string, List<ItemMatcher>> group in groups)
			{
				foreach (ItemMatcher item in group.Value)
				{
					if (item.GroupName != null && !groups.ContainsKey(item.GroupName))
					{
						groupsNode.Get(group.Key).Warn("'" + item?.ToString() + "' names a group that does not exist");
					}
				}
			}
		}

		public bool Matches(string group, ItemData item)
		{
			if (item != null && item.m_shared != null)
			{
				return Matches(group, ItemNames.PrefabName(item), item.m_shared);
			}
			return false;
		}

		public bool Matches(string group, string prefabName, SharedData shared)
		{
			return Matches(group, prefabName, shared, new HashSet<string>(StringComparer.OrdinalIgnoreCase));
		}

		private bool Matches(string group, string prefabName, SharedData shared, HashSet<string> visited)
		{
			if (group == null || !groups.TryGetValue(group, out List<ItemMatcher> value) || !visited.Add(group))
			{
				return false;
			}
			foreach (ItemMatcher item in value)
			{
				if ((item.GroupName != null) ? Matches(item.GroupName, prefabName, shared, visited) : item.Matches(prefabName, shared))
				{
					return true;
				}
			}
			return false;
		}
	}
	public sealed class ItemMatcher
	{
		private enum Kind
		{
			Nothing,
			Everything,
			Name,
			Token,
			Prefix,
			Suffix,
			Type,
			Group
		}

		private readonly Kind kind;

		private readonly string text;

		private readonly string source;

		private readonly ItemType type;

		private readonly ItemGroups groups;

		public string Problem { get; }

		public bool IsExactName
		{
			get
			{
				if (kind != Kind.Name)
				{
					return kind == Kind.Token;
				}
				return true;
			}
		}

		public string GroupName
		{
			get
			{
				if (kind != Kind.Group)
				{
					return null;
				}
				return text;
			}
		}

		private ItemMatcher(Kind kind, string text, string source, ItemGroups groups, string problem, ItemType type = (ItemType)0)
		{
			//IL_002d: 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)
			this.kind = kind;
			this.text = text;
			this.source = source;
			this.groups = groups ?? ItemGroups.Empty;
			this.type = type;
			Problem = problem;
		}

		public static ItemMatcher Parse(string text, ItemGroups groups)
		{
			string text2 = (text ?? "").Trim();
			if (text2.Length == 0)
			{
				return new ItemMatcher(Kind.Nothing, "", "", groups, "empty entry", (ItemType)0);
			}
			if (text2 == "*")
			{
				return new ItemMatcher(Kind.Everything, "*", "*", groups, null, (ItemType)0);
			}
			int num = text2.IndexOf(':');
			if (num > 0)
			{
				return ParsePattern(text2.Substring(0, num).Trim().ToLowerInvariant(), text2.Substring(num + 1).Trim(), text2, groups);
			}
			return new ItemMatcher(text2.StartsWith("$") ? Kind.Token : Kind.Name, text2, text2, groups, null, (ItemType)0);
		}

		private static ItemMatcher ParsePattern(string keyword, string value, string source, ItemGroups groups)
		{
			if (value.Length == 0)
			{
				return new ItemMatcher(Kind.Nothing, "", source, groups, "nothing after '" + keyword + ":'", (ItemType)0);
			}
			return keyword switch
			{
				"prefix" => new ItemMatcher(Kind.Prefix, value, source, groups, null, (ItemType)0), 
				"suffix" => new ItemMatcher(Kind.Suffix, value, source, groups, null, (ItemType)0), 
				"group" => new ItemMatcher(Kind.Group, value, source, groups, null, (ItemType)0), 
				"type" => ParseType(value, source, groups), 
				_ => new ItemMatcher(Kind.Nothing, "", source, groups, "unknown matcher '" + keyword + ":'; use prefix:, suffix:, type: or group:", (ItemType)0), 
			};
		}

		private unsafe static ItemMatcher ParseType(string value, string source, ItemGroups groups)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<ItemType>(value, ignoreCase: true, out ItemType result))
			{
				return new ItemMatcher(Kind.Type, ((object)(*(ItemType*)(&result))/*cast due to .constrained prefix*/).ToString(), source, groups, null, result);
			}
			return new ItemMatcher(Kind.Nothing, "", source, groups, "unknown item type '" + value + "'; known: " + string.Join(", ", Enum.GetNames(typeof(ItemType))), (ItemType)0);
		}

		public bool Matches(ItemData item)
		{
			if (item != null && item.m_shared != null)
			{
				return Matches(ItemNames.PrefabName(item), item.m_shared);
			}
			return false;
		}

		public bool Matches(string prefabName, SharedData shared)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			switch (kind)
			{
			case Kind.Everything:
				return true;
			case Kind.Name:
				return string.Equals(prefabName, text, StringComparison.OrdinalIgnoreCase);
			case Kind.Token:
				if (shared != null)
				{
					return string.Equals(shared.m_name, text, StringComparison.OrdinalIgnoreCase);
				}
				return false;
			case Kind.Prefix:
				return prefabName?.StartsWith(text, StringComparison.OrdinalIgnoreCase) ?? false;
			case Kind.Suffix:
				return prefabName?.EndsWith(text, StringComparison.OrdinalIgnoreCase) ?? false;
			case Kind.Type:
				if (shared != null)
				{
					return shared.m_itemType == type;
				}
				return false;
			case Kind.Group:
				return groups.Matches(text, prefabName, shared);
			default:
				return false;
			}
		}

		public override string ToString()
		{
			return source;
		}
	}
	public sealed class ItemMatchSet
	{
		private readonly List<ItemMatcher> matchers;

		public static ItemMatchSet Empty { get; } = new ItemMatchSet(new List<ItemMatcher>());

		public bool IsEmpty => matchers.Count == 0;

		public IReadOnlyList<ItemMatcher> Matchers => matchers;

		private ItemMatchSet(List<ItemMatcher> matchers)
		{
			this.matchers = matchers;
		}

		public static ItemMatchSet Parse(IEnumerable<string> entries, ItemGroups groups)
		{
			List<ItemMatcher> list = new List<ItemMatcher>();
			if (entries != null)
			{
				foreach (string entry in entries)
				{
					if (!string.IsNullOrWhiteSpace(entry))
					{
						list.Add(ItemMatcher.Parse(entry, groups));
					}
				}
			}
			if (list.Count != 0)
			{
				return new ItemMatchSet(list);
			}
			return Empty;
		}

		public bool Matches(ItemData item)
		{
			if (matchers.Count == 0)
			{
				return false;
			}
			if (item != null && item.m_shared != null)
			{
				return Matches(ItemNames.PrefabName(item), item.m_shared);
			}
			return false;
		}

		public bool Matches(string prefabName, SharedData shared)
		{
			foreach (ItemMatcher matcher in matchers)
			{
				if (matcher.Matches(prefabName, shared))
				{
					return true;
				}
			}
			return false;
		}

		public override string ToString()
		{
			return string.Join(", ", matchers);
		}
	}
	public static class ItemNames
	{
		private static readonly Dictionary<GameObject, string> prefabNames = new Dictionary<GameObject, string>();

		public static string PrefabName(ItemData item)
		{
			if (item == null)
			{
				return "";
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null)
			{
				return PrefabName(item.m_dropPrefab);
			}
			if (item.m_shared == null)
			{
				return "";
			}
			return item.m_shared.m_name;
		}

		private static string PrefabName(GameObject prefab)
		{
			if (prefabNames.TryGetValue(prefab, out string value))
			{
				return value;
			}
			value = Utils.GetPrefabName(prefab);
			if (prefabNames.Count > 8192)
			{
				prefabNames.Clear();
			}
			prefabNames[prefab] = value;
			return value;
		}

		public static string DisplayName(ItemData item)
		{
			if (item == null || item.m_shared == null)
			{
				return "";
			}
			return InscribeDetails.Name(item, KitLocalize.Text(item.m_shared.m_name));
		}

		public static bool SameItem(ItemData a, ItemData b)
		{
			if (a != null && b != null && a.m_shared != null && b.m_shared != null)
			{
				return a.m_shared.m_name == b.m_shared.m_name;
			}
			return false;
		}
	}
	public static class ModDataCheck
	{
		private static readonly char[] separators = new char[3] { ',', ';', ' ' };

		private static string parsedFrom;

		private static string[] prefixes = new string[0];

		public static bool Carries(ItemData item)
		{
			if (!SalvageSettings.SkipModData.Value || item.m_customData == null || item.m_customData.Count == 0)
			{
				return false;
			}
			string[] array = Prefixes();
			if (array.Length == 0)
			{
				return false;
			}
			foreach (KeyValuePair<string, string> customDatum in item.m_customData)
			{
				if (StartsWithAny(customDatum.Key, array) && !SalvageRuneLink.Handles(customDatum.Key))
				{
					return true;
				}
			}
			return false;
		}

		private static bool StartsWithAny(string key, string[] list)
		{
			if (key == null)
			{
				return false;
			}
			foreach (string value in list)
			{
				if (key.StartsWith(value, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		private static string[] Prefixes()
		{
			string text = SalvageSettings.ModDataPrefixes.Value ?? "";
			if (text != parsedFrom)
			{
				prefixes = text.Split(separators, StringSplitOptions.RemoveEmptyEntries);
				parsedFrom = text;
			}
			return prefixes;
		}
	}
	public enum RoundingMode
	{
		Floor,
		Round,
		Ceil
	}
	public static class SalvageActions
	{
		public static bool CanSalvage(ItemData item)
		{
			return SalvageRules.Blocker(Player.m_localPlayer, item) == null;
		}

		public static string WhyNot(ItemData item)
		{
			return SalvageRules.Blocker(Player.m_localPlayer, item);
		}

		public static List<SalvageReturn> Returns(ItemData item)
		{
			List<SalvageReturn> list = SalvageReturns.Compute(SalvageRules.FindRecipe(item), item);
			if (list.Count > 0)
			{
				SalvageRuneLink.AddRune(item, list);
				SalvageGemLink.AddGems(item, list);
			}
			return list;
		}

		public static bool Salvage(Player player, ItemData item)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			string text = SalvageRules.Blocker(player, item);
			if (text != null)
			{
				return Refuse(text);
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (!inventory.ContainsItem(item))
			{
				return Refuse(SalvageWords.Cannot);
			}
			List<SalvageReturn> list = Returns(item);
			if (list.Count == 0)
			{
				return Refuse(SalvageWords.Nothing);
			}
			if (!SalvageInventory.Fits(inventory, item, list))
			{
				return Refuse(SalvageWords.NoFit);
			}
			List<SalvageReturn> list2 = SalvageRuneLink.Roll(list);
			int lost = SalvageGemLink.Lost(item, list2);
			if (!Exchange(inventory, item, list2))
			{
				return false;
			}
			SalvageGemLink.ReportLost(lost);
			return true;
		}

		private static bool Exchange(Inventory inventory, ItemData item, List<SalvageReturn> returns)
		{
			SalvageInventory.Snapshot snapshot = new SalvageInventory.Snapshot(inventory);
			string text = Summary(item, returns);
			bool flag = false;
			try
			{
				if (!inventory.RemoveItem(item) || !SalvageInventory.Add(inventory, returns))
				{
					return Refuse(SalvageWords.NoFit);
				}
				flag = true;
			}
			catch
			{
				return Refuse(SalvageWords.NoFit);
			}
			finally
			{
				if (!flag)
				{
					snapshot.Restore(inventory);
				}
			}
			Messages.TopLeft(text);
			return true;
		}

		private static bool Refuse(string word)
		{
			Messages.Center(word);
			return false;
		}

		public static string Summary(ItemData item, List<SalvageReturn> returns)
		{
			if (item == null)
			{
				return string.Empty;
			}
			object obj = item.m_shared?.m_name;
			if (obj == null)
			{
				GameObject dropPrefab = item.m_dropPrefab;
				obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			}
			string value = (string)obj;
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(SalvageWords.Done).Append(' ').Append(value);
			if (item.m_stack > 1)
			{
				stringBuilder.Append(" ×").Append(item.m_stack);
			}
			stringBuilder.Append(": ").Append(ReturnList(returns));
			return stringBuilder.ToString();
		}

		public static string ReturnList(List<SalvageReturn> returns)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (SalvageReturn @return in returns)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append(@return.Amount).Append(' ').Append(@return.Name);
				if (!@return.IsCertain)
				{
					stringBuilder.Append(" (").Append(Percent(@return.Chance)).Append(')');
				}
			}
			return stringBuilder.ToString();
		}

		public static string Percent(float chance)
		{
			return Mathf.RoundToInt(chance * 100f) + "%";
		}

		public static void Confirm(Player player, ItemData item, Action afterwards)
		{
			Ask(player, item, null, delegate
			{
				Accept(player, item, afterwards);
			});
		}

		internal static void Ask(Player player, ItemData item, Inventory chest, Action accept)
		{
			//IL_0080: 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_0098: Expected O, but got Unknown
			//IL_0098: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			string text = SalvageRules.Blocker(player, item, chest);
			if (text != null)
			{
				Messages.Center(text);
				return;
			}
			if (!UnifiedPopup.IsAvailable())
			{
				Messages.Center(SalvageWords.Cannot);
				return;
			}
			string text2 = AskText(item, chest != null);
			ProductRegistration source = Plugin.Source;
			if (source != null && source.IsActive && CrucibleUiPlugin.Active && KitDialogs.Confirm(source, SalvageWords.Salvage, text2, accept, (Action)null, true) != null)
			{
				return;
			}
			bool answered = false;
			UnifiedPopup.Push((PopupBase)new YesNoPopup(SalvageWords.Salvage, text2, (PopupButtonCallback)delegate
			{
				if (!answered)
				{
					answered = true;
					UnifiedPopup.Pop();
					accept();
				}
			}, (PopupButtonCallback)delegate
			{
				if (!answered)
				{
					answered = true;
					UnifiedPopup.Pop();
				}
			}, true, false));
		}

		private static void Accept(Player player, ItemData item, Action afterwards)
		{
			if (Salvage(player, item))
			{
				afterwards?.Invoke();
			}
		}

		private static string AskText(ItemData item, bool fromChest)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(ItemNames.DisplayName(item));
			if (item.m_stack > 1)
			{
				stringBuilder.Append(" ×").Append(item.m_stack);
			}
			if (fromChest)
			{
				stringBuilder.Append('\n').Append(SalvageWords.FromChest);
			}
			string text = InscribeDetails.Lines(item);
			if (text.Length > 0)
			{
				stringBuilder.Append('\n').Append(text);
			}
			stringBuilder.Append("\n\n").Append(SalvageWords.Ask).Append('\n')
				.Append(ReturnList(Returns(item)));
			return stringBuilder.ToString();
		}
	}
	internal static class SalvageChests
	{
		private sealed class Pending
		{
			internal Container Chest;

			internal ItemData Item;

			internal Player Player;

			internal List<SalvageReturn> Returns;

			internal ChestTakeRetry Retry;

			internal Action Done;
		}

		private const string ItemsId = "meadworks.storage.chest_items";

		private const string TakeId = "meadworks.storage.chest_take";

		private static readonly Version ContractVersion = new Version(1, 0);

		private static readonly CapabilityLink<Func<IReadOnlyList<Tuple<object, object>>>> items = new CapabilityLink<Func<IReadOnlyList<Tuple<object, object>>>>("meadworks.storage.chest_items", ContractVersion);

		private static readonly CapabilityLink<Func<object, object, Action, int>> take = new CapabilityLink<Func<object, object, Action, int>>("meadworks.storage.chest_take", ContractVersion);

		private static Pending? pending;

		private static CapabilityRegistry? Registry
		{
			get
			{
				if (!Plugin.IsReady)
				{
					return null;
				}
				return Plugin.Services.Capabilities;
			}
		}

		internal static bool On
		{
			get
			{
				if (!SalvageSettings.NearbyChests.Value)
				{
					return false;
				}
				try
				{
					CapabilityRegistry registry = Registry;
					Func<IReadOnlyList<Tuple<object, object>>> func = default(Func<IReadOnlyList<Tuple<object, object>>>);
					Func<object, object, Action, int> func2 = default(Func<object, object, Action, int>);
					return items.TryGet(registry, ref func) && take.TryGet(registry, ref func2);
				}
				catch (Exception)
				{
					return false;
				}
			}
		}

		internal static bool Busy => pending != null;

		internal static List<KeyValuePair<Container, ItemData>> Items()
		{
			List<KeyValuePair<Container, ItemData>> list = new List<KeyValuePair<Container, ItemData>>();
			if (!SalvageSettings.NearbyChests.Value)
			{
				return list;
			}
			try
			{
				Func<IReadOnlyList<Tuple<object, object>>> func = default(Func<IReadOnlyList<Tuple<object, object>>>);
				Func<object, object, Action, int> func2 = default(Func<object, object, Action, int>);
				if (!items.TryGet(Registry, ref func) || func == null || !take.TryGet(Registry, ref func2))
				{
					return list;
				}
				IReadOnlyList<Tuple<object, object>> readOnlyList = func();
				if (readOnlyList == null)
				{
					return list;
				}
				foreach (Tuple<object, object> item3 in readOnlyList)
				{
					if (item3 == null)
					{
						continue;
					}
					object item = item3.Item1;
					Container val = (Container)((item is Container) ? item : null);
					if (val != null && Object.op_Implicit((Object)(object)val))
					{
						object item2 = item3.Item2;
						ItemData val2 = (ItemData)((item2 is ItemData) ? item2 : null);
						if (val2 != null && val.GetInventory() != null)
						{
							list.Add(new KeyValuePair<Container, ItemData>(val, val2));
						}
					}
				}
			}
			catch (Exception)
			{
				list.Clear();
			}
			return list;
		}

		internal static int Stamp()
		{
			int num = 17;
			foreach (KeyValuePair<Container, ItemData> item in Items())
			{
				num = num * 31 + RuntimeHelpers.GetHashCode(item.Value) * 7 + item.Value.m_stack * 3 + item.Value.m_gridPos.x * 101 + item.Value.m_gridPos.y;
			}
			return num;
		}

		internal static void Confirm(Player player, Container chest, ItemData item, Action afterwards)
		{
			if (!Object.op_Implicit((Object)(object)chest))
			{
				Messages.Center(SalvageWords.ChestBusy);
				return;
			}
			SalvageActions.Ask(player, item, chest.GetInventory(), delegate
			{
				Salvage(player, chest, item, afterwards);
			});
		}

		internal static void Salvage(Player player, Container chest, ItemData item, Action afterwards)
		{
			string text = (Object.op_Implicit((Object)(object)chest) ? SalvageRules.Blocker(player, item, chest.GetInventory()) : SalvageWords.ChestBusy);
			if (text == null && !On)
			{
				text = SalvageWords.Off;
			}
			if (text != null)
			{
				Messages.Center(text);
				return;
			}
			if (pending != null)
			{
				Messages.Center(SalvageWords.ChestWait);
				return;
			}
			List<SalvageReturn> list = SalvageActions.Returns(item);
			if (list.Count == 0)
			{
				Messages.Center(SalvageWords.Nothing);
				return;
			}
			List<SalvageReturn> list2 = SalvageRuneLink.Roll(list);
			int lostGems = SalvageGemLink.Lost(item, list2);
			string summary = SalvageActions.Summary(item, list2);
			Start(player, chest, item, list2, delegate
			{
				SalvageGemLink.ReportLost(lostGems);
				Messages.TopLeft(summary);
				afterwards?.Invoke();
			});
		}

		internal static void Start(Player player, Container chest, ItemData item, List<SalvageReturn> rolled, Action done)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			if (pending != null)
			{
				Messages.Center(SalvageWords.ChestWait);
				return;
			}
			pending = new Pending
			{
				Chest = chest,
				Item = item,
				Player = player,
				Returns = rolled,
				Retry = new ChestTakeRetry(Time.realtimeSinceStartupAsDouble),
				Done = done
			};
			if (!Attempt())
			{
				Messages.Center(SalvageWords.ChestWait);
			}
		}

		internal static void Tick()
		{
			if (pending != null)
			{
				if (!KindleSalvage.Ready || (Object)(object)pending.Player != (Object)(object)Player.m_localPlayer || !Object.op_Implicit((Object)(object)pending.Chest))
				{
					pending = null;
					Messages.Center(SalvageWords.ChestBusy);
				}
				else
				{
					Attempt();
				}
			}
		}

		internal static void Shutdown()
		{
			pending = null;
		}

		private static bool Attempt()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected I4, but got Unknown
			Pending job = pending;
			bool delivered = false;
			int num;
			try
			{
				Func<object, object, Action, int> func = default(Func<object, object, Action, int>);
				num = ((take.TryGet(Registry, ref func) && func != null) ? func(job.Chest, job.Item, delegate
				{
					delivered = true;
					Deliver(job.Player, job.Returns);
				}) : 3);
			}
			catch (Exception)
			{
				num = 3;
			}
			ChestTakeStep val = job.Retry.Next(num, delivered, Time.realtimeSinceStartupAsDouble);
			switch ((int)val)
			{
			case 1:
				return false;
			case 0:
				pending = null;
				Guard(job.Done);
				return true;
			case 2:
				pending = null;
				Messages.Center(SalvageWords.ChestChanged);
				KindleSalvage.Rebuild();
				return true;
			default:
				pending = null;
				Messages.Center(SalvageWords.ChestBusy);
				KindleSalvage.Rebuild();
				return true;
			}
		}

		internal static void Deliver(Player player, List<SalvageReturn> returns)
		{
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (SalvageDelivery.Deliver<SalvageReturn>(returns.Select((SalvageReturn entry) => (entry: entry, Amount: entry.Amount, MaxStack: entry.MaxStack)), (Func<SalvageReturn, int, int>)delegate(SalvageReturn entry, int chunk)
			{
				ItemData val = SalvageInventory.NewStack(entry.Item, chunk);
				if (inventory.AddItem(val))
				{
					return chunk;
				}
				return (entry.MaxStack > 1) ? (chunk - val.m_stack) : 0;
			}, (Action<SalvageReturn, int>)delegate(SalvageReturn entry, int count)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					Transform transform = ((Component)player).transform;
					ItemDrop val = ItemDrop.DropItem(SalvageInventory.NewStack(entry.Item, count), count, transform.position + transform.forward + transform.up, transform.rotation);
					if ((Object)(object)val != (Object)null)
					{
						val.OnPlayerDrop();
					}
				}
				catch (Exception ex)
				{
					KindleSalvage.Warn("Salvage drop: " + ex.GetType().Name);
				}
			}, (Func<SalvageReturn, int>)((SalvageReturn entry) => Stacked(inventory, entry))) > 0)
			{
				Messages.Center(SalvageWords.Dropped);
			}
		}

		private static int Stacked(Inventory inventory, SalvageReturn entry)
		{
			int num = 0;
			GameObject val = (((Object)(object)entry.Item != (Object)null) ? ((Component)entry.Item).gameObject : null);
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem != null && allItem.m_stack > 0 && !((Object)(object)allItem.m_dropPrefab != (Object)(object)val))
				{
					num += allItem.m_stack;
				}
			}
			return num;
		}

		private static void Guard(Action action)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				KindleSalvage.Warn("Salvage from chest: " + ex.GetType().Name);
			}
		}
	}
	internal static class SalvageGemLink
	{
		public const string Id = "meadworks.crafting.salvage_gems";

		private static readonly Version Version = new Version(1, 0);

		private static readonly CapabilityLink<Tuple<Func<object, string[]>, Func<object, float>, Func<int, string>>> link = new CapabilityLink<Tuple<Func<object, string[]>, Func<object, float>, Func<int, string>>>("meadworks.crafting.salvage_gems", Version);

		private static bool TryGet(out Tuple<Func<object, string[]>, Func<object, float>, Func<int, string>>? provider)
		{
			provider = null;
			if (Plugin.IsReady && link.TryGet(Plugin.Services.Capabilities, ref provider) && provider != null && provider.Item1 != null && provider.Item2 != null)
			{
				return provider.Item3 != null;
			}
			return false;
		}

		public static void AddGems(ItemData item, List<SalvageReturn> returns)
		{
			if (item == null || (Object)(object)ObjectDB.instance == (Object)null || !TryGet(out Tuple<Func<object, string[]>, Func<object, float>, Func<int, string>> provider))
			{
				return;
			}
			string[] array;
			float num;
			try
			{
				array = provider.Item1(item) ?? Array.Empty<string>();
				num = provider.Item2(item);
			}
			catch (Exception)
			{
				return;
			}
			if (!(num > 0f))
			{
				return;
			}
			string[] array2 = array;
			foreach (string text in array2)
			{
				GameObject val = (string.IsNullOrEmpty(text) ? null : ObjectDB.instance.GetItemPrefab(text));
				ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					returns.Add(new SalvageReturn(val2, 1, Mathf.Min(num, 1f)));
				}
			}
		}

		public static int Lost(ItemData item, List<SalvageReturn> rolled)
		{
			if (item == null || !TryGet(out Tuple<Func<object, string[]>, Func<object, float>, Func<int, string>> provider))
			{
				return 0;
			}
			string[] gems;
			try
			{
				gems = provider.Item1(item) ?? Array.Empty<string>();
			}
			catch (Exception)
			{
				return 0;
			}
			int num = rolled.Count((SalvageReturn r) => (Object)(object)r.Item != (Object)null && gems.Contains(((Object)r.Item).name));
			return Math.Max(0, gems.Length - num);
		}

		public static void ReportLost(int lost)
		{
			if (lost <= 0 || !TryGet(out Tuple<Func<object, string[]>, Func<object, float>, Func<int, string>> provider))
			{
				return;
			}
			try
			{
				Messages.Center(provider.Item3(lost));
			}
			catch (Exception)
			{
			}
		}
	}
	[HarmonyPatch]
	internal static class SalvageGuiPatches
	{
		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		[HarmonyPostfix]
		private static void Awake(InventoryGui __instance)
		{
			KindleSalvage.Guard(delegate
			{
				KindleSalvage.Ensure(__instance);
			});
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateCraftingPanel")]
		[HarmonyPrefix]
		private static bool Panel(InventoryGui __instance, bool focusView)
		{
			return KindleSalvage.Guard(() => KindleSalvage.BeforeCraftingPanel(__instance, focusView));
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateCraftingPanel")]
		[HarmonyPostfix]
		private static void AfterPanel()
		{
			KindleSalvage.Guard(delegate
			{
				KindleSalvage.Tick();
			});
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipe")]
		[HarmonyPrefix]
		private static bool BeforeRecipe(InventoryGui __instance)
		{
			return KindleSalvage.Guard(() => KindleSalvage.BeforeRecipe(__instance));
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipe")]
		[HarmonyPostfix]
		[HarmonyAfter(new string[] { "randyknapp.mods.epicloot" })]
		[HarmonyPriority(0)]
		private static void Recipe(InventoryGui __instance, Player player)
		{
			KindleSalvage.Guard(delegate
			{
				KindleSalvage.Fill(__instance, player);
			});
		}

		[HarmonyPatch(typeof(InventoryGui), "OnCraftPressed")]
		[HarmonyPrefix]
		private static bool Craft(InventoryGui __instance)
		{
			return KindleSalvage.Guard(() => KindleSalvage.Craft(__instance));
		}

		[HarmonyPatch(typeof(InventoryGui), "OnTabCraftPressed")]
		[HarmonyPrefix]
		private static void CraftTab()
		{
			KindleSalvage.Deselect();
		}

		[HarmonyPatch(typeof(InventoryGui), "OnTabUpgradePressed")]
		[HarmonyPrefix]
		private static void UpgradeTab()
		{
			KindleSalvage.Deselect();
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeGamepadInput")]
		[HarmonyPrefix]
		private static bool Gamepad(InventoryGui __instance)
		{
			return KindleSalvage.Guard(() => KindleSalvage.Gamepad(__instance));
		}

		[HarmonyPatch(typeof(InventoryGui), "Update")]
		[HarmonyPostfix]
		private static void Update(InventoryGui __instance)
		{
			KindleSalvage.Guard(delegate
			{
				KindleSalvage.Hotkey(__instance);
			});
		}
	}
	internal static class SalvageInterop
	{
		private static readonly CapabilityLink<Func<IReadOnlyCollection<string>>> favourites = new CapabilityLink<Func<IReadOnlyCollection<string>>>("meadworks.items.favorites", FavouritesContract.ContractVersion);

		private static readonly FeatureLink inventoryOwner = new FeatureLink(FeatureOwnerContract.Id("inventory"));

		private static readonly CapabilityLink<Func<Tuple<bool, int, int, int>>> layout = new CapabilityLink<Func<Tuple<bool, int, int, int>>>("meadworks.inventory.layout", InventoryLayoutContract.ContractVersion);

		private static CapabilityRegistry? Registry
		{
			get
			{
				if (!Plugin.IsReady)
				{
					return null;
				}
				return Plugin.Services.Capabilities;
			}
		}

		private static bool Loaded(string id)
		{
			if (Chainloader.PluginInfos.TryGetValue(id, out var value) && (Object)(object)value.Instance != (Object)null)
			{
				return ((Behaviour)value.Instance).isActiveAndEnabled;
			}
			return false;
		}

		private static bool PackPanelGrid()
		{
			if (!Loaded("milkyteam.packpanel"))
			{
				return false;
			}
			ConfigEntry<bool> val = default(ConfigEntry<bool>);
			if (Chainloader.PluginInfos["milkyteam.packpanel"].Instance.Config.TryGetEntry<bool>("1. Inventory", "Enabled", ref val))
			{
				return val.Value;
			}
			return true;
		}

		internal static bool Favourite(ItemData item)
		{
			if (item == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			try
			{
				Func<IReadOnlyCollection<string>> func = default(Func<IReadOnlyCollection<string>>);
				if (!favourites.TryGet(Registry, ref func))
				{
					return false;
				}
				IReadOnlyCollection<string> readOnlyCollection = default(IReadOnlyCollection<string>);
				if (!FavouritesContract.TryRead(func, ref readOnlyCollection))
				{
					return true;
				}
				return FavouritesContract.Contains(readOnlyCollection, ItemNames.PrefabName(item), item.m_shared.m_name);
			}
			catch
			{
				return true;
			}
		}

		internal static int FavouritesStamp()
		{
			try
			{
				Func<IReadOnlyCollection<string>> func = default(Func<IReadOnlyCollection<string>>);
				if (!favourites.TryGet(Registry, ref func))
				{
					return 0;
				}
				IReadOnlyCollection<string> readOnlyCollection = default(IReadOnlyCollection<string>);
				if (!FavouritesContract.TryRead(func, ref readOnlyCollection))
				{
					return 1;
				}
				int num = 17 + readOnlyCollection.Count;
				foreach (string item in readOnlyCollection)
				{
					num = num * 31 + StringComparer.Ordinal.GetHashCode(item ?? "");
				}
				return (num == 0 || num == 1) ? 2 : num;
			}
			catch
			{
				return 1;
			}
		}

		internal static bool ListedCell(Player player, ItemData item)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return MainCell(player, item.m_gridPos, listing: true);
		}

		internal static bool FreedCell(Player player, ItemData item)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return MainCell(player, item.m_gridPos, listing: false);
		}

		internal static int FreeCells(Player player, Inventory inventory)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			for (int i = 0; i < inventory.GetHeight(); i++)
			{
				for (int j = 0; j < inventory.GetWidth(); j++)
				{
					if (inventory.GetItemAt(j, i) == null && MainCell(player, new Vector2i(j, i), listing: false))
					{
						num++;
					}
				}
			}
			return num;
		}

		private static bool MainCell(Player player, Vector2i cell, bool listing)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0073: 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_004a: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			if (cell.x < 0 || cell.y < 0 || (listing && cell.y == 0 && cell.x < 8))
			{
				return false;
			}
			CapabilityRegistry registry = Registry;
			bool flag = inventoryOwner.On(registry);
			bool flag2 = PackPanelGrid();
			if (flag == flag2)
			{
				if (!listing)
				{
					if (!flag && cell.x < ((Humanoid)player).GetInventory().GetWidth())
					{
						return cell.y < ((Humanoid)player).GetInventory().GetHeight();
					}
					return false;
				}
				if (cell.x < 8)
				{
					return cell.y < 4;
				}
				return false;
			}
			int result;
			int result2;
			int result3;
			if (flag)
			{
				Func<Tuple<bool, int, int, int>> func = default(Func<Tuple<bool, int, int, int>>);
				InventoryLayout val = default(InventoryLayout);
				if (!layout.TryGet(registry, ref func) || !InventoryLayoutContract.TryRead(func, ref val) || !((InventoryLayout)(ref val)).LaysOut)
				{
					if (listing && cell.x < 8)
					{
						return cell.y < 4;
					}
					return false;
				}
				result = ((InventoryLayout)(ref val)).Width;
				result2 = ((InventoryLayout)(ref val)).Rows;
				result3 = ((InventoryLayout)(ref val)).Blocked;
			}
			else
			{
				if (!player.m_customData.TryGetValue("PackPanel.mainGrid", out var value) || value == null || value.Length > 40)
				{
					if (listing && cell.x < 8)
					{
						return cell.y < 4;
					}
					return false;
				}
				string[] array = value.Split('|');
				if (array.Length != 3 || !int.TryParse(array[0], NumberStyles.None, CultureInfo.InvariantCulture, out result) || !int.TryParse(array[1], NumberStyles.None, CultureInfo.InvariantCulture, out result2) || !int.TryParse(array[2], NumberStyles.None, CultureInfo.InvariantCulture, out result3))
				{
					if (listing && cell.x < 8)
					{
						return cell.y < 4;
					}
					return false;
				}
			}
			if (result < 1 || result > 12 || result2 < 0 || result2 > 128 || result3 < 0 || result3 >= result || (result2 == 0 && result3 != 0) || ((Humanoid)player).GetInventory().GetWidth() != result || result2 > ((Humanoid)player).GetInventory().GetHeight())
			{
				if (listing && cell.x < 8)
				{
					return cell.y < 4;
				}
				return false;
			}
			if (cell.x < result && cell.y < result2)
			{
				if (cell.y == result2 - 1)
				{
					return cell.x < result - result3;
				}
				return true;
			}
			return false;
		}
	}
	public static class SalvageInventory
	{
		internal sealed class Snapshot
		{
			private readonly List<ItemData> items;

			private readonly Dictionary<ItemData, int> counts = new Dictionary<ItemData, int>();

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

			internal Snapshot(Inventory inventory)
			{
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				items = new List<ItemData>(inventory.GetAllItems());
				foreach (ItemData item in items)
				{
					counts[item] = item.m_stack;
					cells[item] = item.m_gridPos;
				}
			}

			internal void Restore(Inventory inventory)
			{
				//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)
				List<ItemData> allItems = inventory.GetAllItems();
				allItems.Clear();
				foreach (ItemData item in items)
				{
					item.m_stack = counts[item];
					item.m_gridPos = cells[item];
					allItems.Add(item);
				}
				inventory.Changed(false, false);
			}
		}

		public static bool Fits(Inventory inventory, ItemData salvaged, List<SalvageReturn> returns)
		{
			Player localPlayer = Player.m_localPlayer;
			bool flag = (Object)(object)localPlayer != (Object)null && inventory == ((Humanoid)localPlayer).GetInventory();
			bool flag2 = inventory.ContainsItem(salvaged) && (!flag || SalvageInterop.FreedCell(localPlayer, salvaged));
			int num = (flag ? SalvageInterop.FreeCells(localPlayer, inventory) : inventory.GetEmptySlots()) + (flag2 ? 1 : 0);
			int num2 = 0;
			foreach (SalvageReturn @return in returns)
			{
				int num3 = @return.Amount - FreeStackRoom(inventory, @return.Name, salvaged);
				if (num3 > 0)
				{
					num2 += (num3 + @return.MaxStack - 1) / @return.MaxStack;
				}
			}
			return num2 <= num;
		}

		private static int FreeStackRoom(Inventory inventory, string name, ItemData except)
		{
			int num = 0;
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (allItem != except && !(allItem.m_shared.m_name != name) && allItem.m_quality == 1 && allItem.m_worldLevel == Game.m_worldLevel && allItem.m_stack < allItem.m_shared.m_maxStackSize)
				{
					num += allItem.m_shared.m_maxStackSize - allItem.m_stack;
				}
			}
			return num;
		}

		public static bool Add(Inventory inventory, List<SalvageReturn> returns)
		{
			Snapshot snapshot = new Snapshot(inventory);
			bool flag = false;
			try
			{
				foreach (SalvageReturn @return in returns)
				{
					if (AddOne(inventory, @return) < @return.Amount)
					{
						return false;
					}
				}
				flag = true;
				return true;
			}
			finally
			{
				if (!flag)
				{
					snapshot.Restore(inventory);
				}
			}
		}

		private static int AddOne(Inventory inventory, SalvageReturn entry)
		{
			int i;
			int num;
			for (i = 0; i < entry.Amount; i += num)
			{
				num = Mathf.Min(entry.MaxStack, entry.Amount - i);
				ItemData val = NewStack(entry.Item, num);
				if (!inventory.AddItem(val))
				{
					return i + ((entry.MaxStack > 1) ? (num - val.m_stack) : 0);
				}
			}
			return i;
		}

		public static ItemData NewStack(ItemDrop drop, int amount)
		{
			ItemData obj = drop.m_itemData.Clone();
			obj.m_dropPrefab = ((Component)drop).gameObject;
			obj.m_stack = amount;
			obj.m_quality = 1;
			obj.m_variant = 0;
			obj.m_equipped = false;
			obj.m_worldLevel = (byte)Game.m_worldLevel;
			return obj;
		}
	}
	public sealed class SalvageModel : YamlModel
	{
		private static bool excludeWarned;

		private readonly List<string> denyEntries = new List<string>();

		public ItemGroups ItemGroups { get; } = new ItemGroups();

		public ItemMatchSet Deny { get; private set; } = ItemMatchSet.Empty;

		public List<FractionOverride> Overrides { get; } = new List<FractionOverride>();

		protected override void Read(YamlNode root)
		{
			YamlNode yamlNode = root.Get("groups");
			if (yamlNode.Kind == YamlNodeKind.Map)
			{
				ItemGroups.Read(yamlNode);
			}
			YamlNode yamlNode2 = root.Get("deny");
			if (IsPresent(yamlNode2) && yamlNode2.TryStringList(out List<string> items))
			{
				denyEntries.AddRange(items);
			}
			YamlNode yamlNode3 = root.Get("overrides");
			if (yamlNode3.Kind == YamlNodeKind.Map)
			{
				foreach (KeyValuePair<string, YamlNode> entry in yamlNode3.Entries)
				{
					ReadOverride(entry.Key, entry.Value);
				}
			}
			WarnRenamedExclude(root);
		}

		private static void WarnRenamedExclude(YamlNode root)
		{
			if (!excludeWarned && IsPresent(root.Get("exclude")))
			{
				excludeWarned = true;
				root.Warn("the key exclude was renamed deny in 1.1.0; rename it in your file");
			}
		}

		protected override void Verify()
		{
			Deny = ItemMatchSet.Parse(denyEntries, ItemGroups);
			foreach (FractionOverride @override in Overrides)
			{
				@override.Matcher = ItemMatcher.Parse(@override.Key, ItemGroups);
			}
		}

		private void ReadOverride(string key, YamlNode value)
		{
			YamlNode yamlNode = ((value.Kind == YamlNodeKind.Scalar) ? value : value.Get("fraction"));
			if (!yamlNode.TryFloat(out var result))
			{
				if (yamlNode.Kind == YamlNodeKind.Missing)
				{
					value.Error("an override needs a fraction, for example { fraction: 1.0 }");
				}
			}
			else if (result < 0f || float.IsNaN(result) || float.IsInfinity(result))
			{
				yamlNode.Error("the fraction cannot be negative");
			}
			else
			{
				Overrides.Add(new FractionOverride(key, result));
			}
		}

		private static bool IsPresent(YamlNode node)
		{
			if (node.Kind != YamlNodeKind.Missing)
			{
				return node.Kind != YamlNodeKind.Null;
			}
			return false;
		}
	}
	internal static class SalvageRarity
	{
		private static MethodInfo apply;

		private static ConfigEntry<bool> shown;

		private static object instance;

		private static readonly object[] args = new object[2];

		internal static void Apply(GameObject icon, ItemData item)
		{
			if ((Object)(object)icon == (Object)null || Plugin.Settings == null || !Plugin.Settings.Get<bool>(Salvage.ShowRarityBackgrounds))
			{
				return;
			}
			try
			{
				Action<object, object> action = default(Action<object, object>);
				if (Plugin.IsReady && Plugin.Services.Capabilities.TryResolve<Action<object, object>>("meadworks.items.rarity_background", new Version(1, 0), ref action))
				{
					action?.Invoke(icon, item);
				}
			}
			catch (Exception)
			{
			}
			ApplyEpicLoot(icon, item);
		}

		private static void ApplyEpicLoot(GameObject icon, ItemData item)
		{
			try
			{
				if (Chainloader.PluginInfos.TryGetValue("randyknapp.mods.epicloot", out var value) && !((Object)(object)value.Instance == (Object)null))
				{
					if (instance != value.Instance)
					{
						instance = value.Instance;
						apply = ((object)value.Instance).GetType().Assembly.GetType("EpicLoot.API")?.GetMethod("ApplyMagicItemBackgroundToIcon", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
						{
							typeof(GameObject),
							typeof(ItemData)
						}, null);
						value.Instance.Config.TryGetEntry<bool>("Interface", "Show Rarity In Recipe List", ref shown);
					}
					if (!(apply == null) && (shown == null || shown.Value))
					{
						args[0] = icon;
						args[1] = item;
						apply.Invoke(null, args);
					}
				}
			}
			catch (Exception)
			{
				apply = null;
			}
			finally
			{
				args[0] = (args[1] = null);
			}
		}

		internal static void Shutdown()
		{
			instance = null;
			apply = null;
			shown = null;
			args[0] = (args[1] = null);
		}
	}
	public readonly struct SalvageReturn
	{
		public float Chance { get; }

		public bool IsCertain => Chance >= 1f;

		public ItemDrop Item { get; }

		public int Amount { get; }

		public string Name => Item.m_itemData.m_shared.m_name;

		public int MaxStack
		{
			get
			{
				if (Item.m_itemData.m_shared.m_maxStackSize >= 1)
				{
					return Item.m_itemData.m_shared.m_maxStackSize;
				}
				return 1;
			}
		}

		public SalvageReturn(ItemDrop item, int amount, float chance = 1f)
		{
			Item = item;
			Amount = amount;
			Chance = chance;
		}
	}
	public static class SalvageReturns
	{
		public static List<SalvageReturn> Compute(Recipe recipe, ItemData item)
		{
			List<SalvageReturn> list = new List<SalvageReturn>();
			if ((Object)(object)recipe == (Object)null || item == null)
			{
				return list;
			}
			float fraction = SalvageRules.Fraction(item);
			List<KeyValuePair<ItemDrop, float>> list2 = new List<KeyValuePair<ItemDrop, float>>();
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement val in resources)
			{
				if (!((Object)(object)val.m_resItem == (Object)null) && !val.m_upgraderResource)
				{
					Accumulate(list2, val.m_resItem, FullCost(recipe, val, item));
				}
			}
			foreach (KeyValuePair<ItemDrop, float> item2 in list2)
			{
				int num = Shrink(item2.Value, fraction);
				if (num > 0)
				{
					list.Add(new SalvageReturn(item2.Key, num));
				}
			}
			return list;
		}

		private static float FullCost(Recipe recipe, Requirement requirement, ItemData item)
		{
			int num = Mathf.Max(1, recipe.m_amount);
			float num2 = (float)item.m_stack / (float)num * (float)Mathf.Max(0, requirement.m_amount);
			if (SalvageSettings.UpgradeMaterials.Value)
			{
				for (int i = 2; i <= item.m_quality; i++)
				{
					num2 += (float)(item.m_stack * Mathf.Max(0, requirement.GetAmount(i)));
				}
			}
			return num2;
		}

		private static void Accumulate(List<KeyValuePair<ItemDrop, float>> costs, ItemDrop drop, float cost)
		{
			string name = drop.m_itemData.m_shared.m_name;
			for (int i = 0; i < costs.Count; i++)
			{
				if (!(costs[i].Key.m_itemData.m_shared.m_name != name))
				{
					costs[i] = new KeyValuePair<ItemDrop, float>(costs[i].Key, costs[i].Value + cost);
					return;
				}
			}
			costs.Add(new KeyValuePair<ItemDrop, float>(drop, cost));
		}

		public static int Shrink(float fullCost, float fraction)
		{
			if (fullCost <= 0f)
			{
				return 0;
			}
			float num = fullCost * fraction;
			int num2 = RoundBy(num, SalvageSettings.Rounding.Value);
			num2 = Mathf.Min(num2, Mathf.CeilToInt(fullCost - 0.0001f));
			if (SalvageSettings.AtLeastOne.Value && num > 0f && num2 < 1)
			{
				num2 = 1;
			}
			if (num2 >= 0)
			{
				return num2;
			}
			return 0;
		}

		private static int RoundBy(float value, RoundingMode mode)
		{
			return mode switch
			{
				RoundingMode.Floor => Mathf.FloorToInt(value + 0.0001f), 
				RoundingMode.Ceil => Mathf.CeilToInt(value - 0.0001f), 
				_ => (int)Math.Floor(value + 0.5f), 
			};
		}
	}
	public static class SalvageRules
	{
		private static readonly Dictionary<string, Recipe> recipeCache = new Dictionary<string, Recipe>();

		private static ObjectDB cacheDb;

		private static int cacheCount = -1;

		public static SalvageModel Current { get; private set; }

		public static void Apply(SalvageModel model)
		{
			Current = model;
		}

		public static Recipe FindRecipe(ItemData item)
		{
			ObjectDB instance = ObjectDB.instance;
			if (item == null || item.m_shared == null || (Object)(object)instance == (Object)null)
			{
				return null;
			}
			if ((Object)(object)cacheDb != (Object)(object)instance || cacheCount != instance.m_recipes.Count)
			{
				recipeCache.Clear();
				cacheDb = instance;
				cacheCount = instance.m_recipes.Count;
			}
			string name = item.m_shared.m_name;
			if (!recipeCache.TryGetValue(name, out Recipe value))
			{
				value = ScanRecipes(instance, name);
				recipeCache[name] = value;
			}
			return value;
		}

		private static Recipe ScanRecipes(ObjectDB db, string name)
		{
			foreach (Recipe recipe in db.m_recipes)
			{
				if (!((Object)(object)recipe == (Object)null) && !((Object)(object)recipe.m_item == (Object)null) && recipe.m_enabled && !recipe.m_requireOnlyOneIngredient && !(recipe.m_item.m_itemData.m_shared.m_name != name) && recipe.m_resources.Length != 0 && !NeedsItself(recipe, name))
				{
					return recipe;
				}
			}
			return null;
		}

		private static bool NeedsItself(Recipe recipe, string name)
		{
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement val in resources)
			{
				if ((Object)(object)val.m_resItem != (Object)null && val.m_resItem.m_itemData.m_shared.m_name == name)
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsExcluded(ItemData item)
		{
			if (Current != null && !Current.Deny.IsEmpty)
			{
				return Current.Deny.Matches(item);
			}
			return false;
		}

		public static bool IsFavourite(ItemData item)
		{
			return SalvageInterop.Favourite(item);
		}

		public static float Fraction(ItemData item)
		{
			float num = SalvageSettings.ReturnFraction.Value;
			if (Current != null)
			{
				FractionOverride fractionOverride = null;
				foreach (FractionOverride @override in Current.Overrides)
				{
					if (@override.Matches(item))
					{
						if (@override.IsExact)
						{
							return @override.Fraction;
						}
						fractionOverride = fractionOverride ?? @override;
					}
				}
				if (fractionOverride != null)
				{
					num = fractionOverride.Fraction;
				}
			}
			if (!(num < 0f))
			{
				return num;
			}
			return 0f;
		}

		public static string Blocker(Player player, ItemData item)
		{
			return Blocker(player, item, null);
		}

		public static string Blocker(Player player, ItemData item, Inventory chest)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Invalid comparison between Unknown and I4
			if (!KindleSalvage.Ready || !SalvageSettings.Enabled.Value)
			{
				return SalvageWords.Off;
			}
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer || item == null || !(chest ?? ((Humanoid)player).GetInventory()).ContainsItem(item))
			{
				return SalvageWords.Cannot;
			}
			if (item == null || item.m_shared == null)
			{
				return SalvageWords.Cannot;
			}
			if ((int)item.m_shared.m_itemType == 13 || item.m_shared.m_questItem)
			{
				return SalvageWords.Cannot;
			}
			Recipe val = FindRecipe(item);
			if ((Object)(object)val == (Object)null)
			{
				return SalvageWords.NoRecipe;
			}
			if (IsFavourite(item))
			{
				return SalvageWords.Favourite;
			}
			if (IsExcluded(item))
			{
				return SalvageWords.Excluded;
			}
			if (ModDataCheck.Carries(item))
			{
				return SalvageWords.ModData;
			}
			return PlayerBlocker(player, item, val);
		}

		private static string PlayerBlocker(Player player, ItemData item, Recipe recipe)
		{
			if (item.m_equipped || ((Object)(object)player != (Object)null && ((Humanoid)player).IsItemEquiped(item)))
			{
				return SalvageWords.Equipped;
			}
			if (SalvageSettings.RequireKnownRecipe.Value && (Object)(object)player != (Object)null && !KnowsRecipe(player, item, recipe))
			{
				return SalvageWords.Unknown;
			}
			if (SalvageSettings.RequireStation.Value && (Object)(object)player != (Object)null && !StationInRange(player, recipe))
			{
				return SalvageWords.NoStation;
			}
			return null;
		}

		public static bool KnowsRecipe(Player player, ItemData item, Recipe recipe)
		{
			if (player.IsRecipeKnown(recipe.m_item.m_itemData.m_shared.m_name) || item.m_crafterID == 0L || player.NoCostCheat())
			{
				return true;
			}
			if ((Object)(object)ZoneSystem.instance != (Object)null)
			{
				return ZoneSystem.instance.GetGlobalKey((GlobalKeys)28);
			}
			return false;
		}

		public static bool StationInRange(Player player, Recipe recipe)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			CraftingStation craftingStation = recipe.m_craftingStation;
			if ((Object)(object)craftingStation == (Object)null)
			{
				return true;
			}
			CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
			if ((Object)(object)currentCraftingStation != (Object)null && currentCraftingStation.m_name == craftingStation.m_name)
			{
				return true;
			}
			return (Object)(object)CraftingStation.HaveBuildStationInRange(craftingStation.m_name, ((Component)player).transform.position) != (Object)null;
		}
	}
	internal static class SalvageRuneLink
	{
		public const string Id = "meadworks.crafting.salvage_rune";

		public const string HandledPrefix = "ecf_";

		private static readonly CapabilityLink<Tuple<Func<object, string>, Func<object, float>>> link = new CapabilityLink<Tuple<Func<object, string>, Func<object, float>>>("meadworks.crafting.salvage_rune", SalvageRuneContract.ContractVersion);

		public static bool Present
		{
			get
			{
				Tuple<Func<object, string>, Func<object, float>> provider;
				return TryGet(out provider);
			}
		}

		private static bool TryGet(out Tuple<Func<object, string>, Func<object, float>>? provider)
		{
			provider = null;
			if (Plugin.IsReady && link.TryGet(Plugin.Services.Capabilities, ref provider) && provider != null && provider.Item1 != null)
			{
				return provider.Item2 != null;
			}
			return false;
		}

		public static bool Handles(string key)
		{
			if (key.StartsWith("ecf_", StringComparison.Ordinal))
			{
				return Present;
			}
			return false;
		}

		public static void AddRune(ItemData item, List<SalvageReturn> returns)
		{
			if (item == null || (Object)(object)ObjectDB.instance == (Object)null || !TryGet(out Tuple<Func<object, string>, Func<object, float>> provider))
			{
				return;
			}
			string text;
			float num;
			try
			{
				text = provider.Item1(item);
				num = provider.Item2(item);
			}
			catch (Exception)
			{
				return;
			}
			if (!string.IsNullOrEmpty(text) && num > 0f)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
				ItemDrop val = (((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val != (Object)null)
				{
					returns.Add(new SalvageReturn(val, 1, Mathf.Min(num, 1f)));
				}
			}
		}

		public static List<SalvageReturn> Roll(List<SalvageReturn> returns)
		{
			List<SalvageReturn> list = new List<SalvageReturn>(returns.Count);
			foreach (SalvageReturn @return in returns)
			{
				if (@return.IsCertain)
				{
					list.Add(@return);
				}
				else if (Random.value < @return.Chance)
				{
					list.Add(new SalvageReturn(@return.Item, @return.Amount));
				}
			}
			return list;
		}
	}
	internal sealed class SalvageValue<T>
	{
		private readonly Func<T> read;

		public T Value => read();

		internal SalvageValue(Func<T> read)
		{
			this.read = read;
		}
	}
	internal static class SalvageSettings
	{
		internal static readonly SalvageValue<bool> Enabled = Read<bool>(Salvage.Enabled);

		internal static readonly SalvageValue<float> ReturnFraction = Read<float>(Salvage.ReturnFraction);

		internal static readonly SalvageValue<RoundingMode> Rounding = new SalvageValue<RoundingMode>(() => (Plugin.Settings == null) ? RoundingMode.Round : ((RoundingMode)Plugin.Settings.Get<SalvageRounding>(Salvage.Rounding)));

		internal static readonly SalvageValue<bool> AtLeastOne = Read<bool>(Salvage.AtLeastOne);

		internal static readonly SalvageValue<bool> UpgradeMaterials = Read<bool>(Salvage.UpgradeMaterials);

		internal static readonly SalvageValue<bool> RequireKnownRecipe = Read<bool>(Salvage.RequireKnownRecipe);

		internal static readonly SalvageValue<bool> RequireStation = Read<bool>(Salvage.RequireStation);

		internal static readonly SalvageValue<bool> SkipModData = Read<bool>(Salvage.SkipItemsWithModData);

		internal static readonly SalvageValue<string> ModDataPrefixes = Read<string>(Salvage.ModDataPrefixes);

		internal static readonly SalvageValue<bool> NearbyChests = Read<bool>(Salvage.NearbyChests);

		private static SalvageValue<T> Read<T>(KindleSetting<T> setting)
		{
			return new SalvageValue<T>(() => (Plugin.Settings == null) ? setting.Default : Plugin.Settings.Get<T>(setting));
		}
	}
	public static class SalvageWords
	{
		public static string Salvage => KindleText.Text("salvage");

		public static string Ask => KindleText.Text("salvage_ask");

		public static string Empty => KindleText.Text("salvage_empty");

		public static string Nothing => KindleText.Text("salvage_nothing");

		public static string NoFit => KindleText.Text("salvage_nofit");

		public static string Off => KindleText.Text("salvage_off");

		public static string Cannot => KindleText.Text("salvage_cannot");

		public static string NoRecipe => KindleText.Text("salvage_norecipe");

		public static string Favourite => KindleText.Text("salvage_favorite");

		public static string Excluded => KindleText.Text("salvage_excluded");

		public static string ModData => KindleText.Text("salvage_moddata");

		public static string Equipped => KindleText.Text("salvage_equipped");

		public static string Unknown => KindleText.Text("salvage_unknown");

		public static string NoStation => KindleText.Text("salvage_nostation");

		public static string Done => KindleText.Text("salvage_done");

		public static string FromChest => KindleText.Text("salvage_from_chest");

		public static string ChestWait => KindleText.Text("salvage_chest_wait");

		public static string ChestChanged => KindleText.Text("salvage_chest_changed");

		public static string ChestBusy => KindleText.Text("salvage_chest_busy");

		public static string Dropped => KindleText.Text("salvage_dropped");
	}
	internal static class Messages
	{
		internal static void Center(string text)
		{
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, text, 0, (Sprite)null, false);
			}
		}

		internal static void TopLeft(string text)
		{
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)1, text, 0, (Sprite)null, false);
			}
		}
	}
	internal static class SalvageYaml
	{
		private static ConfigEntry<string> carrier;

		private static long synchronizedGeneration = -1L;

		private static long observedGeneration = -1L;

		private static KindleSyncReceipt syncReceipt = new KindleSyncReceipt();

		private static string applied;

		private static float nextRead;

		private static bool initialized;

		private static int ownerThread;

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

		internal static bool Ready { get; private set; }

		internal static IReadOnlyDictionary<string, string> Files { get; private set; } = new Dictionary<string, string>();

		internal static void Initialize(ConfigFile config, ProductRegistration registration)
		{
			//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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			bool saveOnConfigSet = config.SaveOnConfigSet;
			config.SaveOnConfigSet = false;
			try
			{
				ConfigurationManagerAttributes val = new ConfigurationManagerAttributes
				{
					Browsable = false,
					ReadOnly = true
				};
				carrier = ConfigFileExtensions.BindConfig<string>(config, "Salvage", "Managed YAML Content", "", "Managed salvage rules; edit Kindle.Salvage*.yml instead.", true, (int?)null, (AcceptableValueBase)null, (Action<ConfigEntryBase>)null, val);
			}
			finally
			{
				config.SaveOnConfigSet = saveOnConfigSet;
			}
			config.Save();
			SynchronizationManager.OnConfigurationSynchronized += Synchronized;
			registration.AddCapability<Func<IReadOnlyDictionary<string, string>>>("meadworks.crafting.salvage_yaml", new Version(1, 0), (Func<IReadOnlyDictionary<string, string>>)(() => Files));
			ownerThread = Thread.CurrentThread.ManagedThreadId;
			initialized = true;
			Reload();
		}

		private static void Synchronized(object sender, ConfigurationSynchronizationEventArgs args)
		{
			if (Plugin.IsReady && args.UpdatedPluginGUIDs != null && args.UpdatedPluginGUIDs.Contains("com.meadworks.kindle"))
			{
				syncReceipt.Observe();
				synchronizedGeneration = syncReceipt.CurrentGeneration;
				nextRead = 0f;
			}
		}

		internal static void Tick()
		{
			if (initialized && Plugin.IsReady)
			{
				long generation = Plugin.Session.Generation;
				if (observedGeneration != generation)
				{
					observedGeneration = generation;
					applied = null;
					Ready = false;
					SalvageRules.Apply(null);
					nextRead = 0f;
				}
				if (!(Time.unscaledTime < nextRead))
				{
					nextRead = Time.unscaledTime + 5f;
					Reload();
				}
			}
		}

		internal static void Reload()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			if (!initialized || !Plugin.IsReady)
			{
				return;
			}
			try
			{
				bool flag = (int)Plugin.Session.Role == 3;
				AuthorityDecision val = MeadworksAuthority.Decide("com.meadworks.kindle", (ConfigScope)1, true);
				if (flag && (int)val.Source == 1)
				{
					synchronizedGeneration = syncReceipt.CurrentGeneration;
					if (synchronizedGeneration != Plugin.Session.Generation)
					{
						Ready = false;
					}
					else
					{
						Apply(MeadworksConfig.Effective<string>(carrier, "com.meadworks.kindle", (ConfigScope)1, "", true));
					}
					return;
				}
				if ((int)val.Source == 2)
				{
					Ready = false;
					return;
				}
				string text = Path.Combine(Paths.ConfigPath, "Kindle.Salvage.yml");
				string[] array = (from p in Directory.GetFiles(Paths.ConfigPath, "Kindle.Salvage*.yml")
					orderby (!Path.GetFileName(p).Equals("Kindle.Salvage.yml", StringComparison.OrdinalIgnoreCase)) ? 1 : 0
					select p).ThenBy<string, string>((string p) => Path.GetFileName(p), StringComparer.OrdinalIgnoreCase).ToArray();
				if (array.Length == 0)
				{
					using (Stream stream = typeof(SalvageYaml).Assembly.GetManifestResourceStream("Kindle.config.Kindle.Salvage.yml"))
					{
						if (stream == null)
						{
							throw new InvalidOperationException("Embedded salvage rules missing.");
						}
						using StreamReader streamReader = new StreamReader(stream);
						using StreamWriter streamWriter = new StreamWriter(new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.Read));
						streamWriter.Write(streamReader.ReadToEnd());
					}
					array = new string[1] { text };
				}
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				string[] array2 = array;
				foreach (string path in array2)
				{
					dictionary.Add(Path.GetFileName(path), File.ReadAllText(path));
				}
				RegisterDocuments(dictionary.Keys);
				string text2 = JsonConvert.SerializeObject((object)dictionary);
				if (Apply(text2) && !flag && carrier.Value != text2)
				{
					MeadworksConfig.Amend<string>(carrier, "com.meadworks.kindle", (ConfigScope)1, text2, (string)null, true);
				}
			}
			catch (Exception ex)
			{
				KindleSalvage.Warn("Salvage YAML reload refused: " + ex.GetType().Name);
			}
		}

		private static bool Apply(string text)
		{
			if (text == applied && Ready)
			{
				return true;
			}
			Dictionary<string, string> dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(text ?? "");
			if (dictionary == null || dictionary.Count == 0)
			{
				return false;
			}
			foreach (KeyValuePair<string, string> item in dictionary)
			{
				if (Path.GetFileName(item.Key) != item.Key || !item.Key.StartsWith("Kindle.Salvage", StringComparison.OrdinalIgnoreCase) || !item.Key.EndsWith(".yml", StringComparison.OrdinalIgnoreCase) || item.Value == null)
				{
					throw new InvalidOperationException("Invalid salvage file-set shape.");
				}
			}
			SalvageModel salvageModel = new SalvageModel();
			salvageModel.LoadAll(dictionary);
			if (salvageModel.Errors.Count != 0)
			{
				KindleSalvage.Warn("Salvage YAML rejected; previous rules retained (" + salvageModel.Errors.Count + " errors).");
				return false;
			}
			if (salvageModel.Warnings.Count != 0)
			{
				KindleSalvage.Warn("Salvage YAML applied with " + salvageModel.Warnings.Count + " warnings.");
			}
			Files = new ReadOnlyDictionary<string, string>(dictionary);
			SalvageRules.Apply(salvageModel);
			applied = text;
			Ready = true;
			KindleSalvage.Rebuild();
			RegisterDocuments(dictionary.Keys);
			return true;
		}

		private static void RegisterDocuments(IEnumerable<string> names)
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			HashSet<string> current = new HashSet<string>(names, StringComparer.OrdinalIgnoreCase);
			string[] array = documents.Keys.Where((string name) => !current.Contains(name)).ToArray();
			foreach (string key in array)
			{
				documents[key].Dispose();
				documents.Remove(key);
			}
			foreach (string item in current)
			{
				if (!documents.ContainsKey(item))
				{
					string captured = item;
					string text = Path.Combine(Paths.ConfigPath, item);
					documents.Add(item, MeadworksDataFiles.Register(new DataFileRegistration("com.meadworks.kindle", item, text, (Func<string>)(() => ReadDocument(captured)), (Func<string, IReadOnlyList<string>>)((string text2) => ValidateDocument(captured, text2)), (Func<string, string, bool>)((string original, string text2) => ApplyDocument(captured, original, text2)))));
				}
			}
		}

		private static void DocumentOwner()
		{
			if (!initialized || !Plugin.IsReady || Thread.CurrentThread.ManagedThreadId != ownerThread)
			{
				throw new InvalidOperationException("Salvage documents require their live owning thread.");
			}
		}

		private static string ReadDocument(string name)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			DocumentOwner();
			if ((int)Plugin.Session.Role == 3)
			{
				if (!Ready || observedGeneration != Plugin.Session.Generation || !Files.TryGetValue(name, out string value))
				{
					throw new InvalidOperationException("Current-session salvage content is not ready.");
				}
				return value;
			}
			return KindleAlmanac.ReadText(Path.Combine(Paths.ConfigPath, name));
		}

		private static Dictionary<string, string> DiskDocuments()
		{
			return Directory.GetFiles(Paths.ConfigPath, "Kindle.Salvage*.yml").ToDictionary<string, string, string>((string path) => Path.GetFileName(path), (string path) => KindleAlmanac.ReadText(path), StringComparer.OrdinalIgnoreCase);
		}

		private static IReadOnlyList<string> ValidateDocument(string name, string text)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Invalid comparison between Unknown and I4
			DocumentOwner();
			if (text == null || Encoding.UTF8.GetByteCount(text) > 1048576)
			{
				return new string[1] { "Salvage text exceeds 1 MiB." };
			}
			Dictionary<string, string> dictionary = (((int)Plugin.Session.Role == 3) ? Files.ToDictionary<KeyValuePair<string, string>, string, string>((KeyValuePair<string, string> p) => p.Key, (KeyValuePair<string, string> p) => p.Value, StringComparer.OrdinalIgnoreCase) : DiskDocuments());
			if (!dictionary.ContainsKey(name))
			{
				return new string[1] { "The registered salvage file no longer exists." };
			}
			dictionary[name] = text;
			SalvageModel salvageModel = new SalvageModel();
			salvageModel.LoadAll(KindleAlmanac.Ordered(dictionary));
			if ((int)Plugin.Session.Role == 3)
			{
				salvageModel.Errors.Insert(0, "Salvage files are read-only on remote clients.");
			}
			return salvageModel.Errors.AsReadOnly();
		}

		private static bool ApplyDocument(string name, string original, string text)
		{
			DocumentOwner();
			KindleAlmanac.Authority();
			long generation = Plugin.Session.Generation;
			Dictionary<string, string> dictionary = DiskDocuments();
			if (!dictionary.TryGetValue(name, out var value) || !string.Equals(value, original, StringComparison.Ordinal))
			{
				throw new InvalidOperationException("Salvage content changed; reload the document first.");
			}
			if (ValidateDocument(name, text).Count != 0)
			{
				return false;
			}
			string text2 = KindleAlmanac.SetHash(dictionary);
			string text3 = Path.Combine(Paths.ConfigPath, name);
			string text4 = KindleAlmanac.Temporary(text3, text);
			string text5 = KindleAlmanac.Backup(text3);
			bool flag = false;
			try
			{
				DocumentOwner();
				KindleAlmanac.Authority();
				if (Plugin.Session.Generation != generation || KindleAlmanac.SetHash(DiskDocuments()) != text2)
				{
					throw new InvalidOperationException("Salvage file-set or session changed during this edit.");
				}
				File.Replace(text4, text3, text5);
				flag = true;
				if (KindleAlmanac.ReadText(text3) != text)
				{
					throw new IOException("Salvage publication did not retain the requested text.");
				}
				Reload();
				if (!Ready || !Files.TryGetValue(name, out string value2) || value2 != text)
				{
					throw new InvalidOperationException("Salvage reload did not accept the requested file-set.");
				}
				return true;
			}
			catch (Exception ex)
			{
				if (flag)
				{
					try
					{
						DocumentOwner();
						KindleAlmanac.Authority();
						if (Plugin.Session.Generation != generation || KindleAlmanac.ReadText(text3) != text)
						{
							throw new InvalidOperationException("Current authority/content changed; rollback refused.");
						}
						string text6 = text3 + ".import-" + Guid.NewGuid().ToString("N") + ".tmp";
						try
						{
							File.Copy(text5, text6, overwrite: false);
							using (FileStream fileStream = new FileStream(text6, FileMode.Open, FileAccess.Write, FileShare.None))
							{
								fileStream.Flush(flushToDisk: true);
							}
							File.Replace(text6, text3, null);
							Reload();
						}
						finally
						{
							if (File.Exists(text6))
							{
								File.Delete(text6);
							}
						}
					}
					catch (Exception ex2)
					{
						throw new IOException("Salvage edit failed; rollback failed: " + ex2.GetBaseException().Message + ". Backup: " + text5, ex);
					}
				}
				throw new IOException("Salvage edit refused; backup: " + (flag ? text5 : "not written") + ". " + ex.GetBaseException().Message, ex);
			}
			finally
			{
				if (File.Exists(text4))
				{
					File.Delete(text4);
				}
			}
		}

		internal static void Shutdown()
		{
			foreach (IDisposable value in documents.Values)
			{
				value.Dispose();
			}
			documents.Clear();
			SynchronizationManager.OnConfigurationSynchronized -= Synchronized;
			initialized = (Ready = false);
			applied = null;
			carrier = null;
			synchronizedGeneration = (observedGeneration = -1L);
			syncReceipt = new KindleSyncReceipt();
			Files = new Dictionary<string, string>();
			SalvageRules.Apply(null);
		}
	}
	public sealed class YamlGroupTable
	{
		private readonly Dictionary<string, List<string>> members = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, List<string>> parents = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

		public IReadOnlyCollection<string> Names => members.Keys;

		public bool IsGroup(string name)
		{
			return members.ContainsKey(name);
		}

		public void Add(string group, IEnumerable<string> names)
		{
			if (!members.TryGetValue(group, out List<string> value))
			{
				value = new List<string>();
				members.Add(group, value);
			}
			foreach (string name in names)
			{
				value.Add(name);
				if (!parents.TryGetValue(name, out List<string> value2))
				{
					value2 = new List<string>();
					parents.Add(name, value2);
				}
				value2.Add(group);
			}
		}

		public IReadOnlyList<string> Resolve(string name)
		{
			List<string> list = new List<string>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			Queue<string> queue = new Queue<string>();
			queue.Enqueue(name);
			while (queue.Count > 0)
			{
				if (!parents.TryGetValue(queue.Dequeue(), out List<string> value))
				{
					continue;
				}
				foreach (string item in value)
				{
					if (hashSet.Add(item))
					{
						list.Add(item);
						queue.Enqueue(item);
					}
				}
			}
			return list;
		}

		public IReadOnlyList<string> Expand(string group)
		{
			List<string> result = new List<string>();
			HashSet<string> seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			Expand(group, seen, result);
			return result;
		}

		private void Expand(string name, HashSet<string> seen, List<string> result)
		{
			if (!seen.Add(name))
			{
				return;
			}
			if (!members.TryGetValue(name, out List<string> value))
			{
				result.Add(name);
				return;
			}
			foreach (string item in value)
			{
				Expand(item, seen, result);
			}
		}
	}
	public abstract class YamlModel
	{
		private static readonly IDeserializer Parser = new DeserializerBuilder().Build();

		private string? currentFile;

		public List<string> Errors { get; } = new List<string>();

		public List<string> Warnings { get; } = new List<string>();

		protected YamlGroupTable Groups { get; } = new YamlGroupTable();

		public void Load(string yamlText)
		{
			ReadText(yamlText);
			Verify();
		}

		public void LoadAll(IEnumerable<KeyValuePair<string, string>> files)
		{
			foreach (KeyValuePair<string, string> file in files)
			{
				currentFile = Path.GetFileName(file.Key);
				ReadText(file.Value);
			}
			currentFile = null;
			Verify();
		}

		public IReadOnlyList<string> ResolveGroups(string name)
		{
			return Groups.Resolve(name);
		}

		protected abstract void Read(YamlNode root);

		protected virtual void Verify()
		{
		}

		protected void ReadGroups(YamlNode root, string key = "groups")
		{
			foreach (KeyValuePair<string, YamlNode> entry in root.Get(key).Entries)
			{
				if (entry.Value.TryStringList(out List<string> items))
				{
					Groups.Add(entry.Key, items);
				}
			}
		}

		internal void AddError(string message)
		{
			Errors.Add(WithFile(message));
		}

		internal void AddWarning(string message)
		{
			Warnings.Add(WithFile(message));
		}

		private string WithFile(string message)
		{
			if (currentFile != null)
			{
				return currentFile + ": " + message;
			}
			return message;
		}

		private void ReadText(string yamlText)
		{
			if (TryParse(yamlText, out object graph) && graph != null)
			{
				if (!(graph is IDictionary<object, object>))
				{
					AddError("the file must be a map of keys at the top level, not " + ((graph is IList<object>) ? "a list" : "a single value"));
					return;
				}
				YamlNode yamlNode = new YamlNode(this, graph, "");
				Read(yamlNode);
				yamlNode.WarnUnknownKeys();
			}
		}

		private bool TryParse(string yamlText, out object? graph)
		{
			try
			{
				graph = Parser.Deserialize<object>(yamlText.TrimStart('\ufeff'));
				return true;
			}
			catch (Exception ex)
			{
				AddError("invalid YAML: " + ex.Message + ((ex.InnerException == null) ? "" : (" (" + ex.InnerException.Message + ")")));
				graph = null;
				return false;
			}
		}
	}
	public enum YamlNodeKind
	{
		Scalar,
		List,
		Map,
		Null,
		Missing
	}
	public sealed class YamlNode
	{
		private readonly YamlModel model;

		private readonly object? value;

		private List<KeyValuePair<string, YamlNode>>? mapEntries;

		private Dictionary<string, YamlNode>? mapLookup;

		private List<YamlNode>? listItems;

		private HashSet<string>? askedKeys;

		private bool visited;

		private bool shapeReported;

		public string Path { get; }

		public YamlNodeKind Kind { get; }

		public string? Text
		{
			get
			{
				if (Kind != YamlNodeKind.Scalar)
				{
					return null;
				}
				return Convert.ToString(value, CultureInfo.InvariantCulture);
			}
		}

		public int Count => Kind switch
		{
			YamlNodeKind.Map => MapEntries.Count, 
			YamlNodeKind.List => ListItems.Count, 
			_ => 0, 
		};

		public IReadOnlyList<KeyValuePair<string, YamlNode>> Entries
		{
			get
			{
				if (!ExpectShape(YamlNodeKind.Map, "a map"))
				{
					return Array.Empty<KeyValuePair<string, YamlNode>>();
				}
				visited = true;
				AskedKeys.UnionWith(MapEntries.Select<KeyValuePair<string, YamlNode>, string>((KeyValuePair<string, YamlNode> e) => e.Key));
				return MapEntries;
			}
		}

		public IReadOnlyList<YamlNode> Items
		{
			get
			{
				if (!ExpectShape(YamlNodeKind.List, "a list"))
				{
					return Array.Empty<YamlNode>();
				}
				return ListItems;
			}
		}

		private HashSet<string> AskedKeys => askedKeys ?? (askedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase));

		private List<KeyValuePair<string, YamlNode>> MapEntries
		{
			get
			{
				if (mapEntries == null)
				{
					BuildMap();
				}
				return mapEntries;
			}
		}

		private Dictionary<string, YamlNode> MapLookup
		{
			get
			{
				if (mapLookup == null)
				{
					BuildMap();
				}
				return mapLookup;
			}
		}

		private List<YamlNode> ListItems
		{
			get
			{
				if (listItems == null)
				{
					IList<object> source = (IList<object>)value;
					listItems = source.Select((object item, int i) => new YamlNode(model, item, $"{Path}[{i}]")).ToList();
				}
				return listItems;
			}
		}

		internal YamlNode(YamlModel model, object? value, string path, YamlNodeKind kind)
		{
			this.model = model;
			this.value = value;
			Path = path;
			Kind = kind;
		}

		internal YamlNode(YamlModel model, object? value, string path)
			: this(model, value, path, KindOf(value))
		{
		}

		public YamlNode Get(string key)
		{
			string path = (string.IsNullOrEmpty(Path) ? key : (Path + "." + key));
			if (!ExpectShape(YamlNodeKind.Map, "a map"))
			{
				return new YamlNode(model, null, path, YamlNodeKind.Missing);
			}
			visited = true;
			AskedKeys.Add(key);
			if (!MapLookup.TryGetValue(key, out YamlNode result))
			{
				return new YamlNode(model, null, path, YamlNodeKind.Missing);
			}
			return result;
		}

		public bool Is(string keyword)
		{
			if (Kind == YamlNodeKind.Scalar)
			{
				return string.Equals(Text.Trim(), keyword, StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		public void Error(string message)
		{
			model.AddError(Prefixed(message));
		}

		public void Warn(string message)
		{
			model.AddWarning(Prefixed(message));
		}

		public void WarnUnknownKeys()
		{
			if (Kind == YamlNodeKind.Map && visited)
			{
				List<string> list = (from e in MapEntries
					select e.Key into k
					where !AskedKeys.Contains(k)
					select k).ToList();
				if (list.Count > 0)
				{
					Warn("unknown keys " + string.Join(", ", list));
				}
				{
					foreach (KeyValuePair<string, YamlNode> mapEntry in MapEntries)
					{
						mapEntry.Value.WarnUnknownKeys();
					}
					return;
				}
			}
			if (Kind == YamlNodeKind.List && listItems != null)
			{
				listItems.ForEach(delegate(YamlNode item)
				{
					item.WarnUnknownKeys();
				});
			}
		}

		private string Prefixed(string message)
		{
			if (!string.IsNullOrEmpty(Path))
			{
				return Path + ": " + message;
			}
			return message;
		}

		private void BuildMap()
		{
			mapEntries = new List<KeyValuePair<string, YamlNode>>();
			mapLookup = new Dictionary<string, YamlNode>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<object, object> item in (IDictionary<object, object>)value)
			{
				string text = Convert.ToString(item.Key, CultureInfo.InvariantCulture) ?? "";
				string path = (string.IsNullOrEmpty(Path) ? text : (Path + "." + text));
				YamlNode yamlNode = new YamlNode(model, item.Value, path);
				if (mapLookup.ContainsKey(text))
				{
					yamlNode.Warn("duplicate key (differs only in case), ignored");
					continue;
				}
				mapLookup.Add(text, yamlNode);
				mapEntries.Add(new KeyValuePair<string, YamlNode>(text, yamlNode));
			}
		}

		private bool ExpectShape(YamlNodeKind wanted, string description)
		{
			if (Kind == wanted)
			{
				return true;
			}
			if (Kind != YamlNodeKind.Missing && !shapeReported)
			{
				shapeReported = true;
				Error((Kind == YamlNodeKind.Null) ? ("expected " + description + " but the key has no value") : ("expected " + description + ", found " + Describe(Kind)));
			}
			return false;
		}

		private static string Describe(YamlNodeKind kind)
		{
			return kind switch
			{
				YamlNodeKind.Scalar => "a single value", 
				YamlNodeKind.List => "a list", 
				YamlNodeKind.Map => "a map", 
				_ => "nothing", 
			};
		}

		private static YamlNodeKind KindOf(object? value)
		{
			if (value != null)
			{
				if (!(value is IDictionary<object, object>))
				{
					if (value is IList<object>)
					{
						return YamlNodeKind.List;
					}
					return YamlNodeKind.Scalar;
				}
				return YamlNodeKind.Map;
			}
			return YamlNodeKind.Null;
		}

		public bool TryInt(out int result)
		{
			return TryScalar<int>(out result);
		}

		public bool TryFloat(out float result)
		{
			return TryScalar<float>(out result);
		}

		public bool TryBool(out bool result)
		{
			return TryScalar<bool>(out result);
		}

		public bool TryString(out string result)
		{
			return TryScalar<string>(out result);
		}

		public bool TryEnum<T>(out T result) where T : struct, Enum
		{
			return TryScalar<T>(out result);
		}

		public bool TryList<T>(out List<T> items)
		{
			items = new List<T>();
			if (!ExpectShape(YamlNodeKind.List, "a list of " + YamlScalarParser.Plural<T>()))
			{
				return false;
			}
			bool result = true;
			foreach (YamlNode listItem in ListItems)
			{
				if (listItem.TryScalar<T>(out var result2))
				{
					items.Add(result2);
				}
				else
				{
					result = false;
				}
			}
			return result;
		}

		public bool TryStringList(out List<string> items)
		{
			if (Kind == YamlNodeKind.Scalar)
			{
				items = new List<string> { Text };
				return true;
			}
			return TryList(out items);
		}

		private bool TryScalar<T>(out T result)
		{
			result = default(T);
			if (!ExpectShape(YamlNodeKind.Scalar, YamlScalarParser.Describe(typeof(T))))
			{
				return false;
			}
			if (YamlScalarParser.TryParse(Text, typeof(T), out object result2))
			{
				result = (T)result2;
				return true;
			}
			Error("'" + Text + "' is not " + YamlScalarParser.Describe(typeof(T)));
			return false;
		}
	}
	internal static class YamlScalarParser
	{
		private static readonly string[] TrueWords = new string[4] { "true", "yes", "on", "1" };

		private static readonly string[] FalseWords = new string[4] { "false", "no", "off", "0" };

		public static bool TryParse(string text, Type type, out object? result)
		{
			string text2 = text.Trim();
			result = null;
			if (type == typeof(string))
			{
				result = text;
				return true;
			}
			if (type == typeof(int))
			{
				int result3;
				bool result2 = int.TryParse(text2, NumberStyles.Integer, CultureInfo.InvariantCulture, out result3);
				result = result3;
				return result2;
			}
			if (type == typeof(float))
			{
				float result5;
				bool result4 = float.TryParse(text2, NumberStyles.Float, CultureInfo.InvariantCulture, out result5);
				result = result5;
				return result4;
			}
			if (!(type == typeof(bool)))
			{
				return TryParseEnum(text2, type, out result);
			}
			return TryParseBool(text2, out result);
		}

		public static string Describe(Type type)
		{
			if (type == typeof(int))
			{
				return "an integer";
			}
			if (type == typeof(float))
			{
				return "a number";
			}
			if (type == typeof(bool))
			{
				return "true or false";
			}
			if (!type.IsEnum)
			{
				return "text";
			}
			return "one of " + string.Join(", ", Enum.GetNames(type));
		}

		public static string Plural<T>()
		{
			if (!(typeof(T) == typeof(int)))
			{
				if (!(typeof(T) == typeof(float)))
				{
					if (!(typeof(T) == typeof(bool)))
					{
						if (!typeof(T).IsEnum)
						{
							return "text values";
						}
						return "names (" + string.Join(", ", Enum.GetNames(typeof(T))) + ")";
					}
					return "true/false values";
				}
				return "numbers";
			}
			return "integers";
		}

		private static bool TryParseBool(string text, out object? result)
		{
			if (TrueWords.Contains<string>(text, StringComparer.OrdinalIgnoreCase))
			{
				result = true;
				return true;
			}
			result = false;
			return FalseWords.Contains<string>(text, StringComparer.OrdinalIgnoreCase);
		}

		private static bool TryParseEnum(string text, Type type, out object? result)
		{
			if (!type.IsEnum)
			{
				throw new NotSupportedException("YamlNode cannot read values of type " + type.Name);
			}
			string text2 = Enum.GetNames(type).FirstOrDefault((string n) => string.Equals(n, text, StringComparison.OrdinalIgnoreCase));
			result = ((text2 == null) ? null : Enum.Parse(type, text2));
			return text2 != null;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}