using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using InventoryUX.Core;
using InventoryUX.Runtime;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("CraftGuard")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.2.0")]
[assembly: AssemblyInformationalVersion("0.1.2+519a49c399d64d3275a092e9dfe269a0696aaf8b")]
[assembly: AssemblyProduct("CraftGuard")]
[assembly: AssemblyTitle("CraftGuard")]
[assembly: AssemblyVersion("0.1.2.0")]
[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 InventoryUX
{
	[BepInPlugin("com.inventoryux.valheim", "CraftGuard", "0.1.2")]
	public sealed class Plugin : BaseUnityPlugin
	{
		internal const string PluginGuid = "com.inventoryux.valheim";

		internal const string PluginName = "CraftGuard";

		internal const string PluginVersion = "0.1.2";

		private Harmony? _harmony;

		internal static ManualLogSource LogInstance { get; private set; }

		internal static Plugin Instance { get; private set; }

		private void Awake()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			Instance = this;
			LogInstance = ((BaseUnityPlugin)this).Logger;
			ModConfig.Bind(((BaseUnityPlugin)this).Config);
			_harmony = new Harmony("com.inventoryux.valheim");
			_harmony.PatchAll(typeof(Plugin).Assembly);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"CraftGuard 0.1.2 loaded. Undiscovered content is never rendered.");
		}

		private void Update()
		{
			if (ModConfig.Enabled.Value && ModConfig.WriteDataInventoryOnStartup.Value)
			{
				DataInventoryWriter.TryWriteOnce();
			}
		}

		private void OnDestroy()
		{
			HammerGroupDecorations.Shutdown();
			HammerGridSizer.Restore();
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
}
namespace InventoryUX.Runtime
{
	internal enum CraftingSection
	{
		Workbench,
		Forge,
		Cooking,
		Advanced,
		Processing,
		Utility
	}
	internal readonly struct CraftingPieceLayout
	{
		internal CraftingSection Section { get; }

		internal int SortOrder { get; }

		internal int Subgroup { get; }

		internal bool IsPrimaryStation { get; }

		internal CraftingPieceLayout(CraftingSection section, int sortOrder, int subgroup, bool isPrimaryStation = false)
		{
			Section = section;
			SortOrder = sortOrder;
			Subgroup = subgroup;
			IsPrimaryStation = isPrimaryStation;
		}
	}
	internal static class CraftingLayoutMetadata
	{
		private readonly struct PieceRule
		{
			internal CraftingPieceLayout Layout { get; }

			private string[] Markers { get; }

			internal PieceRule(CraftingPieceLayout layout, string[] markers)
			{
				Layout = layout;
				Markers = markers;
			}

			internal bool Matches(string id)
			{
				for (int i = 0; i < Markers.Length; i++)
				{
					if (id.Contains(Markers[i]))
					{
						return true;
					}
				}
				return false;
			}
		}

		private static readonly PieceRule[] Rules = new PieceRule[46]
		{
			Rule(CraftingSection.Workbench, 110, 0, "choppingblock"),
			Rule(CraftingSection.Workbench, 120, 0, "tanningrack"),
			Rule(CraftingSection.Workbench, 130, 0, "adze"),
			Rule(CraftingSection.Workbench, 140, 0, "toolshelf"),
			Rule(CraftingSection.Workbench, 100, 0, true, "workbench"),
			Rule(CraftingSection.Forge, 210, 0, "forgebellows", "bellows"),
			Rule(CraftingSection.Forge, 220, 0, "anvils"),
			Rule(CraftingSection.Forge, 230, 0, "grindingwheel"),
			Rule(CraftingSection.Forge, 240, 0, "smithsanvil"),
			Rule(CraftingSection.Forge, 250, 0, "forgecooler"),
			Rule(CraftingSection.Forge, 260, 0, "forgetoolrack", "toolrack"),
			Rule(CraftingSection.Forge, 100, 0, true, "forge"),
			Rule(CraftingSection.Cooking, 110, 0, "spicerack"),
			Rule(CraftingSection.Cooking, 120, 0, "butcherstable", "butchertable"),
			Rule(CraftingSection.Cooking, 130, 0, "potsandpans"),
			Rule(CraftingSection.Cooking, 140, 0, "mortarandpestle", "mortar"),
			Rule(CraftingSection.Cooking, 150, 0, "rollingpin", "cuttingboard"),
			Rule(CraftingSection.Cooking, 400, 3, true, "meadketill", "meadkettle", "ketill", "kettle"),
			Rule(CraftingSection.Cooking, 410, 3, "fermenter", "fermentationbarrel"),
			Rule(CraftingSection.Cooking, 100, 0, true, "cauldron"),
			Rule(CraftingSection.Cooking, 210, 1, "ironcookingstation", "cookingstationiron"),
			Rule(CraftingSection.Cooking, 200, 1, true, "cookingstation"),
			Rule(CraftingSection.Cooking, 300, 2, true, "foodpreparation", "foodprep", "preptable"),
			Rule(CraftingSection.Cooking, 310, 2, "stoneoven", "oven"),
			Rule(CraftingSection.Advanced, 110, 0, "artisanpress"),
			Rule(CraftingSection.Advanced, 100, 0, true, "artisantable", "artisan"),
			Rule(CraftingSection.Advanced, 210, 1, "blackforgecooler"),
			Rule(CraftingSection.Advanced, 200, 1, true, "blackforge"),
			Rule(CraftingSection.Advanced, 300, 2, "gemcutter"),
			Rule(CraftingSection.Advanced, 310, 2, "metalcutter"),
			Rule(CraftingSection.Advanced, 320, 2, "vice", "vise"),
			Rule(CraftingSection.Advanced, 410, 3, "unfadingcandles"),
			Rule(CraftingSection.Advanced, 420, 3, "featherywreath", "wreath"),
			Rule(CraftingSection.Advanced, 430, 3, "runetable"),
			Rule(CraftingSection.Advanced, 400, 3, true, "galdrtable", "galdr"),
			Rule(CraftingSection.Processing, 100, 0, "charcoalkiln", "kiln"),
			Rule(CraftingSection.Processing, 110, 0, "smelter"),
			Rule(CraftingSection.Processing, 120, 0, "blastfurnace"),
			Rule(CraftingSection.Processing, 130, 0, "windmill"),
			Rule(CraftingSection.Processing, 140, 0, "spinningwheel"),
			Rule(CraftingSection.Processing, 150, 0, "sapextractor", "sapcollector"),
			Rule(CraftingSection.Processing, 160, 0, "obliterator", "incinerator"),
			Rule(CraftingSection.Processing, 170, 0, "eitrrefinery", "refineryeitr"),
			Rule(CraftingSection.Utility, 100, 0, "stonecutter"),
			Rule(CraftingSection.Utility, 110, 0, "beehive"),
			Rule(CraftingSection.Utility, 120, 0, "wispfountain")
		};

		internal static CraftingPieceLayout Resolve(Piece piece)
		{
			string text = Normalize(HammerOrganizer.GetLabel(piece));
			string text2 = ((Localization.instance != null) ? Localization.instance.Localize(piece.m_name) : piece.m_name);
			string text3 = Normalize(text + " " + ((Object)((Component)piece).gameObject).name + " " + piece.m_name + " " + text2);
			if (ContainsAny(text3, "eitrrefinery", "refineryeitr"))
			{
				return ResolveWithin(text3, CraftingSection.Processing, 170, 0);
			}
			if (text.Contains("workbench"))
			{
				return ResolveWithin(text3, CraftingSection.Workbench, 900, 1);
			}
			if (text.Contains("artisan"))
			{
				return ResolveWithin(text3, CraftingSection.Advanced, 900, 0);
			}
			if (text.Contains("blackforge"))
			{
				return ResolveWithin(text3, CraftingSection.Advanced, 900, 1);
			}
			if (text.Contains("galdr"))
			{
				return ResolveWithin(text3, CraftingSection.Advanced, 900, 3);
			}
			if (text.Contains("forge"))
			{
				return ResolveWithin(text3, CraftingSection.Forge, 900, 1);
			}
			if (ContainsAny(text, "cauldron", "foodpreparation", "foodprep", "preptable", "cooking"))
			{
				return ResolveWithin(text3, CraftingSection.Cooking, 900, 3);
			}
			if (ContainsAny(text, "mead", "ketill", "kettle", "brewing"))
			{
				return ResolveWithin(text3, CraftingSection.Cooking, 900, 3);
			}
			for (int i = 0; i < Rules.Length; i++)
			{
				if (Rules[i].Matches(text3))
				{
					return Rules[i].Layout;
				}
			}
			return new CraftingPieceLayout(CraftingSection.Utility, 900, 9);
		}

		internal static string Label(CraftingSection section)
		{
			return section switch
			{
				CraftingSection.Workbench => "WORKBENCH", 
				CraftingSection.Forge => "FORGE", 
				CraftingSection.Cooking => "COOKING", 
				CraftingSection.Advanced => "ADVANCED", 
				CraftingSection.Processing => "PROCESSING", 
				_ => "UTILITY", 
			};
		}

		internal static bool IsRepair(Piece piece)
		{
			if (piece.m_repairPiece)
			{
				return true;
			}
			string text = Normalize(((Object)((Component)piece).gameObject).name);
			string text2 = Normalize(piece.m_name);
			switch (text)
			{
			default:
				if (!(text2 == "repair"))
				{
					return text2 == "piecerepair";
				}
				break;
			case "repair":
			case "piecerepair":
			case "hammerrepair":
			case "repairpiece":
				break;
			}
			return true;
		}

		private static CraftingPieceLayout ResolveWithin(string id, CraftingSection section, int fallbackOrder, int fallbackSubgroup)
		{
			for (int i = 0; i < Rules.Length; i++)
			{
				PieceRule pieceRule = Rules[i];
				if (pieceRule.Layout.Section == section && pieceRule.Matches(id))
				{
					return pieceRule.Layout;
				}
			}
			return new CraftingPieceLayout(section, fallbackOrder, fallbackSubgroup);
		}

		private static PieceRule Rule(CraftingSection section, int order, int subgroup, params string[] markers)
		{
			return new PieceRule(new CraftingPieceLayout(section, order, subgroup), markers);
		}

		private static PieceRule Rule(CraftingSection section, int order, int subgroup, bool primary, params string[] markers)
		{
			return new PieceRule(new CraftingPieceLayout(section, order, subgroup, primary), markers);
		}

		private static bool ContainsAny(string value, params string[] markers)
		{
			for (int i = 0; i < markers.Length; i++)
			{
				if (value.Contains(markers[i]))
				{
					return true;
				}
			}
			return false;
		}

		private static string Normalize(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			foreach (char c in value)
			{
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = char.ToLower(c, CultureInfo.InvariantCulture);
				}
			}
			return new string(array, 0, length);
		}
	}
	internal static class DataInventoryWriter
	{
		private static bool _written;

		internal static void TryWriteOnce()
		{
			if (_written || (Object)(object)ObjectDB.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			try
			{
				string text = Path.Combine(Paths.ConfigPath, "CraftGuard");
				Directory.CreateDirectory(text);
				string text2 = Path.Combine(text, "loaded-data-inventory.csv");
				File.WriteAllText(text2, BuildCsv(), new UTF8Encoding(encoderShouldEmitUTF8Identifier: true));
				_written = true;
				Plugin.LogInstance.LogInfo((object)("Wrote the loaded piece/recipe inventory to " + text2));
			}
			catch (Exception arg)
			{
				_written = true;
				Plugin.LogInstance.LogError((object)$"Could not write the data inventory: {arg}");
			}
		}

		private static string BuildCsv()
		{
			StringBuilder stringBuilder = new StringBuilder();
			WriteRow(stringBuilder, "ContentType", "PrefabID", "DisplayName", "KnownUnlockMechanism", "HammerCategory", "PieceType", "CraftingStation", "StationExtensionParent", "StationLevelContribution", "ItemType", "WeaponFamily", "ArmorType", "Recipe", "Ingredients", "RequiredStation", "RequiredStationLevel", "FoodHP", "FoodStamina", "FoodEitr", "FoodDuration", "FoodRegen", "ProposedGroup", "ProposedBiome", "ProposedSortOrder");
			WritePieces(stringBuilder);
			WriteRecipes(stringBuilder);
			return stringBuilder.ToString();
		}

		private static void WritePieces(StringBuilder output)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			List<GameObject> prefabs = ZNetScene.instance.m_prefabs;
			for (int i = 0; i < prefabs.Count; i++)
			{
				GameObject val = prefabs[i];
				if (!((Object)(object)val == (Object)null))
				{
					Piece component = val.GetComponent<Piece>();
					if (!((Object)(object)component == (Object)null) && hashSet.Add(((Object)val).name))
					{
						CraftingStation component2 = val.GetComponent<CraftingStation>();
						StationExtension component3 = val.GetComponent<StationExtension>();
						PieceGroup pieceGroup = HammerOrganizer.Classify(component, component.m_category);
						string text = (((Object)(object)component2 != (Object)null) ? "Crafting station" : (((Object)(object)component3 != (Object)null) ? "Station extension" : "Build piece"));
						WriteRow(output, "Piece", ((Object)val).name, Localize(component.m_name), "Piece.m_name in Player.m_knownRecipes", ((object)Unsafe.As<PieceCategory, PieceCategory>(ref component.m_category)/*cast due to .constrained prefix*/).ToString(), text, ((Object)(object)component.m_craftingStation != (Object)null) ? Localize(component.m_craftingStation.m_name) : (((Object)(object)component2 != (Object)null) ? Localize(component2.m_name) : string.Empty), ((Object)(object)component3 != (Object)null && (Object)(object)component3.m_craftingStation != (Object)null) ? Localize(component3.m_craftingStation.m_name) : string.Empty, ((Object)(object)component3 != (Object)null) ? "Native unique attached extension (+1)" : string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, FormatPieceIngredients(component), string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, pieceGroup.Label, string.Empty, $"{pieceGroup.Order}:{pieceGroup.Suborder}");
					}
				}
			}
		}

		private static void WriteRecipes(StringBuilder output)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			List<Recipe> recipes = ObjectDB.instance.m_recipes;
			for (int i = 0; i < recipes.Count; i++)
			{
				Recipe val = recipes[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.m_item == (Object)null))
				{
					SharedData shared = val.m_item.m_itemData.m_shared;
					RecipeFacts recipeFacts = ToFacts(val, i);
					RecipeGroup recipeGroup = (recipeFacts.IsFeast ? new RecipeGroup("Feasts", 4) : (recipeFacts.IsFood ? FoodClassifier.ToGroup(FoodClassifier.Classify(recipeFacts.Health, recipeFacts.Stamina, recipeFacts.Eitr)) : RecipeClassifier.GetTypeGroup(recipeFacts)));
					ProgressionBiome biome = BiomeClassifier.Classify(recipeFacts.Id, recipeFacts.IngredientIds);
					WriteRow(output, "Recipe", recipeFacts.Id, recipeFacts.DisplayName, "Player.GetAvailableRecipes / Player.IsRecipeKnown", string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, ((object)Unsafe.As<ItemType, ItemType>(ref shared.m_itemType)/*cast due to .constrained prefix*/).ToString(), ((object)Unsafe.As<SkillType, SkillType>(ref shared.m_skillType)/*cast due to .constrained prefix*/).ToString(), ArmorType(shared.m_itemType), ((Object)val).name, FormatRecipeIngredients(val), ((Object)(object)val.m_craftingStation != (Object)null) ? Localize(val.m_craftingStation.m_name) : string.Empty, val.m_minStationLevel.ToString(CultureInfo.InvariantCulture), shared.m_food.ToString(CultureInfo.InvariantCulture), shared.m_foodStamina.ToString(CultureInfo.InvariantCulture), shared.m_foodEitr.ToString(CultureInfo.InvariantCulture), shared.m_foodBurnTime.ToString(CultureInfo.InvariantCulture), shared.m_foodRegen.ToString(CultureInfo.InvariantCulture), recipeGroup.Label, biome.ToString(), $"{BiomeClassifier.ToGroup(biome).Order}:{recipeGroup.Order}");
				}
			}
		}

		private static RecipeFacts ToFacts(Recipe recipe, int originalIndex)
		{
			SharedData shared = recipe.m_item.m_itemData.m_shared;
			List<string> list = new List<string>();
			if (recipe.m_resources != null)
			{
				for (int i = 0; i < recipe.m_resources.Length; i++)
				{
					ItemDrop val = recipe.m_resources[i]?.m_resItem;
					if (!((Object)(object)val == (Object)null))
					{
						list.Add(((Object)((Component)val).gameObject).name);
						list.Add(val.m_itemData.m_shared.m_name);
					}
				}
			}
			ResolvedFoodStats resolvedFoodStats = FoodStatsResolver.Resolve(recipe.m_item);
			float health = (resolvedFoodStats.Resolved ? resolvedFoodStats.Health : shared.m_food);
			float stamina = (resolvedFoodStats.Resolved ? resolvedFoodStats.Stamina : shared.m_foodStamina);
			float eitr = (resolvedFoodStats.Resolved ? resolvedFoodStats.Eitr : shared.m_foodEitr);
			return new RecipeFacts(((Object)((Component)recipe.m_item).gameObject).name, Localize(shared.m_name), ((object)Unsafe.As<ItemType, ItemType>(ref shared.m_itemType)/*cast due to .constrained prefix*/).ToString(), ((object)Unsafe.As<SkillType, SkillType>(ref shared.m_skillType)/*cast due to .constrained prefix*/).ToString(), list, health, stamina, eitr, originalIndex, resolvedFoodStats.IsFeast);
		}

		private static string FormatPieceIngredients(Piece piece)
		{
			if (piece.m_resources == null)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			for (int i = 0; i < piece.m_resources.Length; i++)
			{
				Requirement val = piece.m_resources[i];
				if ((Object)(object)val?.m_resItem != (Object)null)
				{
					list.Add($"{Localize(val.m_resItem.m_itemData.m_shared.m_name)} x{val.m_amount}");
				}
			}
			return string.Join("; ", list);
		}

		private static string FormatRecipeIngredients(Recipe recipe)
		{
			if (recipe.m_resources == null)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			for (int i = 0; i < recipe.m_resources.Length; i++)
			{
				Requirement val = recipe.m_resources[i];
				if ((Object)(object)val?.m_resItem != (Object)null)
				{
					list.Add($"{Localize(val.m_resItem.m_itemData.m_shared.m_name)} x{val.m_amount}");
				}
			}
			return string.Join("; ", list);
		}

		private static string ArmorType(ItemType itemType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected I4, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			switch (itemType - 6)
			{
			default:
				if ((int)itemType != 17)
				{
					break;
				}
				return "Shoulder";
			case 0:
				return "Helmet";
			case 1:
				return "Chest";
			case 5:
				return "Legs";
			case 6:
				return "Hands";
			case 2:
			case 3:
			case 4:
				break;
			}
			return string.Empty;
		}

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

		private static void WriteRow(StringBuilder output, params string[] values)
		{
			for (int i = 0; i < values.Length; i++)
			{
				if (i > 0)
				{
					output.Append(',');
				}
				output.Append(Escape(values[i]));
			}
			output.AppendLine();
		}

		private static string Escape(string? value)
		{
			value = value ?? string.Empty;
			if (value.IndexOfAny(new char[4] { ',', '"', '\r', '\n' }) < 0)
			{
				return value;
			}
			return "\"" + value.Replace("\"", "\"\"") + "\"";
		}
	}
	internal static class FoodStatsResolver
	{
		private static readonly Dictionary<string, ItemDrop> CookedByInput = new Dictionary<string, ItemDrop>(StringComparer.Ordinal);

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

		private static int _sceneInstanceId = int.MinValue;

		private static int _scenePrefabCount = -1;

		internal static ResolvedFoodStats Resolve(ItemDrop output)
		{
			EnsureIndex();
			if (output == null || (Object)(object)output == (Object)null)
			{
				return default(ResolvedFoodStats);
			}
			Feast val = ((Component)output).GetComponent<Feast>() ?? ((Component)output).GetComponentInChildren<Feast>(true);
			ItemDrop val2 = (((Object)(object)val != (Object)null) ? GetFeastFood(val) : null);
			if ((Object)(object)val2 != (Object)null)
			{
				return FromItem(val2, resolved: true, isFeast: true);
			}
			string name = ((Object)((Component)output).gameObject).name;
			if (FeastFoodByInput.TryGetValue(name, out ItemDrop value) && (Object)(object)value != (Object)null)
			{
				return FromItem(value, resolved: true, isFeast: true);
			}
			ItemDrop val3 = output;
			bool resolved = false;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < 4; i++)
			{
				string name2 = ((Object)((Component)val3).gameObject).name;
				if (!hashSet.Add(name2) || !CookedByInput.TryGetValue(name2, out ItemDrop value2) || (Object)(object)value2 == (Object)null)
				{
					break;
				}
				val3 = value2;
				resolved = true;
			}
			return FromItem(val3, resolved, isFeast: false);
		}

		private static void EnsureIndex()
		{
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Invalid comparison between Unknown and I4
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null || instance.m_prefabs == null)
			{
				return;
			}
			int instanceID = ((Object)instance).GetInstanceID();
			int count = instance.m_prefabs.Count;
			if (_sceneInstanceId == instanceID && _scenePrefabCount == count)
			{
				return;
			}
			_sceneInstanceId = instanceID;
			_scenePrefabCount = count;
			CookedByInput.Clear();
			FeastFoodByInput.Clear();
			for (int i = 0; i < instance.m_prefabs.Count; i++)
			{
				GameObject val = instance.m_prefabs[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				CookingStation[] componentsInChildren = val.GetComponentsInChildren<CookingStation>(true);
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					List<ItemConversion> conversion = componentsInChildren[j].m_conversion;
					if (conversion == null)
					{
						continue;
					}
					for (int k = 0; k < conversion.Count; k++)
					{
						ItemConversion val2 = conversion[k];
						if (!((Object)(object)val2?.m_from == (Object)null) && !((Object)(object)val2.m_to == (Object)null))
						{
							string name = ((Object)((Component)val2.m_from).gameObject).name;
							if (!CookedByInput.ContainsKey(name))
							{
								CookedByInput.Add(name, val2.m_to);
							}
						}
					}
				}
				Feast[] componentsInChildren2 = val.GetComponentsInChildren<Feast>(true);
				foreach (Feast val3 in componentsInChildren2)
				{
					Piece val4 = ((Component)val3).GetComponent<Piece>() ?? ((Component)val3).GetComponentInParent<Piece>();
					ItemDrop feastFood = GetFeastFood(val3);
					if ((Object)(object)feastFood == (Object)null)
					{
						continue;
					}
					ItemDrop val5 = ((Component)val3).GetComponent<ItemDrop>() ?? ((Component)val3).GetComponentInParent<ItemDrop>();
					if ((Object)(object)val5 != (Object)null)
					{
						AddFeastMapping(((Object)((Component)val5).gameObject).name, feastFood);
					}
					ItemDrop component = val.GetComponent<ItemDrop>();
					if ((Object)(object)component != (Object)null)
					{
						AddFeastMapping(((Object)((Component)component).gameObject).name, feastFood);
					}
					if ((Object)(object)val4 == (Object)null || (int)val4.m_category != 5 || val4.m_resources == null)
					{
						continue;
					}
					for (int m = 0; m < val4.m_resources.Length; m++)
					{
						ItemDrop val6 = val4.m_resources[m]?.m_resItem;
						if (!((Object)(object)val6 == (Object)null))
						{
							AddFeastMapping(((Object)((Component)val6).gameObject).name, feastFood);
						}
					}
				}
			}
		}

		private static ItemDrop? GetFeastFood(Feast feast)
		{
			if ((Object)(object)feast.m_foodItem != (Object)null)
			{
				return feast.m_foodItem;
			}
			return ((Component)feast).GetComponent<ItemDrop>() ?? ((Component)feast).GetComponentInParent<ItemDrop>();
		}

		private static void AddFeastMapping(string inputId, ItemDrop feastFood)
		{
			if (!string.IsNullOrEmpty(inputId) && !FeastFoodByInput.ContainsKey(inputId))
			{
				FeastFoodByInput.Add(inputId, feastFood);
			}
		}

		private static ResolvedFoodStats FromItem(ItemDrop item, bool resolved, bool isFeast)
		{
			SharedData shared = item.m_itemData.m_shared;
			return new ResolvedFoodStats(shared.m_food, shared.m_foodStamina, shared.m_foodEitr, resolved, isFeast);
		}
	}
	internal readonly struct ResolvedFoodStats
	{
		internal float Health { get; }

		internal float Stamina { get; }

		internal float Eitr { get; }

		internal bool Resolved { get; }

		internal bool IsFeast { get; }

		internal ResolvedFoodStats(float health, float stamina, float eitr, bool resolved, bool isFeast)
		{
			Health = health;
			Stamina = stamina;
			Eitr = eitr;
			Resolved = resolved;
			IsFeast = isFeast;
		}
	}
	internal static class HammerGridDimensions
	{
		internal const int NativeWidth = 15;

		internal const int NativeHeight = 6;

		internal const int ExpandedWidth = 15;

		internal const int ExpandedHeight = 6;

		internal const float ReferenceCraftingRowScale = 1.1666666f;

		internal static int Width
		{
			get
			{
				if (!ModConfig.Enabled.Value)
				{
					return 15;
				}
				return 15;
			}
		}

		internal static int Height
		{
			get
			{
				if (!ModConfig.Enabled.Value)
				{
					return 6;
				}
				return 6;
			}
		}

		internal static int MaxX => Width - 1;

		internal static int MaxY => Height - 1;

		internal static float CraftingRowPitch(Hud hud)
		{
			return hud.m_pieceIconSpacing * 1.1666666f;
		}
	}
	internal static class HammerGridSizer
	{
		private sealed class RectState
		{
			private readonly RectTransform _rect;

			private readonly Vector2 _sizeDelta;

			private readonly Vector2 _anchoredPosition;

			internal RectState(RectTransform rect)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				_rect = rect;
				_sizeDelta = rect.sizeDelta;
				_anchoredPosition = rect.anchoredPosition;
			}

			internal void Restore()
			{
				//IL_0016: 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 (!((Object)(object)_rect == (Object)null))
				{
					_rect.sizeDelta = _sizeDelta;
					_rect.anchoredPosition = _anchoredPosition;
				}
			}
		}

		private sealed class ReparentedRectState
		{
			private readonly RectTransform _rect;

			private readonly Transform _parent;

			private readonly int _siblingIndex;

			private readonly Vector2 _anchorMin;

			private readonly Vector2 _anchorMax;

			private readonly Vector2 _pivot;

			private readonly Vector2 _sizeDelta;

			private readonly Vector2 _anchoredPosition;

			internal ReparentedRectState(RectTransform rect)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				_rect = rect;
				_parent = ((Transform)rect).parent;
				_siblingIndex = ((Transform)rect).GetSiblingIndex();
				_anchorMin = rect.anchorMin;
				_anchorMax = rect.anchorMax;
				_pivot = rect.pivot;
				_sizeDelta = rect.sizeDelta;
				_anchoredPosition = rect.anchoredPosition;
			}

			internal void Restore()
			{
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: 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_009d: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_rect == (Object)null) && !((Object)(object)_parent == (Object)null))
				{
					((Transform)_rect).SetParent(_parent, false);
					((Transform)_rect).SetSiblingIndex(Mathf.Min(_siblingIndex, _parent.childCount - 1));
					_rect.anchorMin = _anchorMin;
					_rect.anchorMax = _anchorMax;
					_rect.pivot = _pivot;
					_rect.sizeDelta = _sizeDelta;
					_rect.anchoredPosition = _anchoredPosition;
				}
			}
		}

		private static int _hudInstanceId = int.MinValue;

		private static RectState? _windowState;

		private static RectState? _maskState;

		private static RectState? _categoryState;

		private static ReparentedRectState? _previousCategoryControlState;

		internal static float RepairRailWidth { get; private set; }

		internal static void Apply(Hud hud)
		{
			//IL_00a8: 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_00d1: 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_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			int instanceID = ((Object)hud).GetInstanceID();
			if (_hudInstanceId != instanceID)
			{
				Restore();
				float pieceIconSpacing = hud.m_pieceIconSpacing;
				float num = 0f * pieceIconSpacing;
				float num2 = Mathf.Max(0f, 1f * pieceIconSpacing);
				RepairRailWidth = pieceIconSpacing + 28f;
				RectTransform val = (((Object)(object)hud.m_pieceSelectionWindow != (Object)null) ? hud.m_pieceSelectionWindow.GetComponent<RectTransform>() : null);
				if ((Object)(object)val != (Object)null)
				{
					_windowState = new RectState(val);
					ExpandCentered(val, num + RepairRailWidth, num2);
				}
				RectTransform pieceListMask = hud.m_pieceListMask;
				if ((Object)(object)pieceListMask != (Object)null)
				{
					_maskState = new RectState(pieceListMask);
					float widthDelta = (Mathf.Approximately(pieceListMask.anchorMin.x, pieceListMask.anchorMax.x) ? num : 0f);
					float heightDelta = (Mathf.Approximately(pieceListMask.anchorMin.y, pieceListMask.anchorMax.y) ? num2 : 0f);
					ExpandKeepingTopLeft(pieceListMask, widthDelta, heightDelta);
					pieceListMask.anchoredPosition += new Vector2(RepairRailWidth, 0f);
				}
				RectTransform val2 = (((Object)(object)hud.m_pieceCategoryRoot != (Object)null) ? hud.m_pieceCategoryRoot.GetComponent<RectTransform>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					_categoryState = new RectState(val2);
					val2.sizeDelta -= new Vector2(RepairRailWidth, 0f);
					val2.anchoredPosition += new Vector2(RepairRailWidth * (1f - val2.pivot.x), 0f);
					MovePreviousCategoryControl(val2, val, RepairRailWidth);
				}
				_hudInstanceId = instanceID;
			}
		}

		internal static void Restore()
		{
			_windowState?.Restore();
			_maskState?.Restore();
			_categoryState?.Restore();
			_previousCategoryControlState?.Restore();
			_windowState = null;
			_maskState = null;
			_categoryState = null;
			_previousCategoryControlState = null;
			_hudInstanceId = int.MinValue;
			RepairRailWidth = 0f;
		}

		private static void MovePreviousCategoryControl(RectTransform categoryRoot, RectTransform? window, float repairRailWidth)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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)
			if (!((Object)(object)window == (Object)null))
			{
				RectTransform val = FindInteractiveControl(categoryRoot, "Q") ?? FindInteractiveControl(window, "Q");
				if (!((Object)(object)val == (Object)null))
				{
					_previousCategoryControlState = new ReparentedRectState(val);
					((Transform)val).SetParent((Transform)(object)window, false);
					((Transform)val).SetAsLastSibling();
					val.anchorMin = new Vector2(0f, 1f);
					val.anchorMax = new Vector2(0f, 1f);
					val.pivot = new Vector2(0f, 1f);
					val.anchoredPosition = new Vector2(repairRailWidth + 42f, -18f);
				}
			}
		}

		private static RectTransform? FindInteractiveControl(RectTransform root, string displayedText)
		{
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (string.Equals(((TMP_Text)componentsInChildren[i]).text?.Trim(), displayedText, StringComparison.OrdinalIgnoreCase))
				{
					return InteractiveAncestor(root, ((TMP_Text)componentsInChildren[i]).transform);
				}
			}
			Text[] componentsInChildren2 = ((Component)root).GetComponentsInChildren<Text>(true);
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				if (string.Equals(componentsInChildren2[j].text?.Trim(), displayedText, StringComparison.OrdinalIgnoreCase))
				{
					return InteractiveAncestor(root, ((Component)componentsInChildren2[j]).transform);
				}
			}
			return null;
		}

		private static RectTransform? InteractiveAncestor(RectTransform root, Transform child)
		{
			Transform val = child;
			while ((Object)(object)val != (Object)(object)root && (Object)(object)val.parent != (Object)null)
			{
				if ((Object)(object)((Component)val).GetComponent<UIInputHandler>() != (Object)null || (Object)(object)((Component)val).GetComponent<Button>() != (Object)null)
				{
					return (RectTransform?)(object)((val is RectTransform) ? val : null);
				}
				val = val.parent;
			}
			return TopLevelChild(root, child);
		}

		private static RectTransform? TopLevelChild(RectTransform root, Transform child)
		{
			Transform val = child;
			while ((Object)(object)val.parent != (Object)null && (Object)(object)val.parent != (Object)(object)root)
			{
				val = val.parent;
			}
			if (!((Object)(object)val.parent == (Object)(object)root))
			{
				return null;
			}
			return (RectTransform?)(object)((val is RectTransform) ? val : null);
		}

		private static void ExpandCentered(RectTransform rect, float widthDelta, float heightDelta)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			rect.sizeDelta += new Vector2(widthDelta, heightDelta);
		}

		private static void ExpandKeepingTopLeft(RectTransform rect, float widthDelta, float heightDelta)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			rect.sizeDelta += new Vector2(widthDelta, heightDelta);
			rect.anchoredPosition += new Vector2(widthDelta * rect.pivot.x, (0f - heightDelta) * (1f - rect.pivot.y));
		}
	}
	internal static class HammerGroupDecorations
	{
		private readonly struct CraftingEntry
		{
			internal int PieceIndex { get; }

			internal CraftingPieceLayout Metadata { get; }

			internal string Name { get; }

			internal CraftingEntry(int pieceIndex, CraftingPieceLayout metadata, string name)
			{
				PieceIndex = pieceIndex;
				Metadata = metadata;
				Name = name;
			}
		}

		private sealed class CraftingLayoutResult
		{
			internal int[] Slots { get; }

			internal float[] XOffsets { get; }

			internal int RepairIndex { get; }

			internal CraftingSection?[] RowSections { get; }

			internal int[] Representatives { get; }

			internal List<SubgroupDivider> SubgroupBreaks { get; }

			internal int VisibleRows { get; }

			internal CraftingLayoutResult(int[] slots, float[] xOffsets, int repairIndex, CraftingSection?[] rowSections, int[] representatives, List<SubgroupDivider> subgroupBreaks, int visibleRows)
			{
				Slots = slots;
				XOffsets = xOffsets;
				RepairIndex = repairIndex;
				RowSections = rowSections;
				Representatives = representatives;
				SubgroupBreaks = subgroupBreaks;
				VisibleRows = visibleRows;
			}
		}

		private readonly struct SubgroupDivider
		{
			internal int Row { get; }

			internal int Column { get; }

			internal int GapCount { get; }

			internal SubgroupDivider(int row, int column, int gapCount)
			{
				Row = row;
				Column = column;
				GapCount = gapCount;
			}
		}

		private sealed class ShelfLayoutResult
		{
			internal int[] Slots { get; }

			internal float[] XPositions { get; }

			internal List<ShelfCard> Cards { get; }

			internal List<ShelfDivider> Dividers { get; }

			internal int VisibleRows { get; }

			internal float RowPitch { get; }

			internal int RepairIndex { get; }

			internal ShelfLayoutResult(int[] slots, float[] xPositions, List<ShelfCard> cards, List<ShelfDivider> dividers, int visibleRows, float rowPitch, int repairIndex)
			{
				Slots = slots;
				XPositions = xPositions;
				Cards = cards;
				Dividers = dividers;
				VisibleRows = visibleRows;
				RowPitch = rowPitch;
				RepairIndex = repairIndex;
			}
		}

		private readonly struct ShelfCard
		{
			internal int StartRow { get; }

			internal int RowSpan { get; }

			internal string Label { get; }

			internal int Representative { get; }

			internal ShelfCard(int startRow, int rowSpan, string label, int representative)
			{
				StartRow = startRow;
				RowSpan = rowSpan;
				Label = label;
				Representative = representative;
			}
		}

		private readonly struct ShelfDivider
		{
			internal int Row { get; }

			internal float X { get; }

			internal ShelfDivider(int row, float x)
			{
				Row = row;
				X = x;
			}
		}

		private readonly struct NativeBackgroundState
		{
			private Image Image { get; }

			private Color Color { get; }

			private bool RaycastTarget { get; }

			private RectTransform Rect { get; }

			private Vector2 SizeDelta { get; }

			private UIInputHandler? Input { get; }

			private bool InputEnabled { get; }

			internal NativeBackgroundState(Image image, Color color, bool raycastTarget, RectTransform rect, Vector2 sizeDelta, UIInputHandler? input, bool inputEnabled)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Image = image;
				Color = color;
				RaycastTarget = raycastTarget;
				Rect = rect;
				SizeDelta = sizeDelta;
				Input = input;
				InputEnabled = inputEnabled;
			}

			internal void SetHovered(bool hovered)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)Image == (Object)null))
				{
					Color color = Color;
					color.a = (hovered ? Mathf.Max(Color.a, 0.62f) : 0f);
					((Graphic)Image).color = color;
				}
			}

			internal void Restore()
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Image != (Object)null)
				{
					((Graphic)Image).color = Color;
					((Graphic)Image).raycastTarget = RaycastTarget;
				}
				if ((Object)(object)Rect != (Object)null)
				{
					Rect.sizeDelta = SizeDelta;
				}
				if ((Object)(object)Input != (Object)null)
				{
					((Behaviour)Input).enabled = InputEnabled;
				}
			}
		}

		private readonly struct GroupPalette
		{
			internal Color Text { get; }

			internal Color Background { get; }

			internal GroupPalette(Color text, Color background)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Text = text;
				Background = background;
			}
		}

		private const string Prefix = "InventoryUX_";

		private const int GridWidth = 15;

		private const int GridHeight = 6;

		private const int CategoryColumns = 3;

		private const int ShelfColumns = 15;

		private const int ShelfRows = 7;

		private const float CraftingColumnPitchScale = 0.95f;

		private const float ShelfColumnPitchScale = 0.93f;

		private const float CategoryRailScale = 0.9f;

		private const float CategoryToItemsGap = 14f;

		private const float SubgroupSpacing = 26.4f;

		private const float SubgroupLineInset = 19.8f;

		private const float TileInset = 3f;

		private const float LabelHeight = 14f;

		private const float ViewControlsHeight = 76f;

		private const float ViewButtonGap = 6f;

		private static readonly FieldInfo PieceIconsField = AccessTools.Field(typeof(Hud), "m_pieceIcons");

		private static readonly FieldInfo PlayerBuildPiecesField = AccessTools.Field(typeof(Player), "m_buildPieces");

		private static readonly MethodInfo UpdateAvailablePiecesMethod = AccessTools.Method(typeof(Player), "UpdateAvailablePiecesList", (Type[])null, (Type[])null);

		private static readonly MethodInfo HudUpdatePieceListMethod = AccessTools.Method(typeof(Hud), "UpdatePieceList", new Type[4]
		{
			typeof(Player),
			typeof(Vector2Int),
			typeof(PieceCategory),
			typeof(bool)
		}, (Type[])null);

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

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

		private static Type? _iconType;

		private static FieldInfo? _iconGoField;

		private static int[] _visualSlots = Array.Empty<int>();

		private static int _visualWidth = 15;

		private static int _visualHeight = 6;

		private static bool _stateValid;

		private static int _appliedHudId = int.MinValue;

		private static int _appliedSignature;

		private static PieceCategory _appliedCategory = (PieceCategory)8;

		private static int _repairLogicalIndex = -1;

		private static Piece? _repairPiece;

		private static GameObject? _persistentRepair;

		private static GameObject? _hiddenRepairRoot;

		private static int _repairHudId = int.MinValue;

		private static GameObject? _persistentViewControls;

		private static Image? _defaultViewBackground;

		private static Image? _modViewBackground;

		private static int _viewControlsHudId = int.MinValue;

		private static readonly GroupPalette[] FallbackPalettes = new GroupPalette[8]
		{
			Palette(0.88f, 0.69f, 0.39f, 0.5f, 0.34f, 0.14f),
			Palette(0.84f, 0.52f, 0.4f, 0.46f, 0.25f, 0.2f),
			Palette(0.62f, 0.76f, 0.53f, 0.28f, 0.42f, 0.24f),
			Palette(0.59f, 0.72f, 0.82f, 0.25f, 0.37f, 0.48f),
			Palette(0.71f, 0.63f, 0.81f, 0.35f, 0.29f, 0.44f),
			Palette(0.49f, 0.76f, 0.73f, 0.2f, 0.4f, 0.38f),
			Palette(0.82f, 0.68f, 0.48f, 0.45f, 0.34f, 0.21f),
			Palette(0.77f, 0.6f, 0.68f, 0.42f, 0.27f, 0.35f)
		};

		internal static bool UseModView { get; private set; } = true;

		internal static void Apply(Hud hud, IReadOnlyList<Piece> pieces, PieceCategory category)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Invalid comparison between Unknown and I4
			//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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Invalid comparison between Unknown and I4
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: 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)
			RemoveStaleRepairForDifferentHud(hud);
			EnsurePersistentViewControls(hud);
			UpdateRepairSelectionState();
			if (!IsEnabled(category))
			{
				Clear(hud, (int)category == 1);
				return;
			}
			IList list = (IList)PieceIconsField.GetValue(hud);
			int num = Math.Min(pieces.Count, list.Count);
			int num2 = ComputeSignature(pieces, list, num);
			if (_stateValid && _appliedHudId == ((Object)hud).GetInstanceID() && _appliedCategory == category && _appliedSignature == num2)
			{
				return;
			}
			Clear(hud);
			try
			{
				if ((int)category == 1 && CanUseReferenceCraftingLayout(pieces, num))
				{
					CraftingLayoutResult craftingLayoutResult = BuildCraftingLayout(pieces, num);
					_visualSlots = craftingLayoutResult.Slots;
					_repairLogicalIndex = craftingLayoutResult.RepairIndex;
					EnsurePersistentRepair(hud, pieces, list, craftingLayoutResult.RepairIndex);
					ApplyGridPermutation(hud, list, craftingLayoutResult, num);
					ConfigureNativePieceCells(list, num, craftingLayoutResult.Slots, craftingLayoutResult.RepairIndex);
					AddReferenceCraftingRows(hud, pieces, list, num, craftingLayoutResult);
					_visualWidth = 15;
					_visualHeight = 6;
					RememberState(hud, category, num2);
					return;
				}
				if ((int)category != 1 && CanUseShelfLayout(pieces, num))
				{
					ShelfLayoutResult shelfLayoutResult = BuildShelfLayout(hud, pieces, num, category);
					_visualSlots = shelfLayoutResult.Slots;
					_visualWidth = 15;
					_visualHeight = shelfLayoutResult.VisibleRows;
					_repairLogicalIndex = shelfLayoutResult.RepairIndex;
					if (shelfLayoutResult.RepairIndex >= 0)
					{
						EnsurePersistentRepair(hud, pieces, list, shelfLayoutResult.RepairIndex);
					}
					ConfigureNativePieceCells(list, num, shelfLayoutResult.Slots, shelfLayoutResult.RepairIndex);
					ApplyShelfPositions(hud, list, shelfLayoutResult, num);
					AddShelfRows(hud, pieces, list, num, shelfLayoutResult);
					RememberState(hud, category, num2);
					return;
				}
				string a = null;
				for (int i = 0; i < num; i++)
				{
					string text = HammerOrganizer.GetLabel(pieces[i]) ?? "Other";
					GroupPalette palette = GetPalette(category, text);
					bool flag = !string.Equals(a, text, StringComparison.Ordinal);
					GameObject iconGameObject = GetIconGameObject(list[i]);
					AddTileTint(iconGameObject, palette, flag);
					if (flag && !IsStandaloneAction(category, text))
					{
						AddLabel(hud, iconGameObject, CompactLabel(text), palette);
					}
					a = text;
				}
				RememberState(hud, category, num2);
			}
			catch
			{
				RemoveDecorations(hud, list);
				ResetState();
				throw;
			}
		}

		private static int ComputeSignature(IReadOnlyList<Piece> pieces, IList icons, int count)
		{
			int num = 17;
			num = num * 31 + count;
			num = num * 31 + icons.Count;
			num = num * 31 + (ModConfig.ShowSeparators.Value ? 1 : 0);
			num = num * 31 + (ModConfig.ShowHammerPieceNames.Value ? 1 : 0);
			if (icons.Count > 0)
			{
				num = num * 31 + ((Object)GetIconGameObject(icons[0])).GetInstanceID();
			}
			for (int i = 0; i < count; i++)
			{
				Piece val = pieces[i];
				num = num * 31 + ((Object)val).GetInstanceID();
				string text = HammerOrganizer.GetLabel(val) ?? string.Empty;
				num = num * 31 + text.GetHashCode();
			}
			return num;
		}

		private static void RememberState(Hud hud, PieceCategory category, int signature)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			_appliedHudId = ((Object)hud).GetInstanceID();
			_appliedCategory = category;
			_appliedSignature = signature;
			_stateValid = true;
		}

		private static void ResetState()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			_stateValid = false;
			_appliedHudId = int.MinValue;
			_appliedSignature = 0;
			_appliedCategory = (PieceCategory)8;
			_visualSlots = Array.Empty<int>();
			_visualWidth = 15;
			_visualHeight = 6;
			_repairLogicalIndex = -1;
		}

		internal static bool TryNavigate(PieceTable table, int horizontal, int vertical)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (_visualSlots.Length < 2 || table.GetSelectedCategory() != _appliedCategory)
			{
				return false;
			}
			Vector2Int selectedIndex = table.GetSelectedIndex();
			int num = ((Vector2Int)(ref selectedIndex)).y * 15 + ((Vector2Int)(ref selectedIndex)).x;
			if (num < 0 || num >= _visualSlots.Length)
			{
				return false;
			}
			int num2 = _visualSlots[num];
			if (num2 < 0)
			{
				int num3 = ((horizontal < 0 || vertical < 0) ? FindLastVisualPiece() : FindFirstVisualPiece());
				if (num3 >= 0)
				{
					SelectLogicalIndex(table, num3);
				}
				return true;
			}
			int num4 = num2 % _visualWidth;
			int num5 = num2 / _visualWidth;
			int num6 = -1;
			if (horizontal != 0)
			{
				int num7 = int.MaxValue;
				for (int i = 0; i < _visualSlots.Length; i++)
				{
					int num8 = _visualSlots[i];
					if (num8 < 0 || num8 / _visualWidth != num5)
					{
						continue;
					}
					int num9 = num8 % _visualWidth - num4;
					if ((horizontal >= 0 || num9 < 0) && (horizontal <= 0 || num9 > 0))
					{
						int num10 = Math.Abs(num9);
						if (num10 < num7)
						{
							num7 = num10;
							num6 = i;
						}
					}
				}
				if (num6 < 0 && horizontal < 0 && _repairLogicalIndex >= 0)
				{
					num6 = _repairLogicalIndex;
				}
				else if (num6 < 0)
				{
					int num11 = ((horizontal < 0) ? int.MinValue : int.MaxValue);
					for (int j = 0; j < _visualSlots.Length; j++)
					{
						int num12 = _visualSlots[j];
						if (num12 >= 0 && num12 / _visualWidth == num5)
						{
							int num13 = num12 % _visualWidth;
							if ((horizontal < 0 && num13 > num11) || (horizontal > 0 && num13 < num11))
							{
								num11 = num13;
								num6 = j;
							}
						}
					}
				}
			}
			else if (vertical != 0)
			{
				for (int k = 1; k < _visualHeight; k++)
				{
					if (num6 >= 0)
					{
						break;
					}
					int num14 = (num5 + vertical * k + _visualHeight * 2) % _visualHeight;
					int num15 = int.MaxValue;
					for (int l = 0; l < _visualSlots.Length; l++)
					{
						int num16 = _visualSlots[l];
						if (num16 >= 0 && num16 / _visualWidth == num14)
						{
							int num17 = Math.Abs(num16 % _visualWidth - num4);
							if (num17 < num15)
							{
								num15 = num17;
								num6 = l;
							}
						}
					}
				}
			}
			if (num6 >= 0 && num6 != num)
			{
				SelectLogicalIndex(table, num6);
			}
			return true;
		}

		private static void SelectLogicalIndex(PieceTable table, int logicalIndex)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			table.SetSelected(new Vector2Int(logicalIndex % 15, logicalIndex / 15));
		}

		private static int FindFirstVisualPiece()
		{
			int result = -1;
			int num = int.MaxValue;
			for (int i = 0; i < _visualSlots.Length; i++)
			{
				int num2 = _visualSlots[i];
				if (num2 >= 0 && num2 < num)
				{
					num = num2;
					result = i;
				}
			}
			return result;
		}

		private static int FindLastVisualPiece()
		{
			int result = -1;
			int num = int.MinValue;
			for (int i = 0; i < _visualSlots.Length; i++)
			{
				int num2 = _visualSlots[i];
				if (num2 > num)
				{
					num = num2;
					result = i;
				}
			}
			return result;
		}

		private static CraftingLayoutResult BuildCraftingLayout(IReadOnlyList<Piece> pieces, int count)
		{
			List<CraftingEntry>[] array = new List<CraftingEntry>[6];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new List<CraftingEntry>();
			}
			int repairIndex = -1;
			for (int j = 0; j < count; j++)
			{
				Piece val = pieces[j];
				if (CraftingLayoutMetadata.IsRepair(val))
				{
					repairIndex = j;
					continue;
				}
				CraftingPieceLayout metadata = CraftingLayoutMetadata.Resolve(val);
				array[(int)metadata.Section].Add(new CraftingEntry(j, metadata, Localize(val.m_name)));
			}
			for (int k = 0; k < array.Length; k++)
			{
				array[k].Sort(delegate(CraftingEntry left, CraftingEntry right)
				{
					int num11 = left.Metadata.SortOrder.CompareTo(right.Metadata.SortOrder);
					if (num11 != 0)
					{
						return num11;
					}
					num11 = string.Compare(left.Name, right.Name, StringComparison.CurrentCultureIgnoreCase);
					return (num11 == 0) ? left.PieceIndex.CompareTo(right.PieceIndex) : num11;
				});
			}
			int[] array2 = new int[count];
			for (int num = 0; num < array2.Length; num++)
			{
				array2[num] = -1;
			}
			float[] array3 = new float[count];
			bool[] array4 = new bool[90];
			CraftingSection?[] array5 = new CraftingSection?[6];
			int[] array6 = new int[6];
			for (int num2 = 0; num2 < array6.Length; num2++)
			{
				array6[num2] = -1;
			}
			List<SubgroupDivider> list = new List<SubgroupDivider>();
			List<int> list2 = new List<int>();
			int num3 = 0;
			for (int num4 = 0; num4 < array.Length; num4++)
			{
				if (num3 >= 6)
				{
					break;
				}
				List<CraftingEntry> list3 = array[num4];
				if (list3.Count == 0)
				{
					continue;
				}
				array5[num3] = (CraftingSection)num4;
				array6[num3] = FindCategoryRepresentative(list3, (CraftingSection)num4);
				int num5 = 3;
				int subgroup = list3[0].Metadata.Subgroup;
				int num6 = 0;
				for (int num7 = 0; num7 < list3.Count; num7++)
				{
					CraftingEntry craftingEntry = list3[num7];
					if (num7 > 0 && craftingEntry.Metadata.Subgroup != subgroup)
					{
						num6++;
						list.Add(new SubgroupDivider(num3, num5, num6));
					}
					if (num5 >= 15)
					{
						list2.Add(craftingEntry.PieceIndex);
					}
					else
					{
						int num8 = num3 * 15 + num5;
						array2[craftingEntry.PieceIndex] = num8;
						array3[craftingEntry.PieceIndex] = (float)num6 * 26.4f;
						array4[num8] = true;
						num5++;
					}
					subgroup = craftingEntry.Metadata.Subgroup;
				}
				num3++;
			}
			for (int num9 = 0; num9 < list2.Count; num9++)
			{
				int num10 = FirstFreePieceSlot(array4);
				if (num10 < 0)
				{
					break;
				}
				array2[list2[num9]] = num10;
				array4[num10] = true;
			}
			return new CraftingLayoutResult(array2, array3, repairIndex, array5, array6, list, num3);
		}

		private static bool CanUseShelfLayout(IReadOnlyList<Piece> pieces, int count)
		{
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				if (!CraftingLayoutMetadata.IsRepair(pieces[i]))
				{
					num++;
				}
			}
			if (num > 0)
			{
				return num <= 105;
			}
			return false;
		}

		private static ShelfLayoutResult BuildShelfLayout(Hud hud, IReadOnlyList<Piece> pieces, int count, PieceCategory category)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Invalid comparison between Unknown and I4
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int>(count);
			int repairIndex = -1;
			for (int i = 0; i < count; i++)
			{
				if (CraftingLayoutMetadata.IsRepair(pieces[i]))
				{
					repairIndex = i;
				}
				else
				{
					list.Add(i);
				}
			}
			string[] array = new string[list.Count];
			int[] array2 = new int[list.Count];
			int num = 0;
			int num2 = 0;
			string a = null;
			for (int j = 0; j < list.Count; j++)
			{
				Piece piece = pieces[list[j]];
				PieceGroup pieceGroup = HammerOrganizer.Classify(piece, category);
				string text = (array[j] = HammerOrganizer.GetLabel(piece) ?? pieceGroup.Label);
				array2[j] = pieceGroup.Suborder;
				if (j == 0 || string.Equals(a, text, StringComparison.Ordinal))
				{
					num2++;
				}
				else
				{
					num += Mathf.CeilToInt((float)num2 / 15f);
					num2 = 1;
				}
				a = text;
			}
			if (num2 > 0)
			{
				num += Mathf.CeilToInt((float)num2 / 15f);
			}
			int num3 = Mathf.Clamp(Mathf.Max(Mathf.CeilToInt((float)list.Count / 15f), num), 1, 7);
			List<int> list2 = (((int)category == 2) ? BuildMaterialRowSizes(array) : null);
			if (list2 != null)
			{
				num3 = list2.Count;
			}
			float pieceIconSpacing = hud.m_pieceIconSpacing;
			float rowPitch = ShelfRowPitch(hud, num3);
			float num4 = CategoryRailWidth(pieceIconSpacing) + 14f;
			float num5 = 14f * pieceIconSpacing;
			int[] array3 = new int[count];
			for (int k = 0; k < array3.Length; k++)
			{
				array3[k] = -1;
			}
			float[] array4 = new float[count];
			string[] array5 = new string[num3];
			int[] array6 = new int[num3];
			List<ShelfDivider> list3 = new List<ShelfDivider>();
			int num6 = 0;
			for (int l = 0; l < num3; l++)
			{
				int num7 = list2?[l] ?? ShelfRowPlanner.ChooseGroupRowSize(array, num6, 15, num3 - l);
				array5[l] = array[num6];
				array6[l] = list[num6];
				int num8 = 0;
				for (int m = 1; m < num7; m++)
				{
					if (IsShelfBreak(array, array2, num6 + m, category))
					{
						num8++;
					}
				}
				float num9 = pieceIconSpacing * 0.93f;
				if (num7 > 1)
				{
					float num10 = (num5 - num4 - (float)num8 * 26.4f) / (float)(num7 - 1);
					num9 = Mathf.Min(num9, num10);
				}
				int num11 = 0;
				for (int n = 0; n < num7; n++)
				{
					int index = num6 + n;
					int num12 = list[index];
					if (n > 0 && IsShelfBreak(array, array2, index, category))
					{
						num11++;
					}
					float num13 = num4 + (float)n * num9 + (float)num11 * 26.4f;
					if (n > 0 && IsShelfBreak(array, array2, index, category))
					{
						list3.Add(new ShelfDivider(l, num13 - 19.8f));
					}
					array3[num12] = l * 15 + n;
					array4[num12] = num13;
				}
				num6 += num7;
			}
			List<ShelfCard> cards = BuildShelfCards(pieces, list, array, array5, array6, category);
			return new ShelfLayoutResult(array3, array4, cards, list3, num3, rowPitch, repairIndex);
		}

		private static bool IsShelfBreak(string[] labels, int[] subgroups, int index, PieceCategory category)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			if (index <= 0 || index >= labels.Length)
			{
				return false;
			}
			if (!string.Equals(labels[index - 1], labels[index], StringComparison.Ordinal))
			{
				return true;
			}
			if ((int)category == 2 && string.Equals(Normalize(labels[index]), "corewood", StringComparison.Ordinal))
			{
				return false;
			}
			if ((int)category == 2)
			{
				return subgroups[index - 1] != subgroups[index];
			}
			return false;
		}

		private static List<int> BuildMaterialRowSizes(string[] labels)
		{
			List<int> list = new List<int>();
			int num = 0;
			while (num < labels.Length)
			{
				int i;
				for (i = num + 1; i < labels.Length && string.Equals(labels[num], labels[i], StringComparison.Ordinal); i++)
				{
				}
				int num2 = i - num;
				int num3 = Mathf.CeilToInt((float)num2 / 15f);
				for (int j = 0; j < num3; j++)
				{
					int num4 = Mathf.CeilToInt((float)num2 / (float)(num3 - j));
					list.Add(num4);
					num2 -= num4;
				}
				num = i;
			}
			return list;
		}

		private static List<ShelfCard> BuildShelfCards(IReadOnlyList<Piece> pieces, List<int> sourceIndices, string[] labels, string[] rowLabels, int[] representatives, PieceCategory category)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Invalid comparison between Unknown and I4
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			List<ShelfCard> list = new List<ShelfCard>();
			for (int i = 0; i < rowLabels.Length; i++)
			{
				string text = rowLabels[i];
				if (list.Count > 0 && string.Equals(list[list.Count - 1].Label, text, StringComparison.Ordinal))
				{
					ShelfCard shelfCard = list[list.Count - 1];
					list[list.Count - 1] = new ShelfCard(shelfCard.StartRow, shelfCard.RowSpan + 1, shelfCard.Label, shelfCard.Representative);
					continue;
				}
				int num = representatives[i];
				if ((int)category == 2)
				{
					num = FindBuildingBeamRepresentative(pieces, sourceIndices, labels, text, num);
				}
				else if ((int)category == 0 && string.Equals(Normalize(text), "utility", StringComparison.Ordinal))
				{
					num = FindCartographyRepresentative(pieces, sourceIndices, labels, text, num);
				}
				list.Add(new ShelfCard(i, 1, text, num));
			}
			return list;
		}

		private static int FindBuildingBeamRepresentative(IReadOnlyList<Piece> pieces, List<int> sourceIndices, string[] labels, string label, int fallback)
		{
			string text = Normalize(label);
			for (int i = 0; i < sourceIndices.Count; i++)
			{
				if (string.Equals(labels[i], label, StringComparison.Ordinal))
				{
					Piece val = pieces[sourceIndices[i]];
					string text2 = Normalize(((Object)((Component)val).gameObject).name + " " + val.m_name);
					if (text2.Contains("beam") && (!(text == "darkwood") || text2.Contains("darkwood")) && (!(text == "ashwood") || text2.Contains("grausten") || text2.Contains("ashwood") || text2.Contains("blackwood")) && (!(text == "corewood") || text2.Contains("corewood") || text2.Contains("log")) && (!(text == "wood") || (!text2.Contains("darkwood") && !text2.Contains("grausten") && !text2.Contains("ashwood") && !text2.Contains("corewood") && !text2.Contains("log"))))
					{
						return sourceIndices[i];
					}
				}
			}
			return fallback;
		}

		private static int FindCartographyRepresentative(IReadOnlyList<Piece> pieces, List<int> sourceIndices, string[] labels, string label, int fallback)
		{
			for (int i = 0; i < sourceIndices.Count; i++)
			{
				if (string.Equals(labels[i], label, StringComparison.Ordinal))
				{
					Piece val = pieces[sourceIndices[i]];
					string text = Normalize(((Object)((Component)val).gameObject).name + " " + val.m_name);
					if (text.Contains("cartography") || text.Contains("maptable"))
					{
						return sourceIndices[i];
					}
				}
			}
			return fallback;
		}

		private static float CategoryRailWidth(float spacing)
		{
			return (3f * spacing - 28f) * 0.9f;
		}

		private static float CraftingContentShift(float spacing)
		{
			return CategoryRailWidth(spacing) + 14f - 3f * spacing * 0.95f;
		}

		private static float ShelfRowPitch(Hud hud, int visibleRows)
		{
			if (visibleRows <= 6)
			{
				return hud.m_pieceIconSpacing * 1.1666666f;
			}
			return hud.m_pieceIconSpacing * 7f / (float)visibleRows;
		}

		private static int FindCategoryRepresentative(List<CraftingEntry> entries, CraftingSection section)
		{
			int num = 100;
			for (int i = 0; i < entries.Count; i++)
			{
				if (entries[i].Metadata.SortOrder == num)
				{
					return entries[i].PieceIndex;
				}
			}
			return entries[0].PieceIndex;
		}

		private static bool CanUseReferenceCraftingLayout(IReadOnlyList<Piece> pieces, int count)
		{
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				if (!CraftingLayoutMetadata.IsRepair(pieces[i]))
				{
					num++;
				}
			}
			if (num > 0)
			{
				return num <= 72;
			}
			return false;
		}

		private static int FirstFreePieceSlot(bool[] used)
		{
			for (int i = 0; i < 6; i++)
			{
				for (int j = 3; j < 15; j++)
				{
					int num = i * 15 + j;
					if (!used[num])
					{
						return num;
					}
				}
			}
			return -1;
		}

		private static void AddReferenceCraftingRows(Hud hud, IReadOnlyList<Piece> pieces, IList icons, int count, CraftingLayoutResult layout)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			RectTransform templateRect = (RectTransform)GetIconGameObject(icons[0]).transform;
			for (int i = 0; i < count; i++)
			{
				if (i != layout.RepairIndex && layout.Slots[i] >= 0 && ModConfig.ShowHammerPieceNames.Value)
				{
					AddReferenceTile(hud, GetIconGameObject(icons[i]), pieces[i]);
				}
			}
			for (int j = 0; j < layout.VisibleRows; j++)
			{
				if (j < layout.VisibleRows - 1 && ModConfig.ShowSeparators.Value)
				{
					AddRowSeparator(hud, templateRect, j);
				}
				CraftingSection? craftingSection = layout.RowSections[j];
				int num = layout.Representatives[j];
				if (craftingSection.HasValue && num >= 0)
				{
					AddCategoryCard(hud, templateRect, j, craftingSection.Value, pieces[num]);
				}
			}
			if (ModConfig.ShowSeparators.Value)
			{
				for (int k = 0; k < layout.SubgroupBreaks.Count; k++)
				{
					AddSubgroupSeparator(hud, templateRect, layout.SubgroupBreaks[k]);
				}
			}
		}

		private static void AddShelfRows(Hud hud, IReadOnlyList<Piece> pieces, IList icons, int count, ShelfLayoutResult layout)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			RectTransform templateRect = (RectTransform)GetIconGameObject(icons[0]).transform;
			for (int i = 0; i < count; i++)
			{
				if (layout.Slots[i] >= 0 && ModConfig.ShowHammerPieceNames.Value)
				{
					AddReferenceTile(hud, GetIconGameObject(icons[i]), pieces[i]);
				}
			}
			for (int j = 0; j < layout.VisibleRows; j++)
			{
				if (j >= layout.VisibleRows - 1 || !ModConfig.ShowSeparators.Value)
				{
					continue;
				}
				bool flag = false;
				for (int k = 0; k < layout.Cards.Count; k++)
				{
					if (layout.Cards[k].StartRow == j + 1)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					AddRowSeparator(hud, templateRect, j, layout.RowPitch, 0f);
				}
			}
			for (int l = 0; l < layout.Cards.Count; l++)
			{
				ShelfCard shelfCard = layout.Cards[l];
				AddCategoryCard(hud, templateRect, shelfCard.StartRow, layout.RowPitch, shelfCard.Label, pieces[shelfCard.Representative], shelfCard.RowSpan);
			}
			if (ModConfig.ShowSeparators.Value)
			{
				for (int m = 0; m < layout.Dividers.Count; m++)
				{
					AddShelfDivider(hud, templateRect, layout.Dividers[m], layout.RowPitch);
				}
			}
		}

		private static void AddReferenceTile(Hud hud, GameObject iconRoot, Piece piece)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_00b0: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InventoryUX_CraftingPieceName", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val.transform.SetParent(iconRoot.transform, false);
			val.transform.SetAsLastSibling();
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(0f, 0f);
			val2.anchorMax = new Vector2(1f, 0f);
			val2.pivot = new Vector2(0.5f, 0f);
			val2.anchoredPosition = new Vector2(0f, 3f);
			val2.sizeDelta = new Vector2(-8f, 27f);
			TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = Localize(piece.m_name);
			((TMP_Text)component).font = (((Object)(object)hud.m_pieceDescription != (Object)null) ? hud.m_pieceDescription.font : null);
			((TMP_Text)component).fontSize = 10.6f;
			((TMP_Text)component).fontSizeMin = 8.6f;
			((TMP_Text)component).fontSizeMax = 10.6f;
			((TMP_Text)component).enableAutoSizing = true;
			((TMP_Text)component).fontStyle = (FontStyles)1;
			((Graphic)component).color = new Color(0.96f, 0.88f, 0.72f, 1f);
			((TMP_Text)component).alignment = (TextAlignmentOptions)1026;
			((TMP_Text)component).textWrappingMode = (TextWrappingModes)1;
			((TMP_Text)component).overflowMode = (TextOverflowModes)1;
			((TMP_Text)component).maxVisibleLines = 2;
			((TMP_Text)component).outlineWidth = 0.22f;
			((TMP_Text)component).outlineColor = new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue);
			((Graphic)component).raycastTarget = false;
		}

		private static void AddCategoryCard(Hud hud, RectTransform templateRect, int row, CraftingSection section, Piece representative)
		{
			AddCategoryCard(hud, templateRect, row, HammerGridDimensions.CraftingRowPitch(hud), CraftingLayoutMetadata.Label(section), representative);
		}

		private static void AddCategoryCard(Hud hud, RectTransform templateRect, int row, float rowPitch, string text, Piece representative, int rowSpan = 1)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			float pieceIconSpacing = hud.m_pieceIconSpacing;
			GameObject val = new GameObject("InventoryUX_CraftingCategory_" + row, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent((Transform)(object)hud.m_pieceListRoot, false);
			val.transform.SetAsLastSibling();
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = templateRect.anchorMin;
			val2.anchorMax = templateRect.anchorMax;
			val2.pivot = templateRect.pivot;
			val2.anchoredPosition = new Vector2(0f, (float)(-row) * rowPitch);
			val2.sizeDelta = new Vector2(CategoryRailWidth(pieceIconSpacing), rowPitch * (float)rowSpan - 7f);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(0.075f, 0.048f, 0.027f, 0.91f);
			((Graphic)component).raycastTarget = false;
			AddOutline((Transform)(object)val2, "InventoryUX_CraftingCategoryBorder", 0f, new Color(0.66f, 0.49f, 0.25f, 0.54f));
			GameObject val3 = new GameObject("InventoryUX_CraftingCategoryIcon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val3.transform.SetParent((Transform)(object)val2, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = new Vector2(0f, 0.5f);
			val4.anchorMax = new Vector2(0f, 0.5f);
			val4.pivot = new Vector2(0f, 0.5f);
			val4.anchoredPosition = new Vector2(8f, 0f);
			val4.sizeDelta = new Vector2(56f, 56f);
			Image component2 = val3.GetComponent<Image>();
			component2.sprite = representative.m_icon;
			component2.preserveAspect = true;
			((Graphic)component2).color = Color.white;
			((Graphic)component2).raycastTarget = false;
			GameObject val5 = new GameObject("InventoryUX_CraftingCategoryLabel", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val5.transform.SetParent((Transform)(object)val2, false);
			RectTransform val6 = (RectTransform)val5.transform;
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = new Vector2(66f, 6f);
			val6.offsetMax = new Vector2(-7f, -6f);
			TextMeshProUGUI component3 = val5.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component3).text = text.ToUpperInvariant();
			((TMP_Text)component3).font = (((Object)(object)hud.m_pieceDescription != (Object)null) ? hud.m_pieceDescription.font : null);
			((TMP_Text)component3).fontSize = 12.8f;
			((TMP_Text)component3).fontSizeMin = 9.5f;
			((TMP_Text)component3).fontSizeMax = 12.8f;
			((TMP_Text)component3).enableAutoSizing = true;
			((TMP_Text)component3).fontStyle = (FontStyles)1;
			((Graphic)component3).color = new Color(0.84f, 0.69f, 0.43f, 1f);
			((TMP_Text)component3).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)component3).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)component3).overflowMode = (TextOverflowModes)1;
			((TMP_Text)component3).outlineWidth = 0.12f;
			((TMP_Text)component3).outlineColor = new Color32((byte)18, (byte)12, (byte)8, (byte)245);
			((Graphic)component3).raycastTarget = false;
		}

		private static void AddRowSeparator(Hud hud, RectTransform templateRect, int row)
		{
			AddRowSeparator(hud, templateRect, row, HammerGridDimensions.CraftingRowPitch(hud));
		}

		private static void AddRowSeparator(Hud hud, RectTransform templateRect, int row, float rowPitch)
		{
			AddRowSeparator(hud, templateRect, row, rowPitch, 0f);
		}

		private static void AddRowSeparator(Hud hud, RectTransform templateRect, int row, float rowPitch, float startX)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			float pieceIconSpacing = hud.m_pieceIconSpacing;
			GameObject val = new GameObject("InventoryUX_CraftingRowSeparator_" + row, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent((Transform)(object)hud.m_pieceListRoot, false);
			val.transform.SetAsLastSibling();
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = templateRect.anchorMin;
			val2.anchorMax = templateRect.anchorMax;
			val2.pivot = new Vector2(0f, 0.5f);
			val2.anchoredPosition = new Vector2(startX, (0f - ((float)row + 1f)) * rowPitch + 3.5f);
			val2.sizeDelta = new Vector2(15f * pieceIconSpacing - 9f - startX, 1f);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(0.57f, 0.4f, 0.19f, 0.34f);
			((Graphic)component).raycastTarget = false;
		}

		private static void AddSubgroupSeparator(Hud hud, RectTransform templateRect, SubgroupDivider divider)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			float pieceIconSpacing = hud.m_pieceIconSpacing;
			float num = pieceIconSpacing * 0.95f;
			float num2 = HammerGridDimensions.CraftingRowPitch(hud);
			float num3 = (float)divider.Column * num + CraftingContentShift(pieceIconSpacing) + (float)divider.GapCount * 26.4f;
			GameObject val = new GameObject("InventoryUX_CraftingSubgroupSeparator_" + divider.Row + "_" + divider.Column, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent((Transform)(object)hud.m_pieceListRoot, false);
			val.transform.SetAsLastSibling();
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = templateRect.anchorMin;
			val2.anchorMax = templateRect.anchorMax;
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = new Vector2(num3 - 19.8f, (float)(-divider.Row) * num2 - num2 * 0.5f);
			val2.sizeDelta = new Vector2(1f, num2 - 20f);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(0.62f, 0.47f, 0.25f, 0.42f);
			((Graphic)component).raycastTarget = false;
		}

		private static void AddShelfDivider(Hud hud, RectTransform templateRect, ShelfDivider divider, float rowPitch)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InventoryUX_CraftingShelfDivider_" + divider.Row + "_" + divider.X, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent((Transform)(object)hud.m_pieceListRoot, false);
			val.transform.SetAsLastSibling();
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = templateRect.anchorMin;
			val2.anchorMax = templateRect.anchorMax;
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = new Vector2(divider.X, (float)(-divider.Row) * rowPitch - rowPitch * 0.5f);
			val2.sizeDelta = new Vector2(1f, rowPitch - 20f);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(0.62f, 0.47f, 0.25f, 0.42f);
			((Graphic)component).raycastTarget = false;
		}

		private static void ConfigureNativePieceCells(IList icons, int occupiedCount, int[] slots, int repairIndex)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			for (int i = 0; i < icons.Count; i++)
			{
				GameObject iconGameObject = GetIconGameObject(icons[i]);
				Image component = iconGameObject.GetComponent<Image>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				UIInputHandler component2 = iconGameObject.GetComponent<UIInputHandler>();
				int instanceID = ((Object)component).GetInstanceID();
				if (!NativeBackgrounds.ContainsKey(instanceID))
				{
					NativeBackgrounds[instanceID] = new NativeBackgroundState(component, ((Graphic)component).color, ((Graphic)component).raycastTarget, (RectTransform)iconGameObject.transform, ((RectTransform)iconGameObject.transform).sizeDelta, component2, (Object)(object)component2 != (Object)null && ((Behaviour)component2).enabled);
				}
				bool flag = i < occupiedCount && i < slots.Length && slots[i] >= 0 && i != repairIndex;
				Color color = ((Graphic)component).color;
				color.a = 0f;
				((Graphic)component).color = color;
				((Graphic)component).raycastTarget = flag;
				if ((Object)(object)component2 != (Object)null)
				{
					((Behaviour)component2).enabled = flag;
					if (flag && !HoverInputs.ContainsKey(((Object)component2).GetInstanceID()))
					{
						component2.m_onPointerEnter = (Action<UIInputHandler>)Delegate.Combine(component2.m_onPointerEnter, new Action<UIInputHandler>(OnPieceHoverEnter));
						component2.m_onPointerExit = (Action<UIInputHandler>)Delegate.Combine(component2.m_onPointerExit, new Action<UIInputHandler>(OnPieceHoverExit));
						HoverInputs[((Object)component2).GetInstanceID()] = component2;
					}
				}
			}
		}

		private static void OnPieceHoverEnter(UIInputHandler input)
		{
			Image val = (((Object)(object)input != (Object)null) ? ((Component)input).GetComponent<Image>() : null);
			if (!((Object)(object)val == (Object)null) && NativeBackgrounds.TryGetValue(((Object)val).GetInstanceID(), out var value))
			{
				value.SetHovered(hovered: true);
			}
		}

		private static void OnPieceHoverExit(UIInputHandler input)
		{
			Image val = (((Object)(object)input != (Object)null) ? ((Component)input).GetComponent<Image>() : null);
			if (!((Object)(object)val == (Object)null) && NativeBackgrounds.TryGetValue(((Object)val).GetInstanceID(), out var value))
			{
				value.SetHovered(hovered: false);
			}
		}

		private static void RestoreNativeCraftingCells()
		{
			foreach (KeyValuePair<int, UIInputHandler> hoverInput in HoverInputs)
			{
				UIInputHandler value = hoverInput.Value;
				if (!((Object)(object)value == (Object)null))
				{
					value.m_onPointerEnter = (Action<UIInputHandler>)Delegate.Remove(value.m_onPointerEnter, new Action<UIInputHandler>(OnPieceHoverEnter));
					value.m_onPointerExit = (Action<UIInputHandler>)Delegate.Remove(value.m_onPointerExit, new Action<UIInputHandler>(OnPieceHoverExit));
				}
			}
			HoverInputs.Clear();
			foreach (KeyValuePair<int, NativeBackgroundState> nativeBackground in NativeBackgrounds)
			{
				nativeBackground.Value.Restore();
			}
			NativeBackgrounds.Clear();
		}

		private static void EnsurePersistentRepair(Hud hud, IReadOnlyList<Piece> pieces, IList icons, int repairIndex)
		{
			if (repairIndex < 0 || repairIndex >= pieces.Count || repairIndex >= icons.Count)
			{
				DestroyPersistentRepair();
				return;
			}
			Piece val = pieces[repairIndex];
			if ((Object)(object)_persistentRepair == (Object)null || _repairHudId != ((Object)hud).GetInstanceID() || (Object)(object)_repairPiece == (Object)null || ((Object)_repairPiece).GetInstanceID() != ((Object)val).GetInstanceID())
			{
				DestroyPersistentRepair();
				_persistentRepair = Object.Instantiate<GameObject>(GetIconGameObject(icons[repairIndex]), hud.m_pieceSelectionWindow.transform);
				((Object)_persistentRepair).name = "InventoryUX_PersistentRepair";
				_repairHudId = ((Object)hud).GetInstanceID();
				_repairPiece = val;
				ConfigurePersistentRepair(hud, _persistentRepair, val);
			}
			_hiddenRepairRoot = GetIconGameObject(icons[repairIndex]);
			_hiddenRepairRoot.SetActive(false);
			_persistentRepair.SetActive(true);
			UpdateRepairSelectionState();
		}

		private static void EnsurePersistentViewControls(Hud hud)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			if ((Object)(object)_persistentViewControls == (Object)null || _viewControlsHudId != ((Object)hud).GetInstanceID())
			{
				DestroyPersistentViewControls();
				GameObject val = new GameObject("InventoryUX_PersistentViewControls", new Type[1] { typeof(RectTransform) });
				val.transform.SetParent(hud.m_pieceSelectionWindow.transform, false);
				val.transform.SetAsLastSibling();
				RectTransform val2 = (RectTransform)val.transform;
				val2.anchorMin = new Vector2(0f, 1f);
				val2.anchorMax = new Vector2(0f, 1f);
				val2.pivot = new Vector2(0f, 1f);
				val2.anchoredPosition = new Vector2(18f, 0f - (hud.m_pieceIconSpacing + 49f));
				val2.sizeDelta = new Vector2(hud.m_pieceIconSpacing + 8f, 76f);
				_defaultViewBackground = CreateViewButton(hud, val2, "DEFAULT VIEW", 0, useModView: false);
				_modViewBackground = CreateViewButton(hud, val2, "MOD VIEW", 1, useModView: true);
				_persistentViewControls = val;
				_viewControlsHudId = ((Object)hud).GetInstanceID();
			}
			_persistentViewControls.SetActive(true);
			_persistentViewControls.transform.SetAsLastSibling();
			UpdateViewButtonState();
		}

		private static Image CreateViewButton(Hud hud, RectTransform parent, string caption, int index, bool useModView)
		{
			//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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			float num = 35f;
			GameObject val = new GameObject("InventoryUX_" + (useModView ? "ModView" : "DefaultView"), new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent((Transform)(object)parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			val2.anchoredPosition = new Vector2(0f, (float)(-index) * (num + 6f));
			val2.sizeDelta = new Vector2(0f, num);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(0.09f, 0.055f, 0.03f, 0.94f);
			((Graphic)component).raycastTarget = true;
			AddOutline((Transform)(object)val2, "InventoryUX_ViewButtonBorder", 1f, new Color(0.68f, 0.5f, 0.25f, 0.68f));
			Button component2 = val.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((Selectable)component2).transition = (Transition)0;
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				SetHammerView(hud, useModView);
			});
			GameObject val3 = new GameObject("InventoryUX_ViewButtonLabel", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val3.transform.SetParent((Transform)(object)val2, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = new Vector2(4f, 2f);
			val4.offsetMax = new Vector2(-4f, -2f);
			TextMeshProUGUI component3 = val3.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component3).text = caption;
			((TMP_Text)component3).font = (((Object)(object)hud.m_pieceDescription != (Object)null) ? hud.m_pieceDescription.font : null);
			((TMP_Text)component3).fontSize = 9.5f;
			((TMP_Text)component3).fontSizeMin = 7f;
			((TMP_Text)component3).fontSizeMax = 9.5f;
			((TMP_Text)component3).enableAutoSizing = true;
			((TMP_Text)component3).fontStyle = (FontStyles)1;
			((Graphic)component3).color = new Color(0.94f, 0.83f, 0.64f, 1f);
			((TMP_Text)component3).alignment = (TextAlignmentOptions)514;
			((TMP_Text)component3).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)component3).overflowMode = (TextOverflowModes)1;
			((TMP_Text)component3).outlineWidth = 0.16f;
			((TMP_Text)component3).outlineColor = Color32.op_Implicit(Color.black);
			((Graphic)component3).raycastTarget = false;
			return component;
		}

		private static void SetHammerView(Hud hud, bool useModView)
		{
			//IL_0068: 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)
			if (UseModView == useModView)
			{
				return;
			}
			UseModView = useModView;
			Clear(hud, removePersistentRepair: true);
			UpdateViewButtonState();
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			try
			{
				UpdateAvailablePiecesMethod.Invoke(localPlayer, null);
				object? value = PlayerBuildPiecesField.GetValue(localPlayer);
				PieceTable val = (PieceTable)((value is PieceTable) ? value : null);
				if (!((Object)(object)val == (Object)null))
				{
					HudUpdatePieceListMethod.Invoke(hud, new object[4]
					{
						localPlayer,
						val.GetSelectedIndex(),
						val.GetSelectedCategory(),
						true
					});
				}
			}
			catch (Exception arg)
			{
				Plugin.LogInstance.LogWarning((object)$"Hammer view switch failed: {arg}");
			}
		}

		private static void UpdateViewButtonState()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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)
			Color val = default(Color);
			((Color)(ref val))..ctor(0.25f, 0.56f, 0.78f, 0.96f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.09f, 0.055f, 0.03f, 0.94f);
			if ((Object)(object)_defaultViewBackground != (Object)null)
			{
				((Graphic)_defaultViewBackground).color = (UseModView ? val2 : val);
			}
			if ((Object)(object)_modViewBackground != (Object)null)
			{
				((Graphic)_modViewBackground).color = (UseModView ? val : val2);
			}
		}

		private static void ConfigurePersistentRepair(Hud hud, GameObject button, Piece repairPiece)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: 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_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			float pieceIconSpacing = hud.m_pieceIconSpacing;
			RectTransform val = (RectTransform)button.transform;
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(0f, 1f);
			val.pivot = new Vector2(0f, 1f);
			val.anchoredPosition = new Vector2(18f, -18f);
			val.sizeDelta = new Vector2(pieceIconSpacing + 8f, pieceIconSpacing + 13f);
			Image component = button.GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).color = new Color(0.09f, 0.055f, 0.03f, 0.94f);
				((Graphic)component).raycastTarget = true;
				AddOutline((Transform)(object)val, "InventoryUX_RepairBorder", 1f, new Color(0.68f, 0.5f, 0.25f, 0.68f));
			}
			Transform val2 = button.transform.Find("selected");
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(false);
			}
			Transform val3 = button.transform.Find("upgrade");
			if ((Object)(object)val3 != (Object)null)
			{
				((Component)val3).gameObject.SetActive(false);
			}
			Transform val4 = button.transform.Find("icon");
			if ((Object)(object)val4 != (Object)null)
			{
				RectTransform val5 = (RectTransform)val4;
				val5.anchorMin = new Vector2(0.12f, 0.25f);
				val5.anchorMax = new Vector2(0.88f, 0.96f);
				val5.offsetMin = Vector2.zero;
				val5.offsetMax = Vector2.zero;
				Image component2 = ((Component)val4).GetComponent<Image>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.sprite = repairPiece.m_icon;
					component2.preserveAspect = true;
					((Graphic)component2).color = Color.white;
				}
			}
			UIInputHandler component3 = button.GetComponent<UIInputHandler>();
			if ((Object)(object)component3 != (Object)null)
			{
				component3.m_onLeftClick = null;
				component3.m_onLeftDown = OnPersistentRepairSelected;
				component3.m_onLeftUp = null;
				component3.m_onRightClick = null;
				component3.m_onRightDown = OnPersistentRepairSelected;
				component3.m_onRightUp = null;
				component3.m_onMiddleClick = null;
				component3.m_onMiddleDown = null;
				component3.m_onMiddleUp = null;
				component3.m_onPointerEnter = null;
				component3.m_onPointerExit = null;
			}
			UITooltip component4 = button.GetComponent<UITooltip>();
			if ((Object)(object)component4 != (Object)null)
			{
				component4.m_text = repairPiece.m_name;
			}
			GameObject val6 = new GameObject("InventoryUX_RepairLabel", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val6.transform.SetParent(button.transform, false);
			RectTransform val7 = (RectTransform)val6.transform;
			val7.anchorMin = new Vector2(0f, 0f);
			val7.anchorMax = new Vector2(1f, 0f);
			val7.pivot = new Vector2(0.5f, 0f);
			val7.anchoredPosition = new Vector2(0f, 3f);
			val7.sizeDelta = new Vector2(-6f, 18f);
			TextMeshProUGUI component5 = val6.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component5).text = "Repair";
			((TMP_Text)component5).font = (((Object)(object)hud.m_pieceDescription != (Object)null) ? hud.m_pieceDescription.font : null);
			((TMP_Text)component5).fontSize = 10.5f;
			((TMP_Text)component5).fontStyle = (FontStyles)1;
			((Graphic)component5).color = new Color(0.91f, 0.75f, 0.47f, 1f);
			((TMP_Text)component5).alignment = (TextAlignmentOptions)514;
			((TMP_Text)component5).outlineWidth = 0.2f;
			((TMP_Text)component5).outlineColor = Color32.op_Implicit(Color.black);
			((Graphic)component5).raycastTarget = false;
		}

		private static void OnPersistentRepairSelected(UIInputHandler _)
		{
			//IL_006a: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			object? value = PlayerBuildPiecesField.GetValue(localPlayer);
			PieceTable val = (PieceTable)((value is PieceTable) ? value : null);
			List<Piece> buildPieces = localPlayer.GetBuildPieces();
			if (!((Object)(object)val == (Object)null) && buildPieces != null)
			{
				int num = FindRepairIndexInCurrentCategory(val, buildPieces);
				if (num < 0)
				{
					Plugin.LogInstance.LogWarning((object)$"Static Repair selection failed: no Repair action was found in {val.GetSelectedCategory()}.");
					return;
				}
				localPlayer.SetSelectedPiece(new Vector2Int(num % 15, num / 15));
				Hud.HidePieceSelection();
			}
		}

		private static int FindRepairIndexInCurrentCategory(PieceTable table, IReadOnlyList<Piece> pieces)
		{
			//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)
			if (_stateValid && table.GetSelectedCategory() == _appliedCategory && _repairLogicalIndex >= 0 && _repairLogicalIndex < pieces.Count && CraftingLayoutMetadata.IsRepair(pieces[_repairLogicalIndex]))
			{
				return _repairLogicalIndex;
			}
			for (int i = 0; i < pieces.Count; i++)
			{
				if (CraftingLayoutMetadata.IsRepair(pieces[i]))
				{
					return i;
				}
			}
			return -1;
		}

		private static void UpdateRepairSelectionState()
		{
			if (!((Object)(object)_persistentRepair == (Object)null))
			{
				Transform val = _persistentRepair.transform.Find("selected");
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}

		private static void RemoveStaleRepairForDifferentHud(Hud hud)
		{
			if ((Object)(object)_persistentRepair != (Object)null && _repairHudId != ((Object)hud).GetInstanceID())
			{
				DestroyPersistentRepair();
			}
			if ((Object)(object)_persistentViewControls != (Object)null && _viewControlsHudId != ((Object)hud).GetInstanceID())
			{
				DestroyPersistentViewControls();
			}
		}

		private static void DestroyPersistentRepair()
		{
			if ((Object)(object)_persistentRepair != (Object)null)
			{
				_persistentRepair.SetActive(false);
				Object.Destroy((Object)(object)_persistentRepair);
			}
			_persistentRepair = null;
			_repairPiece = null;
			_repairHudId = int.MinValue;
		}

		private static void DestroyPersistentViewControls()
		{
			if ((Object)(object)_persistentViewControls != (Object)null)
			{
				_persistentViewControls.SetActive(false);
				Object.Destroy((Object)(object)_persistentViewControls);
			}
			_persistentViewControls = null;
			_defaultViewBackground = null;
			_modViewBackground = null;
			_viewControlsHudId = int.MinValue;
		}

		private static void AddOutline(Transform parent, string name, float inset, Color color)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0048: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			AddOutlineLine(parent, name + "Top", new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 0f - inset), new Vector2((0f - inset) * 2f, 1f), color);
			AddOutlineLine(parent, name + "Bottom", new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0f, inset), new Vector2((0f - inset) * 2f, 1f), color);
			AddOutlineLine(parent, name + "Left", new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(inset, 0f), new Vector2(1f, (0f - inset) * 2f), color);
			AddOutlineLine(parent, name + "Right", new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(0f - inset, 0f), new Vector2(1f, (0f - inset) * 2f), color);
		}

		private static void AddOutlineLine(Transform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 position, Vector2 size, Color color)
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = position;
			val2.sizeDelta = size;
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = color;
			((Graphic)component).raycastTarget = false;
		}

		private static void ApplyGridPermutation(Hud hud, IList icons, CraftingLayoutResult layout, int occupiedCount)
		{
			int num = Math.Min(icons.Count, 90);
			bool[] array = new bool[num];
			for (int i = 0; i < layout.Slots.Length && i < occupiedCount; i++)
			{
				if (layout.Slots[i] >= 0 && layout.Slots[i] < num)
				{
					array[layout.Slots[i]] = true;
				}
			}
			int j = 0;
			for (int k = 0; k < num; k++)
			{
				if (k < occupiedCount && layout.Slots[k] < 0)
				{
					continue;
				}
				int slot;
				if (k < occupiedCount)
				{
					slot = layout.Slots[k];
				}
				else
				{
					for (; j < num && array[j]; j++)
					{
					}
					slot = ((j < num) ? j++ : k);
				}
				float xOffset = ((k < occupiedCount) ? layout.XOffsets[k] : 0f);
				PositionCraftingIcon(hud, GetIconGameObject(icons[k]), slot, xOffset);
			}
		}

		private static void ApplyShelfPositions(Hud hud, IList icons, ShelfLayoutResult layout, int occupiedCount)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			int num = Math.Min(occupiedCount, icons.Count);
			float num2 = Mathf.Min(1f, layout.RowPitch / hud.m_pieceIconSpacing);
			for (int i = 0; i < num; i++)
			{
				if (layout.Slots[i] >= 0)
				{
					RectTransform val = (RectTransform)GetIconGameObject(icons[i]).transform;
					int num3 = layout.Slots[i] / 15;
					if (num2 < 0.999f)
					{
						val.sizeDelta *= num2;
					}
					val.anchoredPosition = new Vector2(layout.XPositions[i], (float)(-num3) * layout.RowPitch);
				}
			}
		}

		private static void RestoreNativeGrid(Hud hud, IList icons)
		{
			int width = HammerGridDimensions.Width;
			int height = HammerGridDimensions.Height;
			int num = Math.Min(icons.Count, width * height);
			for (int i = 0; i < num; i++)
			{
				PositionIcon(hud, GetIconGameObject(icons[i]), i, width);
			}
		}

		private static void PositionIcon(Hud hud, GameObject iconRoot, int slot)
		{
			PositionIcon(hud, iconRoot, slot, 15);
		}

		private static void PositionCraftingIcon(Hud hud, GameObject iconRoot, int slot, float xOffset)
		{
			//IL_0006: 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)
			RectTransform val = (RectTransform)iconRoot.transform;
			float pieceIconSpacing = hud.m_pieceIconSpacing;
			val.anchoredPosition = new Vector2((float)(slot % 15) * pieceIconSpacing * 0.95f + CraftingContentShift(pieceIconSpacing) + xOffset, (float)(-(slot / 15)) * HammerGridDimensions.CraftingRowPitch(hud));
		}

		private static void PositionIcon(Hud hud, GameObject iconRoot, int slot, int width)
		{
			//IL_0006: 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)
			((RectTransform)iconRoot.transform).anchoredPosition = new Vector2((float)(slot % width) * hud.m_pieceIconSpacing, (float)(-(slot / width)) * hud.m_pieceIconSpacing);
		}

		private static bool IsEnabled(PieceCategory category)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected I4, but got Unknown
			if (!UseModView)
			{
				return false;
			}
			return (int)category switch
			{
				0 => true, 
				1 => ModConfig.OrganizeCrafting.Value, 
				2 => ModConfig.OrganizeBuilding.Value, 
				3 => ModConfig.OrganizeHeavyBuilding.Value, 
				4 => ModConfig.OrganizeFurniture.Value, 
				_ => false, 
			};
		}

		internal static void Clear(Hud hud, bool removePersistentRepair = false)
		{
			if (_stateValid)
			{
				IList icons = (IList)PieceIconsField.GetValue(hud);
				RemoveDecorations(hud, icons);
				ResetState();
			}
			if (removePersistentRepair)
			{
				DestroyPersistentRepair();
			}
		}

		internal static void Shutdown()
		{
			if ((Object)(object)_hiddenRepairRoot != (Object)null)
			{
				_hiddenRepairRoot.SetActive(true);
			}
			_hiddenRepairRoot = null;
			RestoreNativeCraftingCells();
			DestroyPersistentRepair();
			DestroyPersistentViewControls();
			UseModView = true;
			ResetState();
		}

		private static void RemoveDecorations(Hud hud, IList icons)
		{
			if ((Object)(object)_hiddenRepairRoot != (Object)null)
			{
				_hiddenRepairRoot.SetActive(true);
				_hiddenRepairRoot = null;
			}
			RestoreNativeCraftingCells();
			for (int num = ((Transform)hud.m_pieceListRoot).childCount - 1; num >= 0; num--)
			{
				Transform child = ((Transform)hud.m_pieceListRoot).GetChild(num);
				if (((Object)child).name.StartsWith("InventoryUX_Crafting", StringComparison.Ordinal))
				{
					((Component)child).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)child).gameObject);
				}
			}
			RestoreNativeGrid(hud, icons);
			for (int i = 0; i < icons.Count; i++)
			{
				Transform transform = GetIconGameObject(icons[i]).transform;
				for (int num2 = transform.childCount - 1; num2 >= 0; num2--)
				{
					Transform child2 = transform.GetChild(num2);
					if (((Object)child2).name.StartsWith("InventoryUX_", StringComparison.Ordinal))
					{
						((Component)child2).gameObject.SetActive(false);
						Object.Destroy((Object)(object)((Component)child2).gameObject);
					}
				}
			}
		}

		private static void AddTileTint(GameObject iconRoot, GroupPalette palette, bool groupStart)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InventoryUX_TileTint", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(iconRoot.transform, false);
			val.transform.SetAsFirstSibling();
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = new Vector2(3f, 3f);
			val2.offsetMax = new Vector2(-3f, -3f);
			Image component = val.GetComponent<Image>();
			Image component2 = iconRoot.GetComponent<Image>();
			if ((Object)(object)component2 != (Object)null)
			{
				component.sprite = component2.sprite;
				component.type = component2.type;
			}
			Color background = palette.Background;
			if (groupStart)
			{
				background.a *= 1.25f;
			}
			((Graphic)component).color = background;
			((Graphic)component).raycastTarget = false;
		}

		private static void AddLabel(Hud hud, GameObject iconRoot, string label, GroupPalette palette)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InventoryUX_GroupLabel", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val.transform.SetParent(iconRoot.transform, false);
			val.transform.SetAsLastSibling();
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(0f, 0f);
			val2.anchorMax = new Vector2(1f, 0f);
			val2.pivot = new Vector2(0.5f, 0f);
			val2.anchoredPosition = new Vector2(0f, 2f);
			val2.sizeDelta = new Vector2(-7f, 14f);
			TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = label.ToUpperInvariant();
			((TMP_Text)component).font = (((Object)(object)hud.m_pieceDescription != (Object)null) ? hud.m_pieceDescription.font : null);
			((TMP_Text)component).fontSize = 8.5f;
			((TMP_Text)component).fontStyle = (FontStyles)1;
			((Graphic)component).color = palette.Text;
			((Graphic)component).raycastTarget = false;
			((TMP_Text)component).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)component).overflowMode = (TextOverflowModes)1;
			((TMP_Text)component).alignment = (TextAlignmentOptions)1025;
			((TMP_Text)component).outlineWidth = 0.1f;
			((TMP_Text)component).outlineColor = new Color32((byte)18, (byte)14, (byte)11, (byte)225);
		}

		private static bool IsStandaloneAction(PieceCategory category, string label)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)category == 1)
			{
				return string.Equals(Normalize(label), "actions", StringComparison.Ordinal);
			}
			return false;
		}

		private static GroupPalette GetPalette(PieceCategory category, string label)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			string text = Normalize(label);
			if ((int)category == 1)
			{
				if (text.Contains("workbench"))
				{
					return FallbackPalettes[0];
				}
				if (text.Contains("blackforge"))
				{
					return FallbackPalettes[4];
				}
				if (text.Contains("forge"))
				{
					return FallbackPalettes[1];
				}
				if (text.Contains("cauldron"))
				{
					return FallbackPalettes[2];
				}
				if (text.Contains("stonecutter"))
				{
					return FallbackPalettes[3];
				}
				if (text.Contains("artisan"))
				{
					return FallbackPalettes[6];
				}
				if (text.Contains("galdr"))
				{
					return FallbackPalettes[5];
				}
				if (text.Contains("foodpreparation") || text.Contains("preptable"))
				{
					return FallbackPalettes[2];
				}
				if (text.Contains("mead") || text.Contains("ketill") || text.Contains("kettle"))
				{
					return FallbackPalettes[7];
				}
				if (text.Contains("cooking"))
				{
					return FallbackPalettes[6];
				}
			}
			int num = 17;
			for (int i = 0; i < text.Length; i++)
			{
				num = num * 31 + text[i];
			}
			return FallbackPalettes[(num & 0x7FFFFFFF) % FallbackPalettes.Length];
		}

		private static string CompactLabel(string label)
		{
			string text = Normalize(label);
			if (text.Contains("foodpreparation") || text.Contains("preptable"))
			{
				return "Food Prep";
			}
			if (text.Contains("stonecutter"))
			{
				return "Stonecut";
			}
			if (text.Contains("artisantable"))
			{
				return "Artisan";
			}
			if (text.Contains("galdrtable"))
			{
				return "Galdr";
			}
			if (text.Contains("mead") && (text.Contains("ketill") || text.Contains("kettle")))
			{
				return "Mead Ketill";
			}
			if (text.Contains("othercrafting"))
			{
				return "Other";
			}
			return label;
		}

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

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			foreach (char c in value)
			{
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = char.ToLowerInvariant(c);
				}
			}
			return new string(array, 0, length);
		}

		private static GroupPalette Palette(float textR, float textG, float textB, float backgroundR, float backgroundG, float backgroundB)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return new GroupPalette(new Color(textR, textG, textB, 0.96f), new Color(backgroundR, backgroundG, backgroundB, 0.085f));
		}

		private static GameObject GetIconGameObject(object icon)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			Type type = icon.GetType();
			if (_iconType != type)
			{
				_iconType = type;
				_iconGoField = type.GetField("m_go", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (_iconGoField == null)
				{
					throw new MissingFieldException(type.FullName, "m_go");
				}
			}
			return (GameObject)_iconGoField.GetValue(icon);
		}
	}
	internal static class HammerOrganizer
	{
		private static readonly FieldInfo AvailablePiecesField = AccessTools.Field(typeof(PieceTable), "m_availablePieces");

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

		internal static void ReorderAvailablePieces(PieceTable table)
		{
			List<List<Piece>> all = (List<List<Piece>>)AvailablePiecesField.GetValue(table);
			LabelsByPiece.Clear();
			Reorder(all, (PieceCategory)0, enabled: true);
			Reorder(all, (PieceCategory)1, ModConfig.OrganizeCrafting.Value);
			Reorder(all, (PieceCategory)2, ModConfig.OrganizeBuilding.Value);
			Reorder(all, (PieceCategory)3, ModConfig.OrganizeHeavyBuilding.Value);
			Reorder(all, (PieceCategory)4, ModConfig.OrganizeFurniture.Value);
		}

		internal static string? GetLabel(Piece piece)
		{
			if (!((Object)(object)piece != (Object)null) || !LabelsByPiece.TryGetValue(((Object)piece).GetInstanceID(), out string value))
			{
				return null;
			}
			return value;
		}

		internal static int GetExtensionOrder(Piece piece)
		{
			string text = Normalize(((Object)((Component)piece).gameObject).name);
			int num = TrailingNumber(text);
			if (text.Contains("choppingblock"))
			{
				return 10;
			}
			if (text.Contains("tanningrack"))
			{
				return 20;
			}
			if (text.Contains("adze"))
			{
				return 30;
			}
			if (text.Contains("toolshelf"))
			{
				return 40;
			}
			if (text.Contains("forgecooler"))
			{
				return 10;
			}
			if (text.Contains("anvils"))
			{
				return 20;
			}
			if (text.Contains("smithsanvil"))
			{
				return 30;
			}
			if (text.Contains("grindingwheel"))
			{
				return 40;
			}
			if (text.Contains("forgebellows"))
			{
				return 50;
			}
			if (num < 0)
			{
				return 500;
			}
			return 10 + num * 10;
		}

		internal static PieceGroup Classify(Piece piece, PieceCategory category)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected I4, but got Unknown
			return (int)category switch
			{
				0 => ClassifyMisc(piece), 
				1 => ClassifyCrafting(piece), 
				2 => ClassifyBuilding(piece, heavy: false), 
				3 => ClassifyBuilding(piece, heavy: true), 
				4 => ClassifyFurniture(piece), 
				_ => new PieceGroup("Other", 999, 999), 
			};
		}

		private static void Reorder(List<List<Piece>> all, PieceCategory category, bool enabled)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected I4, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Invalid comparison between Unknown and I4
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			int num = (int)category;
			if (!enabled || num < 0 || num >= all.Count || all[num] == null)
			{
				return;
			}
			List<Piece> list = all[num];
			Dictionary<int, int> originalIndex = new Dictionary<int, int>();
			for (int i = 0; i < list.Count; i++)
			{
				originalIndex[((Object)list[i]).GetInstanceID()] = i;
				if ((int)category == 1)
				{
					LabelsByPiece[((Object)list[i]).GetInstanceID()] = ClassifyCrafting(list[i]).Label;
				}
			}
			list.Sort(delegate(Piece left, Piece right)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Invalid comparison between Unknown and I4
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Invalid comparison between Unknown and I4
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: Invalid comparison between Unknown and I4
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: Invalid comparison between Unknown and I4
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				if ((int)category == 1)
				{
					bool flag = left.m_repairPiece || left.m_removePiece;
					bool flag2 = right.m_repairPiece || right.m_removePiece;
					if (flag != flag2)
					{
						if (!flag)
						{
							return -1;
						}
						return 1;
					}
					if (!flag)
					{
						CraftingPieceLayout craftingPieceLayout = CraftingLayoutMetadata.Resolve(left);
						CraftingPieceLayout craftingPieceLayout2 = CraftingLayoutMetadata.Resolve(right);
						int num3 = craftingPieceLayout.Section.CompareTo(craftingPieceLayout2.Section);
						if (num3 != 0)
						{
							return num3;
						}
						num3 = craftingPieceLayout.SortOrder.CompareTo(craftingPieceLayout2.SortOrder);
						if (num3 != 0)
						{
							return num3;
						}
					}
					int num4 = string.Compare(Localize(left.m_name), Localize(right.m_name), StringComparison.CurrentCultureIgnoreCase);
					if (num4 != 0)
					{
						return num4;
					}
					return originalIndex[((Object)left).GetInstanceID()].CompareTo(originalIndex[((Object)right).GetInstanceID()]);
				}
				bool flag3 = CraftingLayoutMetadata.IsRepair(left) || left.m_removePiece;
				bool flag4 = CraftingLayoutMetadata.IsRepair(right) || right.m_removePiece;
				if (flag3 != flag4)
				{
					if (!flag3)
					{
						return -1;
					}
					return 1;
				}
				if (flag3)
				{
					return originalIndex[((Object)left).GetInstanceID()].CompareTo(originalIndex[((Object)right).GetInstanceID()]);
				}
				PieceGroup pieceGroup = Classify(left, category);
				PieceGroup pieceGroup2 = Classify(right, category);
				int num5 = pieceGroup.Order.CompareTo(pieceGroup2.Order);
				if (num5 != 0)
				{
					return num5;
				}
				if ((int)category == 2 || (int)category == 3 || (int)category == 4 || (int)category == 0)
				{
					num5 = pieceGroup.Suborder.CompareTo(pieceGroup2.Suborder);
					if (num5 != 0)
					{
						return num5;
					}
				}
				HammerSortKey hammerSortKey = HammerProgressionSorter.Create(ToSortCategory(category), SearchText(left), ResourceIdentifiers(left));
				HammerSortKey other = HammerProgressionSorter.Create(ToSortCategory(category), SearchText(right), ResourceIdentifiers(right));
				num5 = hammerSortKey.CompareTo(other);
				return (num5 != 0) ? num5 : originalIndex[((Object)left).GetInstanceID()].CompareTo(originalIndex[((Object)right).GetInstanceID()]);
			});
			for (int num2 = 0; num2 < list.Count; num2++)
			{
				LabelsByPiece[((Object)list[num2]).GetInstanceID()] = Classify(list[num2], category).Label;
			}
		}

		private static PieceGroup ClassifyCrafting(Piece piece)
		{
			if (piece.m_repairPiece || piece.m_removePiece)
			{
				return new PieceGroup("Actions", 800, 0);
			}
			CraftingStation component = ((Component)piece).GetComponent<CraftingStation>();
			StationExtension component2 = ((Component)piece).GetComponent<StationExtension>();
			string name;
			int suborder;
			if ((Object)(object)component != (Object)null)
			{
				name = component.m_name;
				suborder = 0;
			}
			else
			{
				if (!((Object)(object)component2 != (Object)null) || !((Object)(object)component2.m_craftingStation != (Object)null))
				{
					return new PieceGroup("Other Crafting", 900, 900);
				}
				name = component2.m_craftingStation.m_name;
				suborder = GetExtensionOrder(piece);
			}
			return new PieceGroup(Localize(name), StationOrder(name), suborder);
		}

		private static PieceGroup ClassifyMisc(Piece piece)
		{
			if (piece.m_repairPiece || piece.m_removePiece)
			{
				return new PieceGroup("Actions", 900, 0);
			}
			string text = SearchText(piece);
			string text2 = ComponentNames(piece);
			if (ContainsAny(text, "cartography", "maptable"))
			{
				return new PieceGroup("Utility", 5, 0);
			}
			int num = HammerProgressionSorter.MiscTravelOrder(text);
			if (num >= 0)
			{
				return new PieceGroup("Travel", 0, num);
			}
			if (ContainsAny(text, "campfire", "bonfire", "firepit", "hearth", "brazier") || text2.Contains("fireplace"))
			{
				return new PieceGroup("Fire / Comfort", 1, 0);
			}
			if (ContainsAny(text, "trap", "stake", "spike", "palisade", "barricade", "roundpolefence", "roundpole", "woodfence", "shieldgenerator", "shieldgen", "defence", "defense"))
			{
				return new PieceGroup("Defense", 2, HammerProgressionSorter.MiscDefenseOrder(text));
			}
			if (ContainsAny(text, "ballista", "catapult", "batteringram", "siege", "turret", "cannon"))
			{
				return new PieceGroup("Siege", 3, 0);
			}
			if (ContainsAny(text, "resource", "stack", "pile", "woodpile", "stonepile", "coalpile", "orepile", "scrappile", "coinpile", "bonepile", "logstack", "haystack"))
			{
				return new PieceGroup("Resources", 4, 0);
			}
			return new PieceGroup("Utility", 5, 0);
		}

		private static PieceGroup ClassifyBuilding(Piece piece, bool heavy)
		{
			if (!heavy)
			{
				string value = SearchText(piece) + " " + ResourceText(piece);
				if (ContainsAny(value, "dvergr", "dverger"))
				{
					return new PieceGroup("Wood", 0, 5);
				}
				if (ContainsAny(value, "grausten", "ashwood", "blackwood"))
				{
					return new PieceGroup("Ashwood", 3, StructuralOrder(piece));
				}
				if (ContainsAny(value, "darkwood", "tar"))
				{
					return new PieceGroup("Darkwood", 2, StructuralOrder(piece));
				}
				if (ContainsAny(value, "corewood", "roundlog", "logpole", "logbeam"))
				{
					return new PieceGroup("Core Wood", 1, StructuralOrder(piece));
				}
				return new PieceGroup("Wood", 0, StructuralOrder(piece));
			}
			int order;
			return new PieceGroup(MaterialGroup(piece, heavy, out order), order, StructuralOrder(piece));
		}

		private static PieceGroup ClassifyFurniture(Piece piece)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Invalid comparison between Unknown and I4
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Invalid comparison between Unknown and I4
			string text = SearchText(piece);
			string text2 = ComponentNames(piece);
			string text3;
			int order;
			if (ContainsAny(text, "hottub", "bathtub"))
			{
				text3 = "Utility / Other";
				order = 6;
			}
			else if (text2.Contains("container") || ContainsAny(text, "chest", "crate", "storage"))
			{
				text3 = "Storage";
				order = 0;
			}
			else if (ContainsAny(text2, "chair", "seat") || ContainsAny(text, "chair", "bench", "stool", "throne"))
			{
				text3 = "Seating";
				order = 1;
			}
			else if ((int)piece.m_comfortGroup == 5 || ContainsAny(text, "table", "desk"))
			{
				text3 = "Tables";
				order = 2;
			}
			else if (text2.Contains("bed") || (int)piece.m_comfortGroup == 2 || text.Contains("bed"))
			{
				text3 = "Beds / Comfort";
				order = 3;
			}
			else if (text2.Contains("fireplace") || ContainsAny(text, "torch", "sconce", "brazier", "fire", "lamp", "lantern"))
			{
				text3 = "Lighting";
				order = 4;
			}
			else if (text2.Contains("itemstand") || ContainsAny(text, "itemstand", "armorstand") || piece.m_comfort > 0 || ContainsAny(text, "banner", "rug", "carpet", "curtain", "decoration"))
			{
				text3 = "Display / Decor";
				order = 5;
			}
			else
			{
				text3 = "Utility / Other";
				order = 6;
			}
			int suborder = 0;
			if (string.Equals(text3, "Display / Decor", StringComparison.Ordinal))
			{
				if (ContainsAny(text, "rug", "carpet"))
				{
					suborder = 800;
				}
				else if (text.Contains("banner"))
				{
					suborder = 900;
				}
			}
			return new PieceGroup(text3, order, suborder);
		}

		private static string MaterialGroup(Piece piece, bool heavy, out int order)
		{
			string text = SearchText(piece) + " " + ResourceText(piece);
			if (ContainsAny(text, "grausten", "ashwood"))
			{
				order = 5;
				return "Grausten";
			}
			if (ContainsAny(text, "blackmarble", "black marble"))
			{
				order = 4;
				return "Black Marble";
			}
			if (ContainsAny(text, "darkwood", "tar"))
			{
				order = 2;
				return "Darkwood";
			}
			if (ContainsAny(text, "corewood", "roundlog", "logpole", "logbeam"))
			{
				order = 1;
				return "Core Wood / Log";
			}
			if (ContainsAny(text, "stone", "crystal"))
			{
				order = 3;
				return "Stone";
			}
			if (ContainsAny(text, "iron", "copper", "bronze", "metal"))
			{
				order = 6;
				return "Metal / Structural";
			}
			if (text.Contains("wood"))
			{
				order = 0;
				return "Wood";
			}
			order = (heavy ? 7 : 8);
			if (!heavy)
			{
				return "Other";
			}
			return "Special / Other";
		}

		private static int StructuralOrder(Piece piece)
		{
			string text = SearchText(piece);
			if (text.Contains("roofcross") || (text.Contains("roof") && text.Contains("cross")))
			{
				return 0;
			}
			if (ContainsAny(text, "beam", "pole", "pillar", "column"))
			{
				return 0;
			}
			if (ContainsAny(text, "floor", "tile"))
			{
				return 1;
			}
			if (ContainsAny(text, "wall", "halfwall"))
			{
				return 2;
			}
			if (ContainsAny(text, "roof", "thatch"))
			{
				return 3;
			}
			return 4;
		}

		private static int StationOrder(string stationName)
		{
			string text = Normalize(stationName);
			if (text.Contains("workbench"))
			{
				return 0;
			}
			if (text.Contains("forge") && !text.Contains("black"))
			{
				return 10;
			}
			if (text.Contains("cauldron"))
			{
				return 20;
			}
			if (text.Contains("stonecutter"))
			{
				return 30;
			}
			if (text.Contains("artisan"))
			{
				return 40;
			}
			if (text.Contains("blackforge"))
			{
				return 50;
			}
			if (text.Contains("galdr"))
			{
				return 60;
			}
			if (text.Contains("foodpreparation") || text.Contains("preptable"))
			{
				return 70;
			}
			if (text.Contains("mead") || text.Contains("ketill") || text.Contains("kettle"))
			{
				return 80;
			}
			if (text.Contains("cooking"))
			{
				return 90;
			}
			return 100;
		}

		private static HammerSortCategory ToSortCategory(PieceCategory category)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected I4, but got Unknown
			return (int)category switch
			{
				0 => HammerSortCategory.Misc, 
				2 => HammerSortCategory.Building, 
				3 => HammerSortCategory.HeavyBuilding, 
				4 => HammerSortCategory.Furniture, 
				_ => HammerSortCategory.Misc, 
			};
		}

		private static string SearchText(Piece piece)
		{
			return Normalize(((Object)((Component)piece).gameObject).name + " " + piece.m_name + " " + piece.m_description);
		}

		private static string ResourceText(Piece piece)
		{
			if (piece.m_resources == null)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			for (int i = 0; i < piece.m_resources.Length; i++)
			{
				ItemDrop val = piece.m_resources[i]?.m_resItem;
				if ((Object)(object)val != (Object)null)
				{
					list.Add(((Object)((Component)val).gameObject).name);
					list.Add(val.m_itemData.m_shared.m_name);
				}
			}
			return Normalize(string.Join(" ", list));
		}

		private static IReadOnlyList<string> ResourceIdentifiers(Piece piece)
		{
			List<string> list = new List<string>();
			if (piece.m_resources == null)
			{
				return list;
			}
			for (int i = 0; i < piece.m_resources.Length; i++)
			{
				ItemDrop val = piece.m_resources[i]?.m_resItem;
				if (!((Object)(object)val == (Object)null))
				{
					list.Add(((Object)((Component)val).gameObject).name);
					list.Add(val.m_itemData.m_shared.m_name);
				}
			}
			return list;
		}

		private static string ComponentNames(Piece piece)
		{
			Component[] components = ((Component)piece).GetComponents<Component>();
			List<string> list = new List<string>(components.Length);
			for (int i = 0; i < components.Length; i++)
			{
				if ((Object)(object)components[i] != (Object)null)
				{
					list.Add(((object)components[i]).GetType().Name.ToLowerInvariant());
				}
			}
			return string.Join(" ", list);
		}

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

		private static bool ContainsAny(string value, params string[] markers)
		{
			for (int i = 0; i < markers.Length; i++)
			{
				if (value.IndexOf(markers[i], StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private static string Normalize(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			foreach (char c in value)
			{
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = char.ToLower(c, CultureInfo.InvariantCulture);
				}
			}
			return new string(array, 0, length);
		}

		private static int TrailingNumber(string value)
		{
			int num = value.Length - 1;
			while (num >= 0 && char.IsDigit(value[num]))
			{
				num--;
			}
			if (num == value.Length - 1)
			{
				return -1;
			}
			if (!int.TryParse(value.Substring(num + 1), NumberStyles.None, CultureInfo.InvariantCulture, out var result))
			{
				return -1;
			}
			return result;
		}
	}
	internal readonly struct PieceGroup
	{
		internal string Label { get; }

		internal int Order { get; }

		internal int Suborder { get; }

		internal PieceGroup(string label, int order, int suborder)
		{
			Label = label;
			Order = order;
			Suborder = suborder;
		}
	}
	internal static class ModConfig
	{
		internal static ConfigFile File { get; private set; }

		internal static ConfigEntry<bool> Enabled { get; private set; }

		internal static ConfigEntry<bool> ShowSeparators { get; private set; }

		internal static ConfigEntry<bool> ShowHammerPieceNames { get; private set; }

		internal static ConfigEntry<bool> OrganizeCrafting { get; private set; }

		internal static ConfigEntry<bool> OrganizeBuilding { get; private set; }

		internal static ConfigEntry<bool> OrganizeHeavyBuilding { get; private set; }

		internal static ConfigEntry<bool> OrganizeFurniture { get; private set; }

		internal static ConfigEntry<bool> OrganizeRecipes { get; private set; }

		internal static ConfigEntry<string> WorkbenchGrouping { get; private set; }

		internal static ConfigEntry<string> FoodGrouping { get; private set; }

		internal static ConfigEntry<bool> WriteDataInventoryOnStartup { get; private set; }

		internal static EquipmentGroupingMode EquipmentMode
		{
			get
			{
				if (string.Equals(WorkbenchGrouping.Value, "Family", StringComparison.OrdinalIgnoreCase))
				{
					return EquipmentGroupingMode.Type;
				}
				if (string.Equals(WorkbenchGrouping.Value, "Tier", StringComparison.OrdinalIgnoreCase))
				{
					return EquipmentGroupingMode.Biome;
				}
				if (!Enum.TryParse<EquipmentGroupingMode>(WorkbenchGrouping.Value, ignoreCase: true, out var result))
				{
					return EquipmentGroupingMode.Default;
				}
				return result;
			}
		}

		internal static FoodGroupingMode FoodMode
		{
			get
			{
				if (string.Equals(FoodGrouping.Value, "Tier", StringComparison.OrdinalIgnoreCase))
				{
					return FoodGroupingMode.Biome;
				}
				if (!Enum.TryParse<FoodGroupingMode>(FoodGrouping.Value, ignoreCase: true, out var result))
				{
					return FoodGroupingMode.Default;
				}
				return result;
			}
		}

		internal static void Bind(ConfigFile config)
		{
			File = config;
			Enabled = config.Bind<bool>("General", "Enabled", true, "Enable CraftGuard.");
			ShowSeparators = config.Bind<bool>("General", "ShowSeparators", true, "Show restrained separator lines around recipe groups.");
			ShowHammerPieceNames = config.Bind<bool>("Hammer", "ShowPieceNames", false, "Show names beneath individual pieces in organized Hammer tabs.");
			OrganizeCrafting = config.Bind<bool>("Hammer", "OrganizeCrafting", true, "Group stations and their known extensions.");
			OrganizeBuilding = config.Bind<bool>("Hammer", "OrganizeBuilding", true, "Group building pieces by material and structure.");
			OrganizeHeavyBuilding = config.Bind<bool>("Hammer", "OrganizeHeavyBuilding", true, "Group heavy building pieces by material and structure.");
			OrganizeFurniture = config.Bind<bool>("Hammer", "OrganizeFurniture", true, "Group furniture by function.");
			OrganizeRecipes = config.Bind<bool>("CraftingUI", "OrganizeRecipes", true, "Enable crafting-station views and search without changing recipes or craftability.");
			WorkbenchGrouping = config.Bind<string>("CraftingUI", "WorkbenchGrouping", "Default", "Remembered equipment-station view: Default, Type, or Biome.");
			FoodGrouping = config.Bind<string>("CraftingUI", "FoodGrouping", "Default", "Remembered food-station view: Default, Stat, or Biome.");
			WriteDataInventoryOnStartup = config.Bind<bool>("Diagnostics", "WriteDataInventoryOnStartup", false, "Write a CSV inventory of the currently loaded vanilla and modded pieces/recipes to BepInEx/config/CraftGuard once per launch.");
		}

		internal static void SetEquipmentMode(EquipmentGroupingMode mode)
		{
			WorkbenchGrouping.Value = mode.ToString();
			File.Save();
		}

		internal static void SetFoodMode(FoodGroupingMode mode)
		{
			FoodGrouping.Value = mode.ToString();
			File.Save();
		}
	}
	internal static class RecipeOrganizer
	{
		private sealed class RecipePairView
		{
			internal object Pair { get; }

			internal GameObject Element { get; }

			internal RecipeFacts Facts { get; }

			internal RecipeGroup Group { get; set; }

			internal int Suborder { get; set; }

			internal float Strength { get; set; }

			internal RecipePairView(object pair, GameObject element, RecipeFacts facts)
			{
				Pair = pair;
				Element = element;
				Facts = facts;
				Group = new RecipeGroup("Other", 999);
			}
		}

		private sealed class FixedControls
		{
			private readonly Vector2 _viewportOffsetMin;

			private readonly Vector2 _viewportOffsetMax;

			private bool _searchSpaceReserved;

			internal InventoryGui Owner { get; }

			internal StationRecipeContext Context { get; }

			internal GameObject ModeRoot { get; }

			internal GameObject SearchRoot { get; }

			internal TMP_InputField SearchInput { get; }

			internal ModeButtonState[] ModeButtons { get; }

			internal RectTransform RecipeViewport { get; }

			internal FixedControls(InventoryGui owner, StationRecipeContext context, GameObject modeRoot, GameObject searchRoot, TMP_InputField searchInput, ModeButtonState[] modeButtons, RectTransform recipeViewport, Vector2 viewportOffsetMin, Vector2 viewportOffsetMax)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: 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)
				Owner = owner;
				Context = context;
				ModeRoot = modeRoot;
				SearchRoot = searchRoot;
				SearchInput = searchInput;
				ModeButtons = modeButtons;
				RecipeViewport = recipeViewport;
				_viewportOffsetMin = viewportOffsetMin;
				_viewportOffsetMax = viewportOffsetMax;
			}

			internal void ReserveSearchSpace()
			{
				//IL_001e: 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)
				if (!_searchSpaceReserved && !((Object)(object)RecipeViewport == (Object)null))
				{
					RecipeViewport.offsetMin = _viewportOffsetMin;
					RecipeViewport.offsetMax = new Vector2(_viewportOffsetMax.x, _viewportOffsetMax.y - 34f);
					_searchSpaceReserved = true;
				}
			}

			internal void RestoreRecipeViewport()
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if (_searchSpaceReserved && !((Object)(object)RecipeViewport == (Object)null))
				{
					RecipeViewport.offsetMin = _viewportOffsetMin;
					RecipeViewport.offsetMax = _viewportOffsetMax;
					_searchSpaceReserved = false;
				}
			}
		}

		private sealed class ModeButtonState
		{
			internal DisplayedMode Mode { get; }

			internal Image Background { get; }

			internal TMP_Text Label { get; }

			internal ModeButtonState(DisplayedMode mode, Image background, TMP_Text label)
			{
				Mode = mode;
				Background = background;
				Label = label;
			}
		}

		private enum StationRecipeContext
		{
			Equipment,
			Food
		}

		private enum FoodStationKind
		{
			Meals,
			FoodPrep,
			Mead
		}

		private enum DisplayedMode
		{
			Default,
			Primary,
			Biome
		}

		private const string ContentPrefix = "InventoryUX_Recipe_";

		private const string FixedPrefix = "InventoryUX_Crafting_";

		private const float ContentTopPadding = 2f;

		private const float SearchStripHeight = 34f;

		private const float SearchFieldHeight = 29f;

		private const float HeaderHeight = 22f;

		private const float ModeButtonWidth = 70f;

		private const float ModeButtonGap = 3f;

		private static readonly Color Gold = new Color(0.83f, 0.62f, 0.25f, 1f);

		private static readonly Color ActiveBlue = new Color(0.24f, 0.55f, 0.78f, 0.95f);

		private static readonly Color InactiveBrown = new Color(0.12f, 0.1f, 0.09f, 0.96f);

		private static readonly Color SearchBrown = new Color(0.18f, 0.125f, 0.075f, 0.98f);

		private static readonly FieldInfo AvailableRecipesField = AccessTools.Field(typeof(InventoryGui), "m_availableRecipes");

		private static readonly FieldInfo RecipeListBaseSizeField = AccessTools.Field(typeof(InventoryGui), "m_recipeListBaseSize");

		private static readonly MethodInfo RefreshMethod = AccessTools.Method(typeof(InventoryGui), "UpdateCraftingPanel", (Type[])null, (Type[])null);

		private static Type? _pairType;

		private static PropertyInfo? _recipeProperty;

		private static PropertyInfo? _elementProperty;

		private static FixedControls? _fixedControls;

		private static string _searchText = string.Empty;

		private static string _activeStationKey = string.Empty;

		internal static void Organize(InventoryGui gui)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			if ((Object)(object)gui.m_recipeListRoot == (Object)null)
			{
				return;
			}
			ClearContentDecorations(gui.m_recipeListRoot);
			Player localPlayer = Player.m_localPlayer;
			CraftingStation val = (((Object)(object)localPlayer != (Object)null) ? localPlayer.GetCurrentCraftingStation() : null);
			if (!gui.InCraftTab() || (Object)(object)val == (Object)null)
			{
				HideFixedControls(gui);
				return;
			}
			PrepareStationSearch(val);
			FoodStationKind foodStationKind = GetFoodStationKind(val);
			IList list = (IList)AvailableRecipesField.GetValue(gui);
			if (list.Count == 0)
			{
				StationRecipeContext context = GuessContextFromStation(val);
				EnsureFixedControls(gui, context);
				SetFixedControlsVisible(visible: true);
				UpdateModeAppearance();
				Render(gui, Array.Empty<RecipePairView>(), context, foodStationKind, grouped: false);
				return;
			}
			EnsurePairAccessors(list[0]);
			List<RecipePairView> list2 = new List<RecipePairView>(list.Count);
			for (int i = 0; i < list.Count; i++)
			{
				object obj = list[i];
				Recipe val2 = (Recipe)_recipeProperty.GetValue(obj, null);
				GameObject val3 = (GameObject)_elementProperty.GetValue(obj, null);
				if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
				{
					HideFixedControls(gui);
					return;
				}
				list2.Add(new RecipePairView(obj, val3, ReadFacts(val2, i, foodStationKind)));
			}
			StationRecipeContext stationRecipeContext = ClassifyContext(val, list2);
			EnsureFixedControls(gui, stationRecipeContext);
			SetFixedControlsVisible(visible: true);
			UpdateModeAppearance();
			List<RecipePairView> list3 = new List<RecipePairView>(list2.Count);
			for (int j = 0; j < list2.Count; j++)
			{
				RecipePairView recipePairView = list2[j];
				if (RecipeSearch.Matches(recipePairView.Facts, _searchText))
				{
					list3.Add(recipePairView);
					continue;
				}
				recipePairView.Element.SetActive(false);
				Object.Destroy((Object)(object)recipePairView.Element);
			}
			bool flag;
			if (stationRecipeContext == StationRecipeContext.Food)
			{
				FoodGroupingMode foodMode = ModConfig.FoodMode;
				flag = foodMode != FoodGroupingMode.Default;
				for (int k = 0; k < list3.Count; k++)
				{
					RecipePairView recipePairView2 = list3[k];
					RecipeGroup recipeGroup = BiomeClassifier.GetGroup(recipePairView2.Facts);
					RecipeGroup recipeGroup2 = foodStationKind switch
					{
						FoodStationKind.Mead => MeadClassifier.ToGroup(MeadClassifier.Classify(recipePairView2.Facts)), 
						FoodStationKind.FoodPrep => RecipeClassifier.GetFoodPrepGroup(recipePairView2.Facts, FoodGroupingMode.Stat), 
						_ => RecipeClassifier.GetFoodGroup(recipePairView2.Facts, FoodGroupingMode.Stat), 
					};
					recipePairView2.Group = ((foodMode == FoodGroupingMode.Biome) ? recipeGroup : recipeGroup2);
					recipePairView2.Suborder = ((foodMode == FoodGroupingMode.Biome) ? recipeGroup2.Order : ((foodStationKind == FoodStationKind.Mead) ? recipeGroup.Order : 0));
					recipePairView2.Strength = ((foodStationKind != FoodStationKind.Mead && recipePairView2.Facts.IsFood) ? FoodClassifier.Strength(recipePairView2.Facts) : 0f);
				}
			}
			else
			{
				EquipmentGroupingMode equipmentMode = ModConfig.EquipmentMode;
				flag = equipmentMode != EquipmentGroupingMode.Default;
				for (int l = 0; l < list3.Count; l++)
				{
					RecipePairView recipePairView3 = list3[l];
					RecipeGroup typeGroup = RecipeClassifier.GetTypeGroup(recipePairView3.Facts);
					RecipeGroup recipeGroup3 = BiomeClassifier.GetGroup(recipePairView3.Facts);
					recipePairView3.Group = ((equipmentMode == EquipmentGroupingMode.Biome) ? recipeGroup3 : typeGroup);
					recipePairView3.Suborder = ((equipmentMode == EquipmentGroupingMode.Type) ? recipeGroup3.Order : typeGroup.Order);
				}
			}
			if (flag)
			{
				list3.Sort(CompareViews);
			}
			list.Clear();
			for (int m = 0; m < list3.Count; m++)
			{
				list.Add(list3[m].Pair);
			}
			Render(gui, list3, stationRecipeContext, foodStationKind, flag);
		}

		internal static void Cleanup(InventoryGui gui)
		{
			if ((Object)(object)gui.m_recipeListRoot != (Object)null)
			{
				ClearContentDecorations(gui.m_recipeListRoot);
			}
			HideFixedControls(gui);
		}

		private static void PrepareStationSearch(CraftingStation station)
		{
			string text = station.m_name + "|" + ((Object)((Component)station).gameObject).name;
			if (!string.Equals(_activeStationKey, text, StringComparison.Ordinal))
			{
				_activeStationKey = text;
				_searchText = string.Empty;
			}
		}

		private static StationRecipeContext ClassifyContext(CraftingStation station, IReadOnlyList<RecipePairView> views)
		{
			StationRecipeContext stationRecipeContext = GuessContextFromStation(station);
			if (stationRecipeContext == StationRecipeContext.Food)
			{
				return stationRecipeContext;
			}
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < views.Count; i++)
			{
				if (views[i].Facts.IsFood)
				{
					num++;
				}
				if (RecipeClassifier.GetTypeGroup(views[i].Facts).Label != "Other")
				{
					num2++;
				}
			}
			if (num <= 0 || (num2 != 0 && num * 2 < views.Count))
			{
				return StationRecipeContext.Equipment;
			}
			return StationRecipeContext.Food;
		}

		private static StationRecipeContext GuessContextFromStation(CraftingStation station)
		{
			string text = (station.m_name + " " + ((Object)((Component)station).gameObject).name).ToLowerInvariant();
			if (!text.Contains("cauldron") && !text.Contains("cooking") && !text.Contains("kitchen") && !text.Contains("oven") && !text.Contains("food") && !text.Contains("mead") && !text.Contains("ketill") && !text.Contains("preptable"))
			{
				return StationRecipeContext.Equipment;
			}
			return StationRecipeContext.Food;
		}

		private static FoodStationKind GetFoodStationKind(CraftingStation station)
		{
			string text = (station.m_name + " " + ((Object)((Component)station).gameObject).name).ToLowerInvariant();
			if (text.Contains("foodpreparation") || text.Contains("preptable"))
			{
				return FoodStationKind.FoodPrep;
			}
			if (!text.Contains("mead") && !text.Contains("ketill") && !text.Contains("kettil") && !text.Contains("kettle"))
			{
				return FoodStationKind.Meals;
			}
			return FoodStationKind.Mead;
		}

		private static int CompareViews(RecipePairView left, RecipePairView right)
		{
			int num = left.Group.Order.CompareTo(right.Group.Order);
			if (num != 0)
			{
				return num;
			}
			num = left.Suborder.CompareTo(right.Suborder);
			if (num != 0)
			{
				return num;
			}
			num = right.Strength.CompareTo(left.Strength);
			if (num != 0)
			{
				return num;
			}
			num = string.Compare(left.Facts.DisplayName, right.Facts.DisplayName, StringComparison.CurrentCultureIgnoreCase);
			if (num != 0)
			{
				return num;
			}
			num = string.Compare(left.Facts.Id, right.Facts.Id, StringComparison.Ordinal);
			if (num == 0)
			{
				return left.Facts.OriginalIndex.CompareTo(right.Facts.OriginalIndex);
			}
			return num;
		}

		private static void Render(InventoryGui gui, IReadOnlyList<RecipePairView> views, StationRecipeContext context, FoodStationKind foodStationKind, bool grouped)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			RectTransform recipeListRoot = gui.m_recipeListRoot;
			float num = 2f;
			string a = null;
			if (views.Count == 0 && !string.IsNullOrWhiteSpace(_searchText))
			{
				CreateStatus(gui, recipeListRoot, "No matching unlocked recipes", num);
				num += 22f;
			}
			for (int i = 0; i < views.Count; i++)
			{
				RecipePairView recipePairView = views[i];
				if (grouped && !string.Equals(a, recipePairView.Group.Label, StringComparison.Ordinal))
				{
					CreateHeader(gui, recipeListRoot, recipePairView.Group.Label, num);
					num += 22f;
					a = recipePairView.Group.Label;
				}
				((RectTransform)recipePairView.Element.transform).anchoredPosition = new Vector2(0f, 0f - num);
				if (context == StationRecipeContext.Food && foodStationKind != FoodStationKind.Mead && (recipePairView.Facts.IsFood || recipePairView.Facts.IsFeast))
				{
					AddMealStats(gui, recipePairView);
				}
				num += gui.m_recipeListSpace;
			}
			float num2 = (float)RecipeListBaseSizeField.GetValue(gui);
			recipeListRoot.SetSizeWithCurrentAnchors((Axis)1, Mathf.Max(num2, num));
		}

		private static void EnsureFixedControls(InventoryGui gui, StationRecipeContext context)
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			if (_fixedControls != null && (Object)(object)_fixedControls.Owner == (Object)(object)gui && _fixedControls.Context == context && (Object)(object)_fixedControls.ModeRoot != (Object)null && (Object)(object)_fixedControls.SearchRoot != (Object)null)
			{
				_fixedControls.SearchInput.SetTextWithoutNotify(_searchText);
				_fixedControls.SearchRoot.transform.SetAsLastSibling();
				return;
			}
			if (_fixedControls != null)
			{
				_fixedControls.RestoreRecipeViewport();
				if ((Object)(object)_fixedControls.ModeRoot != (Object)null)
				{
					Object.Destroy((Object)(object)_fixedControls.ModeRoot);
				}
				if ((Object)(object)_fixedControls.SearchRoot != (Object)null)
				{
					Object.Destroy((Object)(object)_fixedControls.SearchRoot);
				}
				_fixedControls = null;
			}
			ModeButtonState[] buttons;
			GameObject modeRoot = CreateModeRoot(gui, context, out buttons);
			TMP_InputField input;
			RectTransform recipeViewport;
			Vector2 viewportOffsetMin;
			Vector2 viewportOffsetMax;
			GameObject searchRoot = CreateSearchRoot(gui, out input, out recipeViewport, out viewportOffsetMin, out viewportOffsetMax);
			_fixedControls = new FixedControls(gui, context, modeRoot, searchRoot, input, buttons, recipeViewport, viewportOffsetMin, viewportOffsetMax);
			input.SetTextWithoutNotify(_searchText);
		}

		private static GameObject CreateModeRoot(InventoryGui gui, StationRecipeContext context, out ModeButtonState[] buttons)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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)
			RectTransform val = (RectTransform)((Component)gui.m_tabUpgrade).transform;
			RectTransform crafting = gui.m_crafting;
			GameObject val2 = new GameObject("InventoryUX_Crafting_Modes", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent((Transform)(object)crafting, false);
			val2.transform.SetAsLastSibling();
			RectTransform val3 = (RectTransform)val2.transform;
			Rect rect = val.rect;
			if (!(Mathf.Abs(((Rect)(ref rect)).width) > 1f))
			{
				_ = val.sizeDelta;
			}
			else
			{
				rect = val.rect;
				_ = ((Rect)(ref rect)).width;
			}
			rect = val.rect;
			float num;
			if (!(Mathf.Abs(((Rect)(ref rect)).height) > 1f))
			{
				num = val.sizeDelta.y;
			}
			else
			{
				rect = val.rect;
				num = ((Rect)(ref rect)).height;
			}
			float num2 = num;
			val3.anchorMin = new Vector2(0.5f, 0.5f);
			val3.anchorMax = new Vector2(0.5f, 0.5f);
			val3.pivot = new Vector2(0f, val.pivot.y);
			val3.sizeDelta = new Vector2(216f, Mathf.Max(25f, num2));
			((Transform)val3).rotation = ((Transform)val).rotation;
			rect = val.rect;
			((Transform)val3).position = ((Transform)val).TransformPoint(new Vector3(((Rect)(ref rect)).xMax + 5f, 0f, 0f));
			string caption = ((context == StationRecipeContext.Food) ? "STAT" : "TYPE");
			buttons = new ModeButtonState[3]
			{
				CreateModeButton(gui, val3, context, DisplayedMode.Default, "DEFAULT", 0),
				CreateModeButton(gui, val3, context, DisplayedMode.Primary, caption, 1),
				CreateModeButton(gui, val3, context, DisplayedMode.Biome, "BIOME", 2)
			};
			return val2;
		}

		private static ModeButtonState CreateModeButton(InventoryGui gui, RectTransform parent, StationRecipeContext context, DisplayedMode mode, string caption, int index)
		{
			//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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InventoryUX_Crafting_Mode_" + caption, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent((Transform)(object)parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(0f, 0.5f);
			val2.anchorMax = new Vector2(0f, 0.5f);
			val2.pivot = new Vector2(0f, 0.5f);
			val2.anchoredPosition = new Vector2((float)index * 73f, 0f);
			val2.sizeDelta = new Vector2(70f, parent.sizeDelta.y);
			Image component = val.GetComponent<Image>();
			ApplyVanillaButtonSprite(gui, component);
			Button component2 = val.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				if (context == StationRecipeContext.Food)
				{
					FoodGroupingMode foodGroupingMode = ((mode != DisplayedMode.Default) ? ((mode == DisplayedMode.Primary) ? FoodGroupingMode.Stat : FoodGroupingMode.Biome) : FoodGroupingMode.Default);
					if (ModConfig.FoodMode == foodGroupingMode)
					{
						return;
					}
					ModConfig.SetFoodMode(foodGroupingMode);
				}
				else
				{
					EquipmentGroupingMode equipmentGroupingMode = ((mode != DisplayedMode.Default) ? ((mode == DisplayedMode.Primary) ? EquipmentGroupingMode.Type : EquipmentGroupingMode.Biome) : EquipmentGroupingMode.Default);
					if (ModConfig.EquipmentMode == equipmentGroupingMode)
					{
						return;
					}
					ModConfig.SetEquipmentMode(equipmentGroupingMode);
				}
				UpdateModeAppearance();
				Refresh(gui);
			});
			TMP_Text label = CreateText(gui, (Transform)(object)val2, "InventoryUX_Crafting_ModeLabel", caption, Vector2.zero, Vector2.zero, 10.5f, Color.white, (TextAlignmentOptions)514, stretch: true);
			return new ModeButtonState(mode, component, label);
		}

		private static GameObject CreateSearchRoot(InventoryGui gui, out TMP_InputField input, out RectTransform recipeViewport, out Vector2 viewportOffsetMin, out Vector2 viewportOffsetMax)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_0103: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Expected O, but got Unknown
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Expected O, but got Unknown
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Expected O, but got Unknown
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform recipeListRoot = gui.m_recipeListRoot;
			Transform parent = ((Transform)recipeListRoot).parent;
			recipeViewport = (RectTransform)(object)(((parent is RectTransform) ? parent : null) ?? throw new InvalidOperationException("The crafting recipe list does not have a RectTransform viewport."));
			Transform parent2 = ((Transform)recipeViewport).parent;
			RectTransform val = (RectTransform)(object)(((parent2 is RectTransform) ? parent2 : null) ?? throw new InvalidOperationException("The crafting recipe viewport does not have a RectTransform parent."));
			viewportOffsetMin = recipeViewport.offsetMin;
			viewportOffsetMax = recipeViewport.offsetMax;
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			recipeViewport.GetWorldCorners(array);
			Vector3 val2 = (array[1] + array[2]) * 0.5f;
			Vector3 val3 = ((Transform)val).InverseTransformPoint(array[1]);
			float num = Mathf.Abs(((Transform)val).InverseTransformPoint(array[2]).x - val3.x);
			GameObject val4 = new GameObject("InventoryUX_Crafting_Search", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(TMP_InputField)
			});
			val4.transform.SetParent((Transform)(object)val, false);
			val4.transform.SetAsLastSibling();
			RectTransform val5 = (RectTransform)val4.transform;
			val5.anchorMin = new Vector2(0.5f, 0.5f);
			val5.anchorMax = new Vector2(0.5f, 0.5f);
			val5.pivot = new Vector2(0.5f, 1f);
			val5.sizeDelta = new Vector2(num, 29f);
			((Transform)val5).rotation = ((Transform)recipeViewport).rotation;
			((Transform)val5).position = val2 + ((Transform)recipeViewport).TransformVector(new Vector3(0f, -2f, 0f));
			Image component = val4.GetComponent<Image>();
			ApplyVanillaButtonSprite(gui, component);
			((Graphic)component).color = SearchBrown;
			AddSearchBorder(val5);
			GameObject val6 = new GameObject("InventoryUX_Crafting_SearchViewport", new Type[2]
			{
				typeof(RectTransform),
				typeof(RectMask2D)
			});
			val6.transform.SetParent((Transform)(object)val5, false);
			RectTransform val7 = (RectTransform)val6.transform;
			val7.anchorMin = Vector2.zero;
			val7.anchorMax = Vector2.one;
			val7.offsetMin = new Vector2(8f, 2f);
			val7.offsetMax = new Vector2(-27f, -2f);
			TextMeshProUGUI val8 = (TextMeshProUGUI)CreateText(gui, (Transform)(object)val7, "InventoryUX_Crafting_SearchText", string.Empty, Vector2.zero, Vector2.zero, 12f, new Color(0.92f, 0.9f, 0.84f), (TextAlignmentOptions)4097, stretch: true);
			((TMP_Text)val8).fontStyle = (FontStyles)0;
			TextMeshProUGUI val9 = (TextMeshProUGUI)CreateText(gui, (Transform)(object)val7, "InventoryUX_Crafting_SearchPlaceholder", "Search recipes", Vector2.zero, Vector2.zero, 12f, new Color(0.66f, 0.63f, 0.57f), (TextAlignmentOptions)4097, stretch: true);
			((TMP_Text)val9).fontStyle = (FontStyles)0;
			input = val4.GetComponent<TMP_InputField>();
			((Selectable)input).targetGraphic = (Graphic)(object)component;
			input.textViewport = val7;
			input.textComponent = (TMP_Text)(object)val8;
			input.placeholder = (Graphic)(object)val9;
			input.lineType = (LineType)0;
			input.contentType = (ContentType)0;
			input.characterLimit = 64;
			input.caretColor = Gold;
			input.selectionColor = new Color(ActiveBlue.r, ActiveBlue.g, ActiveBlue.b, 0.55f);
			((UnityEvent<string>)(object)input.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
			{
				_searchText = value ?? string.Empty;
				Refresh(gui);
			});
			CreateClearSearchButton(gui, val5, input);
			return val4;
		}

		private static void AddSearchBorder(RectTransform parent)
		{
			//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)
			//IL_002e: 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_0057: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_0103: 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)
			AddBorderLine(parent, "Top", new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, -1f), new Vector2(0f, 1f));
			AddBorderLine(parent, "Bottom", new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0f, 1f), new Vector2(0f, 1f));
			AddBorderLine(parent, "Left", new Vector2(0f, 0f), new Vector2(0f, 1f), new Vector2(1f, 0f), new Vector2(1f, 0f));
			AddBorderLine(parent, "Right", new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(-1f, 0f), new Vector2(1f, 0f));
		}

		private static void AddBorderLine(RectTransform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 position, Vector2 size)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InventoryUX_Crafting_SearchBorder" + name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent((Transform)(object)parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = anchorMin;
			val2.anchorMax = anchorMax;
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.anchoredPosition = position;
			val2.sizeDelta = size;
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(Gold.r, Gold.g, Gold.b, 0.62f);
			((Graphic)component).raycastTarget = false;
		}

		private static void CreateClearSearchButton(InventoryGui gui, RectTransform parent, TMP_InputField input)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00b9: 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_00df: 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_010b: Expected O, but got Unknown
			//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_013a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InventoryUX_Crafting_SearchClear", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent((Transform)(object)parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(1f, 0f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(1f, 0.5f);
			val2.anchoredPosition = Vector2.zero;
			val2.sizeDelta = new Vector2(25f, 0f);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(0f, 0f, 0f, 0.01f);
			Button component2 = val.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				_searchText = string.Empty;
				input.SetTextWithoutNotify(string.Empty);
				Refresh(gui);
			});
			CreateText(gui, (Transform)(object)val2, "InventoryUX_Crafting_SearchClearLabel", "×", Vector2.zero, Vector2.zero, 16f, new Color(0.84f, 0.8f, 0.7f), (TextAlignmentOptions)514, stretch: true);
		}

		private static void SetFixedControlsVisible(bool visible)
		{
			if (_fixedControls != null)
			{
				if (visible)
				{
					_fixedControls.ReserveSearchSpace();
				}
				else
				{
					_fixedControls.RestoreRecipeViewport();
				}
				_fixedControls.ModeRoot.SetActive(visible);
				_fixedControls.SearchRoot.SetActive(visible);
				if (visible)
				{
					_fixedControls.SearchRoot.transform.SetAsLastSibling();
				}
			}
		}

		private static void HideFixedControls(InventoryGui gui)
		{
			if (_fixedControls != null && (Object)(object)_fixedControls.Owner == (Object)(object)gui)
			{
				SetFixedControlsVisible(visible: false);
			}
		}

		private static void UpdateModeAppearance()
		{
			//IL_006f: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if (_fixedControls != null)
			{
				DisplayedMode displayedMode = ((_fixedControls.Context != StationRecipeContext.Food) ? ((ModConfig.EquipmentMode != EquipmentGroupingMode.Default) ? ((ModConfig.EquipmentMode == EquipmentGroupingMode.Type) ? DisplayedMode.Primary : DisplayedMode.Biome) : DisplayedMode.Default) : ((ModConfig.FoodMode != FoodGroupingMode.Default) ? ((ModConfig.FoodMode == FoodGroupingMode.Stat) ? DisplayedMode.Primary : DisplayedMode.Biome) : DisplayedMode.Default));
				for (int i = 0; i < _fixedControls.ModeButtons.Length; i++)
				{
					ModeButtonState obj = _fixedControls.ModeButtons[i];
					bool flag = obj.Mode == displayedMode;
					((Graphic)obj.Background).color = (flag ? ActiveBlue : InactiveBrown);
					((Graphic)obj.Label).color = (Color)(flag ? Color.white : new Color(0.78f, 0.75f, 0.69f));
				}
			}
		}

		private static void ApplyVanillaButtonSprite(InventoryGui gui, Image image)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Image val = (((Object)(object)gui.m_tabCraft != (Object)null) ? ((Component)gui.m_tabCraft).GetComponent<Image>() : null);
			image.sprite = (((Object)(object)val != (Object)null) ? val.sprite : null);
			image.type = (Type)(((Object)(object)val != (Object)null) ? ((int)val.type) : 0);
		}

		private static void CreateHeader(InventoryGui gui, RectTransform root, string label, float y)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)CreateText(gui, (Transform)(object)root, "InventoryUX_Recipe_Header_" + label, label.ToUpperInvariant(), new Vector2(4f, 0f - y), new Vector2(0f, 22f), 13f, Gold, (TextAlignmentOptions)4097).transform;
			val.anchorMax = new Vector2(1f, 1f);
			val.sizeDelta = new Vector2(-8f, 22f);
			if (ModConfig.ShowSeparators.Value)
			{
				GameObject val2 = new GameObject("InventoryUX_Recipe_HeaderLine", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val2.transform.SetParent((Transform)(object)root, false);
				RectTransform val3 = (RectTransform)val2.transform;
				val3.anchorMin = new Vector2(0f, 1f);
				val3.anchorMax = new Vector2(1f, 1f);
				val3.pivot = new Vector2(0f, 1f);
				val3.anchoredPosition = new Vector2(4f, 0f - (y + 22f - 2f));
				val3.sizeDelta = new Vector2(-8f, 1f);
				Image component = val2.GetComponent<Image>();
				((Graphic)component).color = new Color(Gold.r, Gold.g, Gold.b, 0.45f);
				((Graphic)component).raycastTarget = false;
			}
		}

		private static void CreateStatus(InventoryGui gui, RectTransform root, string label, float y)
		{
			//IL_000f: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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)
			RectTransform val = (RectTransform)CreateText(gui, (Transform)(object)root, "InventoryUX_Recipe_Status", label, new Vector2(4f, 0f - y), new Vector2(0f, 22f), 12f, new Color(0.72f, 0.69f, 0.62f), (TextAlignmentOptions)4097).transform;
			val.anchorMax = new Vector2(1f, 1f);
			val.sizeDelta = new Vector2(-8f, 22f);
		}

		private static void AddMealStats(InventoryGui gui, RecipePairView view)
		{
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = view.Element.transform;
			Transform val = transform.Find("InventoryUX_Recipe_FoodStats");
			TMP_Text val2;
			if ((Object)(object)val != (Object)null)
			{
				val2 = ((Component)val).GetComponent<TMP_Text>();
			}
			else
			{
				float num = 42f;
				Transform obj = transform.Find("name");
				RectTransform val3 = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if (val3 != null)
				{
					Vector3[] array = (Vector3[])(object)new Vector3[4];
					val3.GetWorldCorners(array);
					RectTransform val4 = (RectTransform)transform;
					float x = ((Transform)val4).InverseTransformPoint(array[0]).x;
					Rect rect = val4.rect;
					float num2 = x - ((Rect)(ref rect)).xMin;
					if (num2 > 0f)
					{
						rect = val4.rect;
						if (num2 < ((Rect)(ref rect)).width)
						{
							num = num2;
						}
					}
					rect = val3.rect;
					if (((Rect)(ref rect)).height > 20f)
					{
						val3.SetSizeWithCurrentAnchors((Axis)1, 20f);
					}
					val3.anchoredPosition += new Vector2(0f, 7f);
				}
				val2 = CreateText(gui, transform, "InventoryUX_Recipe_FoodStats", string.Empty, Vector2.zero, Vector2.zero, 11f, Color.white, (TextAlignmentOptions)4097, stretch: true);
				RectTransform val5 = (RectTransform)val2.transform;
				val5.anchorMin = new Vector2(0f, 0f);
				val5.anchorMax = new Vector2(1f, 0f);
				val5.pivot = new Vector2(0f, 0f);
				val5.offsetMin = new Vector2(num, 0f);
				val5.offsetMax = new Vector2(-4f, 17f);
				val2.fontStyle = (FontStyles)1;
				val2.richText = true;
				val2.outlineWidth = 0.1f;
				val2.outlineColor = new Color32((byte)25, (byte)15, (byte)10, (byte)230);
			}
			List<string> list = new List<string>(3);
			if (view.Facts.Health > 0f)
			{
				list.Add("<color=#FF9C7A>HP " + Mathf.RoundToInt(view.Facts.Health) + "</color>");
			}
			if (view.Facts.Stamina > 0f)
			{
				list.Add("<color=#FFE071>STAM " + Mathf.RoundToInt(view.Facts.Stamina) + "</color>");
			}
			if (view.Facts.Eitr > 0f)
			{
				list.Add("<color=#D7A5FF>EITR " + Mathf.RoundToInt(view.Facts.Eitr) + "</color>");
			}
			val2.text = string.Join("   ", list);
		}

		private static TMP_Text CreateText(InventoryGui gui, Transform parent, string name, string content, Vector2 position, Vector2 size, float fontSize, Color color, TextAlignmentOptions alignment, bool stretch = false)
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = (Vector2)(stretch ? Vector2.zero : new Vector2(0f, 1f));
			val2.anchorMax = (Vector2)(stretch ? Vector2.one : new Vector2(0f, 1f));
			val2.pivot = (stretch ? new Vector2(0.5f, 0.5f) : new Vector2(0f, 1f));
			val2.anchoredPosition = position;
			val2.sizeDelta = size;
			TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = content;
			((TMP_Text)component).font = (((Object)(object)gui.m_recipeName != (Object)null) ? gui.m_recipeName.font : null);
			((TMP_Text)component).fontSize = fontSize;
			((TMP_Text)component).fontStyle = (FontStyles)1;
			((Graphic)component).color = color;
			((TMP_Text)component).alignment = alignment;
			((TMP_Text)component).textWrappingMode = (TextWrappingModes)0;
			((Graphic)component).raycastTarget = false;
			return (TMP_Text)(object)component;
		}

		private static RecipeFacts ReadFacts(Recipe recipe, int originalIndex, FoodStationKind foodStationKind)
		{
			SharedData shared = recipe.m_item.m_itemData.m_shared;
			List<string> list = new List<string>();
			if (recipe.m_resources != null)
			{
				for (int i = 0; i < recipe.m_resources.Length; i++)
				{
					ItemDrop val = recipe.m_resources[i]?.m_resItem;
					if ((Object)(object)val != (Object)null)
					{
						list.Add(((Object)((Component)val).gameObject).name);
						list.Add(val.m_itemData.m_shared.m_name);
					}
				}
			}
			string displayName = ((Localization.instance != null) ? Localization.instance.Localize(shared.m_name) : shared.m_name);
			ResolvedFoodStats resolvedFoodStats = ((foodStationKind != FoodStationKind.Mead) ? FoodStatsResolver.Resolve(recipe.m_item) : default(ResolvedFoodStats));
			float health = (resolvedFoodStats.Resolved ? resolvedFoodStats.Health : shared.m_food);
			float stamina = (resolvedFoodStats.Resolved ? resolvedFoodStats.Stamina : shared.m_foodStamina);
			float eitr = (resolvedFoodStats.Resolved ? resolvedFoodStats.Eitr : shared.m_foodEitr);
			return new RecipeFacts(((Object)((Component)recipe.m_item).gameObject).name, displayName, ((object)Unsafe.As<ItemType, ItemType>(ref shared.m_itemType)/*cast due to .constrained prefix*/).ToString(), ((object)Unsafe.As<SkillType, SkillType>(ref shared.m_skillType)/*cast due to .constrained prefix*/).ToString(), list, health, stamina, eitr, originalIndex, resolvedFoodStats.IsFeast);
		}

		private static void EnsurePairAccessors(object pair)
		{
			Type type = pair.GetType();
			if (!(_pairType == type))
			{
				_pairType = type;
				_recipeProperty = type.GetProperty("Recipe", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_elementProperty = type.GetProperty("InterfaceElement", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (_recipeProperty == null || _elementProperty == null)
				{
					throw new MissingMemberException(type.FullName, "Recipe/InterfaceElement");
				}
			}
		}

		private static void ClearContentDecorations(RectTransform root)
		{
			for (int num = ((Transform)root).childCount - 1; num >= 0; num--)
			{
				Transform child = ((Transform)root).GetChild(num);
				if (((Object)child).name.StartsWith("InventoryUX_Recipe_", StringComparison.Ordinal))
				{
					((Component)child).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)child).gameObject);
				}
			}
		}

		private static void Refresh(InventoryGui gui)
		{
			RefreshMethod.Invoke(gui, new object[1] { false });
		}
	}
	internal static class UnlockVisibilityService
	{
		internal static bool IsKnownRecipe(Player? player, Recipe? recipe)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)recipe == (Object)null || (Object)(object)recipe.m_item == (Object)null)
			{
				return false;
			}
			return player.IsRecipeKnown(recipe.m_item.m_itemData.m_shared.m_name);
		}

		internal static bool IsKnownPiece(Player? player, Piece? piece)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)piece == (Object)null || string.IsNullOrEmpty(piece.m_name))
			{
				return false;
			}
			return player.IsRecipeKnown(piece.m_name);
		}
	}
}
namespace InventoryUX.Patches
{
	[HarmonyPatch]
	internal static class HammerGridWidthPatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return Require(typeof(Hud), "UpdatePieceList");
			yield return Require(typeof(Hud), "GetSelectedGrid");
			yield return Require(typeof(PieceTable), "GetPiece", typeof(PieceCategory), typeof(Vector2Int));
			yield return Require(typeof(PieceTable), "GetPieceIndex");
			yield return Require(typeof(PieceTable), "LeftPiece");
			yield return Require(typeof(PieceTable), "RightPiece");
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
		{
			bool flag = original.DeclaringType == typeof(PieceTable) && original.Name == "LeftPiece";
			int nativeValue = (flag ? 14 : 15);
			MethodInfo replacement = AccessTools.PropertyGetter(typeof(HammerGridDimensions), flag ? "MaxX" : "Width");
			return GridConstantRewriter.Replace(instructions, original, nativeValue, replacement);
		}

