using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using SpaceCraft;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("PlayerInventoryStacks")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("PlayerInventoryStacks")]
[assembly: AssemblyTitle("PlayerInventoryStacks")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 PlayerInventoryStacks
{
	internal static class Backpacks
	{
		private static readonly HashSet<int> Ids = new HashSet<int>();

		private static readonly FieldInfo LockTime = typeof(WorldObject).GetField("_lockInInventoryTime", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static void Clear()
		{
			Ids.Clear();
		}

		internal static void Register(int id)
		{
			if (id > 0)
			{
				Ids.Add(id);
			}
		}

		internal static bool IsPlayer(Inventory inventory)
		{
			if (inventory != null)
			{
				return Ids.Contains(inventory.GetId());
			}
			return false;
		}

		internal static string Key(WorldObject item)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			if (item == null)
			{
				throw new ArgumentNullException("item");
			}
			StringBuilder b;
			if (item.GetLinkedInventoryId() == 0)
			{
				List<int> secondaryInventoriesId = item.GetSecondaryInventoriesId();
				if ((secondaryInventoriesId == null || secondaryInventoriesId.Count <= 0) && item.GetLinkedWorldObject() == 0 && (float)LockTime.GetValue(item) == 0f)
				{
					b = new StringBuilder();
					Add(item.GetGroup().GetId());
					Add(item.GetText());
					Add(item.GetSetting());
					Add(item.GetGeneticTraitType());
					Add(item.GetGeneticTraitValue());
					Color color = item.GetColor();
					Add(color.r);
					Add(color.g);
					Add(color.b);
					Add(color.a);
					Add(item.GetEnergy());
					Add(item.GetGrowth());
					Add(item.GetHunger());
					Add(item.GetPetTime());
					Vector2Int count = item.GetCount();
					Add(((Vector2Int)(ref count)).x);
					count = item.GetCount();
					Add(((Vector2Int)(ref count)).y);
					Add(item.GetPlanetLinkedHash());
					List<Group> linkedGroups = item.GetLinkedGroups();
					Add(linkedGroups?.Count ?? 0);
					if (linkedGroups != null)
					{
						foreach (Group item2 in linkedGroups)
						{
							Add(item2.GetId());
						}
					}
					List<int> panelsId = item.GetPanelsId();
					Add(panelsId?.Count ?? 0);
					if (panelsId != null)
					{
						foreach (int item3 in panelsId)
						{
							Add(item3);
						}
					}
					return b.ToString();
				}
			}
			return "unique:" + item.GetId();
			void Add(object value)
			{
				string text = Convert.ToString(value, CultureInfo.InvariantCulture) ?? "";
				b.Append(text.Length).Append(':').Append(text)
					.Append('|');
			}
		}

		internal static List<StackLayout.Stack<WorldObject>> Layout(Inventory inventory)
		{
			return StackLayout.Create(inventory.GetInsideWorldObjects(), Key);
		}

		internal static bool FullFor(Inventory inventory, WorldObject item)
		{
			if (!IsPlayer(inventory))
			{
				return inventory.IsFull();
			}
			if (item == null)
			{
				return Layout(inventory).Count >= inventory.GetSize();
			}
			if (inventory.ContainWorldObject(item))
			{
				return false;
			}
			return !StackLayout.CanAdd(inventory.GetInsideWorldObjects(), item, inventory.GetSize(), Key);
		}

		internal static bool FullForGroup(Inventory inventory, Group group)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			return FullFor(inventory, new WorldObject(0, group));
		}

		internal static bool FitsCraft(Inventory inventory, List<Group> ingredients, Group output, bool freeCraft)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			List<WorldObject> list = inventory.GetInsideWorldObjects().ToList();
			if (!freeCraft)
			{
				foreach (Group group in ingredients)
				{
					int num = list.FindLastIndex((WorldObject item) => item.GetGroup() == group);
					if (num >= 0)
					{
						list.RemoveAt(num);
					}
				}
			}
			return StackLayout.CanAdd(list, new WorldObject(0, output), inventory.GetSize(), Key);
		}
	}
	[BepInPlugin("local.planetcrafter.playerinventorystacks", "Player Inventory Stacks", "1.0.0")]
	[BepInProcess("Planet Crafter.exe")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string Id = "local.planetcrafter.playerinventorystacks";

		private Harmony harmony;

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			harmony = new Harmony("local.planetcrafter.playerinventorystacks");
			try
			{
				harmony.PatchAll(typeof(Plugin).Assembly);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Player Inventory Stacks 1.0.0 loaded: 64 items per backpack stack; containers unchanged.");
			}
			catch (Exception ex)
			{
				harmony.UnpatchSelf();
				((BaseUnityPlugin)this).Logger.LogError((object)("Player Inventory Stacks could not patch this game version; all its patches were removed. " + ex));
			}
		}

		private void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}
	}
	[HarmonyPatch(typeof(InventoriesHandler), "OnNetworkSpawn")]
	internal static class ResetWorld
	{
		private static void Prefix()
		{
			Backpacks.Clear();
		}
	}
	[HarmonyPatch(typeof(PlayerBackpack), "SetInventory")]
	internal static class RegisterBackpack
	{
		private static void Prefix(Inventory _playerInventory)
		{
			if (_playerInventory != null)
			{
				Backpacks.Register(_playerInventory.GetId());
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMainController), "InitPlayerClientRpc")]
	internal static class RegisterClientBackpack
	{
		private static void Prefix(int inventoryId)
		{
			Backpacks.Register(inventoryId);
		}
	}
	[HarmonyPatch(typeof(SavedDataHandler), "LoadSavedData")]
	internal static class RegisterSavedBackpacks
	{
		private static void Postfix(SavedDataHandler __instance)
		{
			List<JsonablePlayerState> lastLoadedPlayerData = __instance.GetLastLoadedPlayerData();
			if (lastLoadedPlayerData == null)
			{
				return;
			}
			foreach (JsonablePlayerState item in lastLoadedPlayerData)
			{
				Backpacks.Register(item.inventoryId);
			}
		}
	}
	[HarmonyPatch(typeof(Inventory), "IsFull")]
	internal static class InventoryFull
	{
		private static bool Prefix(Inventory __instance, ref bool __result)
		{
			if (!Backpacks.IsPlayer(__instance))
			{
				return true;
			}
			__result = Backpacks.Layout(__instance).Count >= __instance.GetSize();
			return false;
		}
	}
	[HarmonyPatch(typeof(Inventory), "AddItemInInventory")]
	internal static class AddItemCapacity
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			return PatchTools.ReplaceFull(instructions, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_1, (object)null)
			}, "FullFor");
		}
	}
	[HarmonyPatch(typeof(Inventory), "DropObjectsIfNotEnoughSpace")]
	internal static class BackpackShrink
	{
		private static bool Prefix(Inventory __instance, Vector3 dropPosition, bool removeOnly, ref List<WorldObject> __result)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (!Backpacks.IsPlayer(__instance))
			{
				return true;
			}
			List<WorldObject> list = Backpacks.Layout(__instance).Skip(Math.Max(0, __instance.GetSize())).SelectMany((StackLayout.Stack<WorldObject> s) => s.Items)
				.ToList();
			foreach (WorldObject item in list)
			{
				if (!removeOnly)
				{
					WorldObjectsHandler.Instance.DropOnFloor(item, dropPosition, 0f, true, false, 0);
				}
				__instance.RemoveItem(item);
			}
			__result = list;
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryDisplayer), "SetInventoryBlocks")]
	internal static class DisplayStacks
	{
		private static void Prefix(Inventory ____inventory, ref ReadOnlyCollection<WorldObject> inventoryWorldObjects, out List<StackLayout.Stack<WorldObject>> __state)
		{
			__state = null;
			if (Backpacks.IsPlayer(____inventory))
			{
				__state = Backpacks.Layout(____inventory);
				inventoryWorldObjects = __state.Select((StackLayout.Stack<WorldObject> s) => s.Items[0]).ToList().AsReadOnly();
			}
		}

		private static void Postfix(Inventory ____inventory, GridLayoutGroup ____grid, List<StackLayout.Stack<WorldObject>> __state)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00b1: 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_00ff: 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)
			if (__state == null)
			{
				return;
			}
			InventoryBlock[] componentsInChildren = ((Component)____grid).GetComponentsInChildren<InventoryBlock>();
			componentsInChildren = componentsInChildren.Skip(Math.Max(0, componentsInChildren.Length - ____inventory.GetSize())).ToArray();
			for (int i = 0; i < Math.Min(componentsInChildren.Length, __state.Count); i++)
			{
				int count = __state[i].Items.Count;
				if (count > 1)
				{
					GameObject val = new GameObject("PlayerStackCount", new Type[2]
					{
						typeof(RectTransform),
						typeof(TextMeshProUGUI)
					});
					val.transform.SetParent(((Component)componentsInChildren[i]).transform, false);
					RectTransform val2 = (RectTransform)val.transform;
					val2.anchorMin = Vector2.zero;
					val2.anchorMax = Vector2.one;
					val2.offsetMin = new Vector2(3f, 3f);
					val2.offsetMax = new Vector2(-5f, -3f);
					TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
					((TMP_Text)component).font = TMP_Settings.defaultFontAsset;
					((TMP_Text)component).text = count.ToString();
					((TMP_Text)component).fontSize = 22f;
					((TMP_Text)component).fontStyle = (FontStyles)1;
					((Graphic)component).color = Color.white;
					((TMP_Text)component).alignment = (TextAlignmentOptions)1028;
					((Graphic)component).raycastTarget = false;
					((TMP_Text)component).textWrappingMode = (TextWrappingModes)0;
					((TMP_Text)component).outlineWidth = 0.22f;
					((TMP_Text)component).outlineColor = new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue);
				}
			}
		}
	}
	internal static class PatchTools
	{
		internal static readonly MethodInfo IsFull = AccessTools.Method(typeof(Inventory), "IsFull", (Type[])null, (Type[])null);

		internal static IEnumerable<CodeInstruction> ReplaceFull(IEnumerable<CodeInstruction> source, IEnumerable<CodeInstruction> loadCandidate, string helper, int expected = 1)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>();
			int num = 0;
			foreach (CodeInstruction item in source)
			{
				if (CodeInstructionExtensions.Calls(item, IsFull))
				{
					List<CodeInstruction> list2 = loadCandidate.Select((Func<CodeInstruction, CodeInstruction>)((CodeInstruction c) => new CodeInstruction(c))).ToList();
					list2[0].labels.AddRange(item.labels);
					list2[0].blocks.AddRange(item.blocks);
					list.AddRange(list2);
					list.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Backpacks), helper, (Type[])null, (Type[])null)));
					num++;
				}
				else
				{
					list.Add(item);
				}
			}
			if (num != expected)
			{
				throw new InvalidOperationException($"Expected {expected} capacity checks, found {num}.");
			}
			return list;
		}

		internal static WorldObject ActionItem(Component component)
		{
			WorldObjectAssociated componentInParent = component.GetComponentInParent<WorldObjectAssociated>();
			if (componentInParent == null)
			{
				return null;
			}
			return componentInParent.GetWorldObject();
		}

		internal static IEnumerable<CodeInstruction> ActionCapacity(IEnumerable<CodeInstruction> source, FieldInfo owner = null)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null)
			};
			if (owner != null)
			{
				list.Add(new CodeInstruction(OpCodes.Ldfld, (object)owner));
			}
			list.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PatchTools), "ActionItem", (Type[])null, (Type[])null)));
			return ReplaceFull(source, list, "FullFor");
		}
	}
	[HarmonyPatch(typeof(ActionMinable), "OnAction")]
	internal static class StartMiningCapacity
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return PatchTools.ActionCapacity(instructions);
		}
	}
	[HarmonyPatch]
	internal static class FinishMiningCapacity
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.EnumeratorMoveNext((MethodBase)AccessTools.Method(typeof(ActionMinable), "FinishMining", (Type[])null, (Type[])null));
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
		{
			return PatchTools.ActionCapacity(instructions, AccessTools.Field(original.DeclaringType, "<>4__this"));
		}
	}
	[HarmonyPatch(typeof(ActionGrabable), "OnAction")]
	internal static class GrabCapacity
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return PatchTools.ActionCapacity(instructions);
		}
	}
	[HarmonyPatch(typeof(CraftManager), "TryToCraftInInventory")]
	internal static class CraftCapacity
	{
		private static bool Prefix(PlayerMainController playerController, GroupItem groupItem, ref bool __result)
		{
			Inventory inventory = playerController.GetPlayerBackpack().GetInventory();
			if (!Backpacks.IsPlayer(inventory))
			{
				return true;
			}
			bool freeCraft = Managers.GetManager<GameSettingsHandler>().GetCurrentGameSettings().GetFreeCraft();
			if (Backpacks.FitsCraft(inventory, ((Group)groupItem).GetRecipe().GetIngredientsGroupInRecipe(), (Group)(object)groupItem, freeCraft))
			{
				return true;
			}
			Managers.GetManager<BaseHudHandler>().DisplayCursorText("UI_InventoryFull", 2f, "", "", false);
			__result = false;
			return false;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			return PatchTools.ReplaceFull(instructions, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_2, (object)null)
			}, "FullForGroup", 2);
		}
	}
	[HarmonyPatch(typeof(WorldObjectsHandler), "RetrieveResourcesFromDeconstructionServerRpc")]
	internal static class DeconstructionCapacity
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			List<CodeInstruction> list = instructions.ToList();
			int num = list.FindIndex((CodeInstruction c) => CodeInstructionExtensions.Calls(c, PatchTools.IsFull));
			int num2 = ((num < 0) ? (-1) : list.FindLastIndex(num, (CodeInstruction c) => CodeInstructionExtensions.Calls(c, AccessTools.Method(typeof(WorldObject), "GetGroup", (Type[])null, (Type[])null))));
			if (num2 <= 0 || !CodeInstructionExtensions.IsLdloc(list[num2 - 1], (LocalBuilder)null))
			{
				throw new InvalidOperationException("Could not identify deconstruction resource local.");
			}
			return PatchTools.ReplaceFull(list, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[1]
			{
				new CodeInstruction(list[num2 - 1].opcode, list[num2 - 1].operand)
			}, "FullFor");
		}
	}
	[HarmonyPatch(typeof(ActionPanelDeconstruct), "Deconstruct")]
	internal static class PanelCapacity
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			var list = (from local in original.GetMethodBody().LocalVariables
				select new
				{
					local = local,
					field = local.LocalType.GetField("group", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				} into pair
				where pair.field?.FieldType == typeof(Group)
				select pair).ToList();
			if (list.Count != 1)
			{
				throw new InvalidOperationException("Could not identify panel ingredient local.");
			}
			var anon = list[0];
			return PatchTools.ReplaceFull(instructions, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldloc, (object)anon.local.LocalIndex),
				new CodeInstruction(OpCodes.Ldfld, (object)anon.field)
			}, "FullForGroup");
		}
	}
	[HarmonyPatch(typeof(InventoriesHandler), "AnInventoryHasBeenClicked")]
	internal static class QuickTransferKey
	{
		internal static bool IsPressed(PlayerInputDispatcher input, Inventory source)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (input.IsPressingAccessibilityKey())
			{
				return true;
			}
			if (Keyboard.current == null || !Keyboard.current.shiftKey.isPressed)
			{
				return false;
			}
			WindowsHandler manager = Managers.GetManager<WindowsHandler>();
			UiWindow windowViaUiId = manager.GetWindowViaUiId(manager.GetOpenedUi());
			UiWindowContainer val = (UiWindowContainer)(object)((windowViaUiId is UiWindowContainer) ? windowViaUiId : null);
			if ((Object)(object)val != (Object)null)
			{
				if (!Backpacks.IsPlayer(source))
				{
					return Backpacks.IsPlayer(val.GetOtherInventory(source));
				}
				return true;
			}
			return false;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>();
			int num = 0;
			MethodInfo methodInfo = AccessTools.Method(typeof(PlayerInputDispatcher), "IsPressingAccessibilityKey", (Type[])null, (Type[])null);
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.Calls(instruction, methodInfo))
				{
					CodeInstruction val = new CodeInstruction(OpCodes.Ldarg_1, (object)null);
					val.labels.AddRange(instruction.labels);
					val.blocks.AddRange(instruction.blocks);
					list.Add(val);
					list.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(QuickTransferKey), "IsPressed", (Type[])null, (Type[])null)));
					num++;
				}
				else
				{
					list.Add(instruction);
				}
			}
			if (num != 1)
			{
				throw new InvalidOperationException("Could not identify inventory quick-transfer key check.");
			}
			return list;
		}
	}
	internal static class StackLayout
	{
		internal sealed class Stack<T>
		{
			internal readonly List<T> Items = new List<T>();
		}

		internal const int Limit = 64;

		internal static List<Stack<T>> Create<T>(IEnumerable<T> items, Func<T, string> key)
		{
			List<Stack<T>> list = new List<Stack<T>>();
			Dictionary<string, Stack<T>> dictionary = new Dictionary<string, Stack<T>>(StringComparer.Ordinal);
			foreach (T item in items)
			{
				string key2 = key(item);
				if (!dictionary.TryGetValue(key2, out var value) || value.Items.Count == 64)
				{
					value = (dictionary[key2] = new Stack<T>());
					list.Add(value);
				}
				value.Items.Add(item);
			}
			return list;
		}

		internal static bool CanAdd<T>(IEnumerable<T> items, T candidate, int slots, Func<T, string> key)
		{
			List<Stack<T>> list = Create(items, key);
			if (list.Count < slots)
			{
				return true;
			}
			if (list.Count > slots)
			{
				return false;
			}
			string text = key(candidate);
			foreach (Stack<T> item in list)
			{
				if (item.Items.Count < 64 && key(item.Items[0]) == text)
				{
					return true;
				}
			}
			return false;
		}
	}
}