		private static MethodBase Require(Type type, string name, params Type[]? parameters)
		{
			return ((parameters == null || parameters.Length == 0) ? AccessTools.Method(type, name, (Type[])null, (Type[])null) : AccessTools.Method(type, name, parameters, (Type[])null)) ?? throw new MissingMethodException(type.FullName, name);
		}
	}
	[HarmonyPatch]
	internal static class HammerGridHeightPatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return Require(typeof(Hud), "UpdatePieceList");
			yield return Require(typeof(Hud), "GetSelectedGrid");
			yield return Require(typeof(PieceTable), "UpPiece");
			yield return Require(typeof(PieceTable), "DownPiece");
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
		{
			bool flag = original.DeclaringType == typeof(PieceTable) && original.Name == "UpPiece";
			int nativeValue = (flag ? 5 : 6);
			MethodInfo replacement = AccessTools.PropertyGetter(typeof(HammerGridDimensions), flag ? "MaxY" : "Height");
			return GridConstantRewriter.Replace(instructions, original, nativeValue, replacement);
		}

		private static MethodBase Require(Type type, string name)
		{
			return AccessTools.Method(type, name, (Type[])null, (Type[])null) ?? throw new MissingMethodException(type.FullName, name);
		}
	}
	internal static class GridConstantRewriter
	{
		internal static IEnumerable<CodeInstruction> Replace(IEnumerable<CodeInstruction> instructions, MethodBase original, int nativeValue, MethodInfo replacement)
		{
			List<CodeInstruction> list = new List<CodeInstruction>();
			int num = 0;
			foreach (CodeInstruction instruction in instructions)
			{
				if (LoadsInt32(instruction, nativeValue))
				{
					instruction.opcode = OpCodes.Call;
					instruction.operand = replacement;
					num++;
				}
				list.Add(instruction);
			}
			if (num == 0)
			{
				throw new InvalidOperationException($"No {nativeValue} grid constant found in {original.DeclaringType?.FullName}.{original.Name}.");
			}
			return list;
		}

		private static bool LoadsInt32(CodeInstruction instruction, int expected)
		{
			if (instruction.opcode == OpCodes.Ldc_I4_M1)
			{
				return expected == -1;
			}
			if (instruction.opcode == OpCodes.Ldc_I4_0)
			{
				return expected == 0;
			}
			if (instruction.opcode == OpCodes.Ldc_I4_1)
			{
				return expected == 1;
			}
			if (instruction.opcode == OpCodes.Ldc_I4_2)
			{
				return expected == 2;
			}
			if (instruction.opcode == OpCodes.Ldc_I4_3)
			{
				return expected == 3;
			}
			if (instruction.opcode == OpCodes.Ldc_I4_4)
			{
				return expected == 4;
			}
			if (instruction.opcode == OpCodes.Ldc_I4_5)
			{
				return expected == 5;
			}
			if (instruction.opcode == OpCodes.Ldc_I4_6)
			{
				return expected == 6;
			}
			if (instruction.opcode == OpCodes.Ldc_I4_7)
			{
				return expected == 7;
			}
			if (instruction.opcode == OpCodes.Ldc_I4_8)
			{
				return expected == 8;
			}
			if (instruction.opcode != OpCodes.Ldc_I4 && instruction.opcode != OpCodes.Ldc_I4_S)
			{
				return false;
			}
			if (instruction.operand != null)
			{
				return Convert.ToInt32(instruction.operand) == expected;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeList")]
	internal static class InventoryGuiUpdateRecipeListPatch
	{
		private static void Postfix(InventoryGui __instance, List<Recipe> recipes)
		{
			if (!ModConfig.Enabled.Value || !ModConfig.OrganizeRecipes.Value)
			{
				RecipeOrganizer.Cleanup(__instance);
				return;
			}
			try
			{
				RecipeOrganizer.Organize(__instance);
			}
			catch (Exception ex)
			{
				Plugin.LogInstance.LogWarning((object)("Recipe organization skipped: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(PieceTable), "UpdateAvailable")]
	internal static class PieceTableUpdateAvailablePatch
	{
		private static void Postfix(PieceTable __instance)
		{
			if (!ModConfig.Enabled.Value || !HammerGroupDecorations.UseModView)
			{
				return;
			}
			try
			{
				HammerOrganizer.ReorderAvailablePieces(__instance);
			}
			catch (Exception arg)
			{
				Plugin.LogInstance.LogWarning((object)$"Hammer organization skipped: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(Hud), "UpdatePieceList")]
	internal static class HudUpdatePieceListPatch
	{
		private static void Postfix(Hud __instance, Player player, PieceCategory category)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!ModConfig.Enabled.Value)
				{
					HammerGridSizer.Restore();
					HammerGroupDecorations.Shutdown();
					return;
				}
				HammerGridSizer.Apply(__instance);
				List<Piece> buildPieces = player.GetBuildPieces();
				if (buildPieces != null)
				{
					HammerGroupDecorations.Apply(__instance, buildPieces, category);
				}
			}
			catch (Exception arg)
			{
				Plugin.LogInstance.LogWarning((object)$"Hammer labels skipped: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(PieceTable), "LeftPiece")]
	internal static class PieceTableLeftPiecePatch
	{
		private static bool Prefix(PieceTable __instance)
		{
			return !HammerGroupDecorations.TryNavigate(__instance, -1, 0);
		}
	}
	[HarmonyPatch(typeof(PieceTable), "RightPiece")]
	internal static class PieceTableRightPiecePatch
	{
		private static bool Prefix(PieceTable __instance)
		{
			return !HammerGroupDecorations.TryNavigate(__instance, 1, 0);
		}
	}
	[HarmonyPatch(typeof(PieceTable), "UpPiece")]
	internal static class PieceTableUpPiecePatch
	{
		private static bool Prefix(PieceTable __instance)
		{
			return !HammerGroupDecorations.TryNavigate(__instance, 0, -1);
		}
	}
	[HarmonyPatch(typeof(PieceTable), "DownPiece")]
	internal static class PieceTableDownPiecePatch
	{
		private static bool Prefix(PieceTable __instance)
		{
			return !HammerGroupDecorations.TryNavigate(__instance, 0, 1);
		}
	}
}
namespace InventoryUX.Core
{
	internal static class BiomeClassifier
	{
		private static readonly IReadOnlyDictionary<ProgressionBiome, string[]> Markers = new Dictionary<ProgressionBiome, string[]>
		{
			[ProgressionBiome.Ashlands] = new string[14]
			{
				"ashlands", "ashwood", "asksvin", "bellfragment", "blackwood", "bonemaw", "celestialfeather", "charred", "flametal", "grausten",
				"morgen", "proustite", "sulfur", "vineberry"
			},
			[ProgressionBiome.Mistlands] = new string[14]
			{
				"blackcore", "carapace", "dvergr", "eitr", "haremeat", "jotunpuffs", "magecap", "mandible", "refinedeitr", "royaljelly",
				"scalehide", "seeker", "softtissue", "yggdrasil"
			},
			[ProgressionBiome.Plains] = new string[14]
			{
				"barley", "blackmetal", "bloodpudding", "bread", "cloudberry", "deathsquito", "flax", "linen", "lox", "needle",
				"padded", "porcupine", "tar", "wolfjerky"
			},
			[ProgressionBiome.Mountains] = new string[12]
			{
				"crystal", "drake", "fenring", "fenris", "freeze", "frost", "golem", "moder", "obsidian", "onion",
				"silver", "wolf"
			},
			[ProgressionBiome.Ocean] = new string[5] { "abyssal", "barnacle", "chitin", "leviathan", "serpent" },
			[ProgressionBiome.Swamp] = new string[14]
			{
				"ancientbark", "bloodbag", "bonemass", "chain", "draugr", "entrails", "guck", "iron", "ooze", "root",
				"scrapiron", "surtling", "turnip", "witheredbone"
			},
			[ProgressionBiome.BlackForest] = new string[11]
			{
				"blueberry", "bronze", "carrot", "copper", "corewood", "deerhide", "elder", "finewood", "greydwarf", "tin",
				"troll"
			},
			[ProgressionBiome.Meadows] = new string[13]
			{
				"boar", "club", "dandelion", "deer", "feather", "flint", "leatherscraps", "mushroom", "necktail", "raspberry",
				"resin", "stone", "wood"
			}
		};

		internal static ProgressionBiome Classify(string itemId, IReadOnlyList<string> ingredients)
		{
			ProgressionBiome latest = ProgressionBiome.Other;
			Consider(itemId, ref latest);
			for (int i = 0; i < ingredients.Count; i++)
			{
				Consider(ingredients[i], ref latest);
			}
			return latest;
		}

		internal static RecipeGroup ToGroup(ProgressionBiome biome)
		{
			return biome switch
			{
				ProgressionBiome.Ashlands => new RecipeGroup("Ashlands", 0), 
				ProgressionBiome.Mistlands => new RecipeGroup("Mistlands", 1), 
				ProgressionBiome.Plains => new RecipeGroup("Plains", 2), 
				ProgressionBiome.Mountains => new RecipeGroup("Mountains", 3), 
				ProgressionBiome.Ocean => new RecipeGroup("Ocean", 4), 
				ProgressionBiome.Swamp => new RecipeGroup("Swamp", 5), 
				ProgressionBiome.BlackForest => new RecipeGroup("Black Forest", 6), 
				ProgressionBiome.Meadows => new RecipeGroup("Meadows", 7), 
				_ => new RecipeGroup("Other", 8), 
			};
		}

		internal static RecipeGroup GetGroup(RecipeFacts facts)
		{
			return ToGroup(Classify(facts.Id, facts.IngredientIds));
		}

		private static void Consider(string? raw, ref ProgressionBiome latest)
		{
			string text = Normalize(raw);
			if (text.Length == 0)
			{
				return;
			}
			foreach (KeyValuePair<ProgressionBiome, string[]> marker in Markers)
			{
				for (int i = 0; i < marker.Value.Length; i++)
				{
					if (text.IndexOf(marker.Value[i], StringComparison.Ordinal) >= 0)
					{
						if (marker.Key > latest)
						{
							latest = marker.Key;
						}
						break;
					}
				}
			}
		}

		private static string Normalize(string? value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			foreach (char c in value)
			{
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = char.ToLowerInvariant(c);
				}
			}
			return new string(array, 0, length);
		}
	}
	internal enum EquipmentGroupingMode
	{
		Default,
		Type,
		Biome
	}
	internal enum FoodGroupingMode
	{
		Default,
		Stat,
		Biome
	}
	internal enum FoodRole
	{
		Health,
		Stamina,
		Eitr,
		Balanced
	}
	internal enum MeadRole
	{
		Health,
		Stamina,
		Utility
	}
	internal enum ProgressionBiome
	{
		Other = -1,
		Meadows,
		BlackForest,
		Swamp,
		Ocean,
		Mountains,
		Plains,
		Mistlands,
		Ashlands
	}
	internal sealed class RecipeFacts
	{
		internal string Id { get; }

		internal string DisplayName { get; }

		internal string ItemType { get; }

		internal string Skill { get; }

		internal IReadOnlyList<string> IngredientIds { get; }

		internal float Health { get; }

		internal float Stamina { get; }

		internal float Eitr { get; }

		internal int OriginalIndex { get; }

		internal bool IsFeast { get; }

		internal bool IsFood
		{
			get
			{
				if (!(Health > 0f) && !(Stamina > 0f))
				{
					return Eitr > 0f;
				}
				return true;
			}
		}

		internal RecipeFacts(string id, string displayName, string itemType, string skill, IReadOnlyList<string> ingredientIds, float health, float stamina, float eitr, int originalIndex, bool isFeast = false)
		{
			Id = id ?? string.Empty;
			DisplayName = displayName ?? string.Empty;
			ItemType = itemType ?? string.Empty;
			Skill = skill ?? string.Empty;
			IngredientIds = ingredientIds ?? Array.Empty<string>();
			Health = health;
			Stamina = stamina;
			Eitr = eitr;
			OriginalIndex = originalIndex;
			IsFeast = isFeast;
		}
	}
	internal readonly struct RecipeGroup
	{
		internal string Label { get; }

		internal int Order { get; }

		internal RecipeGroup(string label, int order)
		{
			Label = label;
			Order = order;
		}
	}
	internal static class FoodClassifier
	{
		internal const float SpecialistRatio = 1.2f;

		internal static FoodRole Classify(float health, float stamina, float eitr)
		{
			if (eitr > 0f)
			{
				return FoodRole.Eitr;
			}
			if (health <= 0f && stamina <= 0f)
			{
				return FoodRole.Balanced;
			}
			if (health >= stamina * 1.2f)
			{
				return FoodRole.Health;
			}
			if (stamina >= health * 1.2f)
			{
				return FoodRole.Stamina;
			}
			return FoodRole.Balanced;
		}

		internal static RecipeGroup ToGroup(FoodRole role)
		{
			return role switch
			{
				FoodRole.Health => new RecipeGroup("Health", 0), 
				FoodRole.Stamina => new RecipeGroup("Stamina", 1), 
				FoodRole.Eitr => new RecipeGroup("Eitr", 2), 
				_ => new RecipeGroup("Balanced", 3), 
			};
		}

		internal static float Strength(RecipeFacts facts)
		{
			if (facts.IsFeast)
			{
				return facts.Health + facts.Stamina + facts.Eitr;
			}
			return Classify(facts.Health, facts.Stamina, facts.Eitr) switch
			{
				FoodRole.Health => facts.Health, 
				FoodRole.Stamina => facts.Stamina, 
				FoodRole.Eitr => facts.Eitr, 
				_ => facts.Health + facts.Stamina + facts.Eitr, 
			};
		}
	}
	internal enum HammerSortCategory
	{
		Misc,
		Building,
		HeavyBuilding,
		Furniture
	}
	internal readonly struct HammerSortKey : IComparable<HammerSortKey>
	{
		internal int Progression { get; }

		internal int Family { get; }

		internal int Variation { get; }

		internal int Cosmetic { get; }

		internal HammerSortKey(int progression, int family, int variation, int cosmetic)
		{
			Progression = progression;
			Family = family;
			Variation = variation;
			Cosmetic = cosmetic;
		}

		public int CompareTo(HammerSortKey other)
		{
			int num = Progression.CompareTo(other.Progression);
			if (num != 0)
			{
				return num;
			}
			num = Family.CompareTo(other.Family);
			if (num != 0)
			{
				return num;
			}
			num = Variation.CompareTo(other.Variation);
			if (num == 0)
			{
				return Cosmetic.CompareTo(other.Cosmetic);
			}
			return num;
		}
	}
	internal static class HammerProgressionSorter
	{
		internal static int MiscTravelOrder(string itemId)
		{
			string text = Normalize(itemId);
			if (ContainsAny(text, "cartography", "maptable"))
			{
				return -1;
			}
			if (text.Contains("cart"))
			{
				return 0;
			}
			if (text.Contains("raft"))
			{
				return 10;
			}
			if (text.Contains("karve"))
			{
				return 20;
			}
			if (text.Contains("longship"))
			{
				return 30;
			}
			if (ContainsAny(text, "drakkar", "ashlandship", "vikingshipashlands"))
			{
				return 40;
			}
			if (ContainsAny(text, "portal", "teleport"))
			{
				return 50;
			}
			if (ContainsAny(text, "boat", "ship"))
			{
				return 60;
			}
			return -1;
		}

		internal static int MiscDefenseOrder(string itemId)
		{
			string value = Normalize(itemId);
			if (ContainsAny(value, "roundpolefence", "roundpole", "woodfence"))
			{
				return 0;
			}
			if (ContainsAny(value, "shieldgenerator", "shieldgen"))
			{
				return 100;
			}
			return 50;
		}

		internal static HammerSortKey Create(HammerSortCategory category, string itemId, IReadOnlyList<string> requirements)
		{
			string text = Normalize(itemId);
			int progression = ProgressionOrder(BiomeClassifier.Classify(text, requirements));
			if (IsSeasonal(text))
			{
				progression = 90;
			}
			else if (IsSpecial(text))
			{
				progression = 80;
			}
			return new HammerSortKey(progression, FamilyOrder(category, text), VariationOrder(text), CosmeticOrder(text));
		}

		private static int ProgressionOrder(ProgressionBiome biome)
		{
			return biome switch
			{
				ProgressionBiome.Meadows => 0, 
				ProgressionBiome.BlackForest => 10, 
				ProgressionBiome.Swamp => 20, 
				ProgressionBiome.Ocean => 25, 
				ProgressionBiome.Mountains => 30, 
				ProgressionBiome.Plains => 40, 
				ProgressionBiome.Mistlands => 50, 
				ProgressionBiome.Ashlands => 60, 
				_ => 70, 
			};
		}

		private static int FamilyOrder(HammerSortCategory category, string id)
		{
			switch (category)
			{
			case HammerSortCategory.Misc:
				return MiscFamilyOrder(id);
			case HammerSortCategory.Building:
			case HammerSortCategory.HeavyBuilding:
				return BuildingFamilyOrder(id);
			case HammerSortCategory.Furniture:
				return FurnitureFamilyOrder(id);
			default:
				return 500;
			}
		}

		private static int MiscFamilyOrder(string id)
		{
			int num = MiscTravelOrder(id);
			if (num >= 0)
			{
				return num;
			}
			if (ContainsAny(id, "campfire", "firepit", "bonfire"))
			{
				return 30;
			}
			if (id.Contains("hearth"))
			{
				return 31;
			}
			if (id.Contains("brazier"))
			{
				return 32;
			}
			if (ContainsAny(id, "fence", "palisade", "barricade"))
			{
				return 40;
			}
			if (ContainsAny(id, "stake", "spike"))
			{
				return 41;
			}
			if (id.Contains("trap"))
			{
				return 42;
			}
			if (ContainsAny(id, "shieldgenerator", "shieldgen"))
			{
				return 43;
			}
			if (id.Contains("ballista"))
			{
				return 50;
			}
			if (id.Contains("catapult"))
			{
				return 51;
			}
			if (id.Contains("batteringram"))
			{
				return 52;
			}
			if (ContainsAny(id, "cannon", "turret"))
			{
				return 53;
			}
			if (ContainsAny(id, "workbench", "station", "table"))
			{
				return 60;
			}
			if (ContainsAny(id, "plant", "garden", "crop", "seed", "cultiv"))
			{
				return 70;
			}
			if (ContainsAny(id, "sign", "marker", "cartography", "maptable"))
			{
				return 80;
			}
			return 90;
		}

		private static int BuildingFamilyOrder(string id)
		{
			if (id.Contains("roofcross") || (id.Contains("roof") && id.Contains("cross")))
			{
				return 9;
			}
			if (id.Contains("beam"))
			{
				return 0;
			}
			if (id.Contains("pole"))
			{
				return 1;
			}
			if (ContainsAny(id, "pillar", "column"))
			{
				return 2;
			}
			if (ContainsAny(id, "foundation", "base"))
			{
				return 3;
			}
			if (id.Contains("floor"))
			{
				return 10;
			}
			if (id.Contains("tile"))
			{
				return 11;
			}
			if (ContainsAny(id, "wall", "halfwall"))
			{
				return 20;
			}
			if (id.Contains("roof"))
			{
				return 30;
			}
			if (ContainsAny(id, "stair", "staircase"))
			{
				return 40;
			}
			if (id.Contains("ladder"))
			{
				return 41;
			}
			if (id.Contains("door"))
			{
				return 50;
			}
			if (id.Contains("gate"))
			{
				return 51;
			}
			if (id.Contains("window"))
			{
				return 52;
			}
			if (id.Contains("arch"))
			{
				return 53;
			}
			return 60;
		}

		private static int FurnitureFamilyOrder(string id)
		{
			if (id.Contains("chest"))
			{
				return 0;
			}
			if (ContainsAny(id, "crate", "storage"))
			{
				return 1;
			}
			if (id.Contains("stool"))
			{
				return 10;
			}
			if (id.Contains("chair"))
			{
				return 11;
			}
			if (id.Contains("bench"))
			{
				return 12;
			}
			if (id.Contains("throne"))
			{
				return 13;
			}
			if (ContainsAny(id, "table", "desk"))
			{
				return 20;
			}
			if (id.Contains("bed"))
			{
				return 21;
			}
			if (ContainsAny(id, "torch", "fire"))
			{
				return 30;
			}
			if (id.Contains("sconce"))
			{
				return 31;
			}
			if (id.Contains("brazier"))
			{
				return 32;
			}
			if (ContainsAny(id, "lamp", "lantern"))
			{
				return 33;
			}
			if (id.Contains("itemstand"))
			{
				return 40;
			}
			if (id.Contains("armorstand"))
			{
				return 41;
			}
			if (ContainsAny(id, "rug", "carpet"))
			{
				return 80;
			}
			if (id.Contains("banner"))
			{
				return 90;
			}
			return 50;
		}

		private static int VariationOrder(string id)
		{
			if (ContainsAny(id, "extension", "upgrade", "improvement"))
			{
				int num = TrailingNumber(id);
				return 100 + ((num >= 0) ? num : 0);
			}
			if (ContainsAny(id, "1x1", "1m", "small", "short"))
			{
				return 0;
			}
			if (ContainsAny(id, "2x2", "2m"))
			{
				return 10;
			}
			if (ContainsAny(id, "4x4", "4m", "large", "tall", "wide"))
			{
				return 20;
			}
			if (id.Contains("26"))
			{
				return 30;
			}
			if (id.Contains("45"))
			{
				return 31;
			}
			if (ContainsAny(id, "corner", "end", "cap"))
			{
				return 35;
			}
			return 5;
		}

		private static int CosmeticOrder(string id)
		{
			if (!ContainsAny(id, "decor", "ornament", "adornment", "carved", "painted", "variant"))
			{
				return 0;
			}
			return 10;
		}

		private static bool IsSeasonal(string id)
		{
			return ContainsAny(id, "seasonal", "yule", "xmas", "christmas", "halloween", "midsummer", "maypole", "jackoturnip", "mistletoe");
		}

		private static bool IsSpecial(string id)
		{
			return ContainsAny(id, "special", "event", "anniversary", "celebration");
		}

		private static bool ContainsAny(string value, params string[] markers)
		{
			for (int i = 0; i < markers.Length; i++)
			{
				if (value.IndexOf(markers[i], StringComparison.Ordinal) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private static int TrailingNumber(string value)
		{
			int num = value.Length - 1;
			while (num >= 0 && char.IsDigit(value[num]))
			{
				num--;
			}
			if (num == value.Length - 1)
			{
				return -1;
			}
			if (!int.TryParse(value.Substring(num + 1), out var result))
			{
				return -1;
			}
			return result;
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			foreach (char c in value)
			{
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = char.ToLowerInvariant(c);
				}
			}
			return new string(array, 0, length);
		}
	}
	internal static class MeadClassifier
	{
		internal static MeadRole Classify(RecipeFacts facts)
		{
			string text = (facts.Id + " " + facts.DisplayName).ToLowerInvariant();
			if (text.IndexOf("health", StringComparison.Ordinal) >= 0 || text.IndexOf("healing", StringComparison.Ordinal) >= 0)
			{
				return MeadRole.Health;
			}
			if (text.IndexOf("stamina", StringComparison.Ordinal) >= 0)
			{
				return MeadRole.Stamina;
			}
			return MeadRole.Utility;
		}

		internal static RecipeGroup ToGroup(MeadRole role)
		{
			return role switch
			{
				MeadRole.Health => new RecipeGroup("HP", 0), 
				MeadRole.Stamina => new RecipeGroup("Stamina", 1), 
				_ => new RecipeGroup("Utility", 2), 
			};
		}
	}
	internal static class RecipeClassifier
	{
		internal static RecipeGroup GetEquipmentGroup(RecipeFacts facts, EquipmentGroupingMode mode)
		{
			return mode switch
			{
				EquipmentGroupingMode.Default => new RecipeGroup("", 0), 
				EquipmentGroupingMode.Biome => BiomeClassifier.ToGroup(BiomeClassifier.Classify(facts.Id, facts.IngredientIds)), 
				_ => GetTypeGroup(facts), 
			};
		}

		internal static RecipeGroup GetFoodGroup(RecipeFacts facts, FoodGroupingMode mode)
		{
			switch (mode)
			{
			case FoodGroupingMode.Default:
				return new RecipeGroup("", 0);
			case FoodGroupingMode.Biome:
				return BiomeClassifier.ToGroup(BiomeClassifier.Classify(facts.Id, facts.IngredientIds));
			default:
				if (!facts.IsFood)
				{
					return new RecipeGroup("Other", 4);
				}
				return FoodClassifier.ToGroup(FoodClassifier.Classify(facts.Health, facts.Stamina, facts.Eitr));
			}
		}

		internal static RecipeGroup GetFoodPrepGroup(RecipeFacts facts, FoodGroupingMode mode)
		{
			if (mode == FoodGroupingMode.Stat && (facts.IsFeast || !facts.IsFood))
			{
				return new RecipeGroup("Feasts", 4);
			}
			return GetFoodGroup(facts, mode);
		}

		internal static RecipeGroup GetTypeGroup(RecipeFacts facts)
		{
			string itemType = facts.ItemType;
			string skill = facts.Skill;
			if (EqualsAny(itemType, "Tool"))
			{
				return new RecipeGroup("Tools", 0);
			}
			if (EqualsAny(itemType, "Shield"))
			{
				return new RecipeGroup("Shields", 20);
			}
			if (EqualsAny(itemType, "Helmet", "Chest", "Legs", "Hands", "Shoulder"))
			{
				return new RecipeGroup("Armor", 30);
			}
			if (EqualsAny(itemType, "Ammo", "AmmoNonEquipable"))
			{
				return new RecipeGroup("Ammunition", 40);
			}
			if (EqualsAny(itemType, "Utility", "Torch", "Trinket"))
			{
				return new RecipeGroup("Utility", 50);
			}
			if (EqualsAny(itemType, "OneHandedWeapon", "TwoHandedWeapon", "TwoHandedWeaponLeft", "Bow", "Attach_Atgeir"))
			{
				return WeaponGroup(skill);
			}
			return new RecipeGroup("Other", 60);
		}

		private static RecipeGroup WeaponGroup(string skill)
		{
			switch (skill)
			{
			case "Swords":
				return new RecipeGroup("Swords", 10);
			case "Axes":
			case "WoodCutting":
				return new RecipeGroup("Axes", 11);
			case "Clubs":
				return new RecipeGroup("Maces", 12);
			case "Spears":
				return new RecipeGroup("Spears", 13);
			case "Knives":
				return new RecipeGroup("Knives", 14);
			case "Polearms":
				return new RecipeGroup("Polearms / Atgeirs", 15);
			case "Bows":
			case "Crossbows":
				return new RecipeGroup("Bows / Ranged", 16);
			default:
				return new RecipeGroup("Weapons", 17);
			}
		}

		private static bool EqualsAny(string value, params string[] choices)
		{
			for (int i = 0; i < choices.Length; i++)
			{
				if (string.Equals(value, choices[i], StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class RecipeSearch
	{
		internal static bool Matches(RecipeFacts facts, string? query)
		{
			if (string.IsNullOrWhiteSpace(query))
			{
				return true;
			}
			string value = query.Trim();
			if (facts.DisplayName.IndexOf(value, StringComparison.CurrentCultureIgnoreCase) < 0)
			{
				return facts.Id.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}
	}
	internal static class ShelfRowPlanner
	{
		internal static int ChooseGroupRowSize(IReadOnlyList<string> labels, int cursor, int columns, int remainingRows)
		{
			if (labels == null)
			{
				throw new ArgumentNullException("labels");
			}
			if (cursor < 0 || cursor >= labels.Count)
			{
				throw new ArgumentOutOfRangeException("cursor");
			}
			if (columns < 1)
			{
				throw new ArgumentOutOfRangeException("columns");
			}
			if (remainingRows < 1)
			{
				throw new ArgumentOutOfRangeException("remainingRows");
			}
			int num = labels.Count - cursor;
			if (remainingRows == 1)
			{
				if (num > columns)
				{
					throw new InvalidOperationException($"The final shelf row cannot hold {num} entries in {columns} columns.");
				}
				return num;
			}
			int num2 = Math.Max(1, num - (remainingRows - 1) * columns);
			int num3 = Math.Min(columns, num - (remainingRows - 1));
			if (num3 < num2)
			{
				throw new InvalidOperationException($"Cannot distribute {num} entries across {remainingRows} shelf rows.");
			}
			string b = labels[cursor];
			int i;
			for (i = 1; cursor + i < labels.Count && string.Equals(labels[cursor + i], b, StringComparison.Ordinal); i++)
			{
			}
			int num4 = (i + columns - 1) / columns;
			int val = (i + num4 - 1) / num4;
			return Math.Max(num2, Math.Min(num3, val));
		}
	}
	internal static class StableRecipeSorter
	{
		internal static List<T> Sort<T>(IReadOnlyList<T> source, Func<T, RecipeGroup> group, Func<T, RecipeFacts> facts)
		{
			List<(T, int)> list = new List<(T, int)>(source.Count);
			for (int i = 0; i < source.Count; i++)
			{
				list.Add((source[i], i));
			}
			list.Sort(delegate((T Item, int Index) left, (T Item, int Index) right)
			{
				RecipeGroup recipeGroup = group(left.Item);
				RecipeGroup recipeGroup2 = group(right.Item);
				int num2 = recipeGroup.Order.CompareTo(recipeGroup2.Order);
				if (num2 != 0)
				{
					return num2;
				}
				RecipeFacts recipeFacts = facts(left.Item);
				RecipeFacts recipeFacts2 = facts(right.Item);
				num2 = string.Compare(recipeFacts.DisplayName, recipeFacts2.DisplayName, StringComparison.CurrentCultureIgnoreCase);
				if (num2 != 0)
				{
					return num2;
				}
				num2 = string.Compare(recipeFacts.Id, recipeFacts2.Id, StringComparison.Ordinal);
				return (num2 == 0) ? left.Index.CompareTo(right.Index) : num2;
			});
			List<T> list2 = new List<T>(list.Count);
			for (int num = 0; num < list.Count; num++)
			{
				list2.Add(list[num].Item1);
			}
			return list2;
		}

		internal static IReadOnlyList<RecipeGroup> VisibleGroups<T>(IReadOnlyList<T> source, Func<T, RecipeGroup> classifier)
		{
			List<RecipeGroup> list = new List<RecipeGroup>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < source.Count; i++)
			{
				RecipeGroup item = classifier(source[i]);
				if (hashSet.Add(item.Label))
				{
					list.Add(item);
				}
			}
			list.Sort((RecipeGroup left, RecipeGroup right) => left.Order.CompareTo(right.Order));
			return list;
		}
	}
}