using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("BottomlessChest.Logic")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BottomlessChest.Logic")]
[assembly: AssemblyTitle("BottomlessChest.Logic")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace BottomlessChest.Logic
{
	public readonly struct IndexEntry
	{
		public string ItemId { get; }

		public int Quality { get; }

		public int Count { get; }

		public int WorldLevel { get; }

		public bool Cheated { get; }

		public IndexEntry(string itemId, int quality, int count, int worldLevel, bool cheated)
		{
			ItemId = itemId;
			Quality = quality;
			Count = count;
			WorldLevel = worldLevel;
			Cheated = cheated;
		}
	}
	public sealed class ChestIndex
	{
		private readonly IndexEntry[] _entries;

		public long Generation { get; }

		public long Version { get; }

		public IReadOnlyList<IndexEntry> Entries => _entries;

		private ChestIndex(long generation, long version, IndexEntry[] entries)
		{
			Generation = generation;
			Version = version;
			_entries = entries;
		}

		public static ChestIndex From(long generation, long version, IEnumerable<IStorableItem> items)
		{
			List<IndexEntry> list = new List<IndexEntry>();
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			if (items != null)
			{
				foreach (IStorableItem item in items)
				{
					if (item != null && item.ItemId != null)
					{
						string key = item.ItemId + "/" + item.Quality + "/" + item.WorldLevel + "/" + (item.Cheated ? "1" : "0");
						if (dictionary.TryGetValue(key, out var value))
						{
							IndexEntry indexEntry = list[value];
							list[value] = new IndexEntry(indexEntry.ItemId, indexEntry.Quality, indexEntry.Count + item.Stack, indexEntry.WorldLevel, indexEntry.Cheated);
						}
						else
						{
							dictionary[key] = list.Count;
							list.Add(new IndexEntry(item.ItemId, item.Quality, item.Stack, item.WorldLevel, item.Cheated));
						}
					}
				}
			}
			return new ChestIndex(generation, version, list.ToArray());
		}

		public int CountOf(string itemId, int quality)
		{
			if (itemId == null)
			{
				return 0;
			}
			int num = 0;
			IndexEntry[] entries = _entries;
			for (int i = 0; i < entries.Length; i++)
			{
				IndexEntry indexEntry = entries[i];
				if (indexEntry.ItemId == itemId && (quality < 0 || indexEntry.Quality == quality))
				{
					num += indexEntry.Count;
				}
			}
			return num;
		}

		public int Count(Func<string, bool> itemIdMatches, int quality, int minWorldLevel)
		{
			if (itemIdMatches == null)
			{
				return 0;
			}
			int num = 0;
			IndexEntry[] entries = _entries;
			for (int i = 0; i < entries.Length; i++)
			{
				IndexEntry indexEntry = entries[i];
				if ((quality < 0 || indexEntry.Quality == quality) && (minWorldLevel < 0 || indexEntry.WorldLevel >= minWorldLevel) && indexEntry.Count > 0 && itemIdMatches(indexEntry.ItemId))
				{
					num += indexEntry.Count;
				}
			}
			return num;
		}

		public int Take(string itemId, int quality, int amount, int minWorldLevel = -1)
		{
			if (itemId == null || amount <= 0)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < _entries.Length; i++)
			{
				if (num >= amount)
				{
					break;
				}
				IndexEntry indexEntry = _entries[i];
				if (!(indexEntry.ItemId != itemId) && (quality < 0 || indexEntry.Quality == quality) && (minWorldLevel < 0 || indexEntry.WorldLevel >= minWorldLevel))
				{
					int num2 = ((indexEntry.Count < amount - num) ? indexEntry.Count : (amount - num));
					_entries[i] = new IndexEntry(indexEntry.ItemId, indexEntry.Quality, indexEntry.Count - num2, indexEntry.WorldLevel, indexEntry.Cheated);
					num += num2;
				}
			}
			return num;
		}
	}
	public sealed class ChestIndexCache
	{
		private readonly Dictionary<string, ChestIndex> _byStore = new Dictionary<string, ChestIndex>(StringComparer.Ordinal);

		public void Put(string storeId, ChestIndex index)
		{
			if (!string.IsNullOrEmpty(storeId) && index != null && (!_byStore.TryGetValue(storeId, out var value) || !IsNewer(value, index)))
			{
				_byStore[storeId] = index;
			}
		}

		public bool TryGet(string storeId, out ChestIndex index)
		{
			if (string.IsNullOrEmpty(storeId))
			{
				index = null;
				return false;
			}
			return _byStore.TryGetValue(storeId, out index);
		}

		public void Forget(string storeId)
		{
			if (!string.IsNullOrEmpty(storeId))
			{
				_byStore.Remove(storeId);
			}
		}

		public void Clear()
		{
			_byStore.Clear();
		}

		private static bool IsNewer(ChestIndex held, ChestIndex incoming)
		{
			if (held.Generation <= incoming.Generation)
			{
				if (held.Generation == incoming.Generation)
				{
					return held.Version > incoming.Version;
				}
				return false;
			}
			return true;
		}
	}
	public static class ConfigDefaults
	{
		public static string Upgrade(string stored, string previousDefault, string currentDefault)
		{
			if (!string.Equals(stored, previousDefault, StringComparison.Ordinal))
			{
				return stored;
			}
			return currentDefault;
		}
	}
	public static class ContentsDiff
	{
		public static Dictionary<string, int> Tally(IEnumerable<IStorableItem> items)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			if (items == null)
			{
				return dictionary;
			}
			foreach (IStorableItem item in items)
			{
				if (item != null)
				{
					Add(dictionary, item.ItemId, item.Stack);
				}
			}
			return dictionary;
		}

		public static void Add(Dictionary<string, int> tally, string itemId, int stack)
		{
			if (tally != null && itemId != null)
			{
				tally.TryGetValue(itemId, out var value);
				tally[itemId] = value + stack;
			}
		}

		public static string Describe(IReadOnlyDictionary<string, int> before, IReadOnlyDictionary<string, int> after)
		{
			if (before == null || after == null)
			{
				return null;
			}
			SortedSet<string> sortedSet = new SortedSet<string>();
			foreach (KeyValuePair<string, int> item in before)
			{
				sortedSet.Add(item.Key);
			}
			foreach (KeyValuePair<string, int> item2 in after)
			{
				sortedSet.Add(item2.Key);
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (string item3 in sortedSet)
			{
				before.TryGetValue(item3, out var value);
				after.TryGetValue(item3, out var value2);
				int num = value2 - value;
				if (num != 0)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(", ");
					}
					stringBuilder.Append(item3).Append(' ').Append((num > 0) ? "+" : "-")
						.Append((num > 0) ? num : (-num));
				}
			}
			if (stringBuilder.Length <= 0)
			{
				return null;
			}
			return stringBuilder.ToString();
		}
	}
	public readonly struct GridPos : IEquatable<GridPos>
	{
		public int X { get; }

		public int Y { get; }

		public GridPos(int x, int y)
		{
			X = x;
			Y = y;
		}

		public bool Equals(GridPos other)
		{
			if (X == other.X)
			{
				return Y == other.Y;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (X * 397) ^ Y;
		}

		public override string ToString()
		{
			return $"({X}, {Y})";
		}
	}
	public static class GridPacker
	{
		public static GridPos PositionOf(int index, int width)
		{
			RequirePositiveWidth(width);
			return new GridPos(index % width, index / width);
		}

		public static int RowsNeeded(int count, int width)
		{
			RequirePositiveWidth(width);
			if (count > 0)
			{
				return (count - 1) / width + 1;
			}
			return 0;
		}

		public static int LastPageRow(int count, int width, int pageSlots)
		{
			RequirePositiveWidth(width);
			if (count > pageSlots)
			{
				return RowsNeeded(count - pageSlots, width);
			}
			return 0;
		}

		public static int RowsForChest(int count, int width, int minRows)
		{
			RequirePositiveWidth(width);
			int num = RowsNeeded(count, width) + 1;
			int num2 = ((minRows < 1) ? 1 : minRows);
			if (num <= num2)
			{
				return num2;
			}
			return num;
		}

		public static bool LayoutFitsWindow(IReadOnlyList<GridPos> positions, int width, int rows)
		{
			RequirePositiveWidth(width);
			if (rows < 1 || positions == null)
			{
				return false;
			}
			if (positions.Count > width * rows)
			{
				return false;
			}
			HashSet<int> hashSet = new HashSet<int>();
			foreach (GridPos position in positions)
			{
				if (position.X < 0 || position.X >= width || position.Y < 0 || position.Y >= rows)
				{
					return false;
				}
				if (!hashSet.Add(position.Y * width + position.X))
				{
					return false;
				}
			}
			return true;
		}

		public static GridPos FirstEmptySlot(IEnumerable<GridPos> occupied, int width, int height, bool topFirst)
		{
			RequirePositiveWidth(width);
			if (height <= 0)
			{
				return new GridPos(-1, -1);
			}
			bool[] array = new bool[(long)width * (long)height];
			if (occupied != null)
			{
				foreach (GridPos item in occupied)
				{
					if (item.X >= 0 && item.X < width && item.Y >= 0 && item.Y < height)
					{
						array[(long)item.Y * (long)width + item.X] = true;
					}
				}
			}
			for (int i = 0; i < height; i++)
			{
				int num = (topFirst ? i : (height - 1 - i));
				for (int j = 0; j < width; j++)
				{
					if (!array[(long)num * (long)width + j])
					{
						return new GridPos(j, num);
					}
				}
			}
			return new GridPos(-1, -1);
		}

		private static void RequirePositiveWidth(int width)
		{
			if (width <= 0)
			{
				throw new ArgumentOutOfRangeException("width", width, "Grid width must be at least 1.");
			}
		}
	}
	public sealed class IndexedItem : IStorableItem
	{
		public string ItemId { get; }

		public int Quality { get; }

		public int Stack { get; }

		public int WorldLevel { get; }

		public bool Cheated { get; }

		public string DisplayName => ItemId;

		public string SearchKey => TextKey.Of(ItemId);

		public ItemKind Kind => ItemKind.Unknown;

		public int MaxStackSize => int.MaxValue;

		public int Variant => 0;

		public string CustomData => null;

		public IndexedItem(string itemId, int quality, int stack, int worldLevel = 0, bool cheated = false)
		{
			ItemId = itemId;
			Quality = quality;
			Stack = stack;
			WorldLevel = worldLevel;
			Cheated = cheated;
		}
	}
	public enum PayloadFormat
	{
		Unknown,
		VanillaIntCount,
		VanillaUShortCount,
		Bottomless
	}
	public readonly struct PayloadHeader
	{
		public PayloadFormat Format { get; }

		public int ItemVersion { get; }

		public int Count { get; }

		public int ItemsOffset { get; }

		public PayloadHeader(PayloadFormat format, int itemVersion, int count, int itemsOffset)
		{
			Format = format;
			ItemVersion = itemVersion;
			Count = count;
			ItemsOffset = itemsOffset;
		}
	}
	public static class InventoryPayload
	{
		public const int Marker = 1112294217;

		public const int FirstUShortCountVersion = 108;

		private const int LowestKnownItemVersion = 100;

		private const int HighestPlausibleItemVersion = 999;

		public static bool TryReadHeader(byte[] payload, out PayloadHeader header)
		{
			header = default(PayloadHeader);
			if (payload == null || payload.Length < 6)
			{
				return false;
			}
			int num = ReadInt(payload, 0);
			if (num == 1112294217)
			{
				if (payload.Length < 12)
				{
					return false;
				}
				int version = ReadInt(payload, 4);
				int count = ReadInt(payload, 8);
				return Accept(PayloadFormat.Bottomless, version, count, 12, out header);
			}
			if (num < 100 || num > 999)
			{
				return false;
			}
			if (num >= 108)
			{
				return Accept(PayloadFormat.VanillaUShortCount, num, ReadUShort(payload, 4), 6, out header);
			}
			if (payload.Length < 8)
			{
				return false;
			}
			return Accept(PayloadFormat.VanillaIntCount, num, ReadInt(payload, 4), 8, out header);
		}

		public static byte[] Wrap(byte[] vanillaPayload, int trueCount)
		{
			if (vanillaPayload == null)
			{
				throw new ArgumentNullException("vanillaPayload");
			}
			if (trueCount < 0)
			{
				throw new ArgumentOutOfRangeException("trueCount", trueCount, "A stack count cannot be negative.");
			}
			if (!TryReadHeader(vanillaPayload, out var header))
			{
				throw new ArgumentException("Not a serialized inventory: its leading value is neither an item version nor our marker.", "vanillaPayload");
			}
			int num = vanillaPayload.Length - header.ItemsOffset;
			byte[] array = new byte[12 + num];
			WriteInt(array, 0, 1112294217);
			WriteInt(array, 4, header.ItemVersion);
			WriteInt(array, 8, trueCount);
			Buffer.BlockCopy(vanillaPayload, header.ItemsOffset, array, 12, num);
			return array;
		}

		public static bool TryUnwrapToVanilla(byte[] wrapped, out byte[] vanilla)
		{
			vanilla = null;
			if (!TryReadHeader(wrapped, out var header) || header.Format != PayloadFormat.Bottomless)
			{
				return false;
			}
			bool flag = header.ItemVersion >= 108;
			if (flag && header.Count > 65535)
			{
				return false;
			}
			int num = wrapped.Length - header.ItemsOffset;
			int num2 = (flag ? 2 : 4);
			vanilla = new byte[4 + num2 + num];
			WriteInt(vanilla, 0, header.ItemVersion);
			if (flag)
			{
				vanilla[4] = (byte)header.Count;
				vanilla[5] = (byte)(header.Count >> 8);
			}
			else
			{
				WriteInt(vanilla, 4, header.Count);
			}
			Buffer.BlockCopy(wrapped, header.ItemsOffset, vanilla, 4 + num2, num);
			return true;
		}

		private static bool Accept(PayloadFormat format, int version, int count, int offset, out PayloadHeader header)
		{
			if (count < 0)
			{
				header = default(PayloadHeader);
				return false;
			}
			header = new PayloadHeader(format, version, count, offset);
			return true;
		}

		private static int ReadInt(byte[] buffer, int offset)
		{
			return buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24);
		}

		private static int ReadUShort(byte[] buffer, int offset)
		{
			return buffer[offset] | (buffer[offset + 1] << 8);
		}

		private static void WriteInt(byte[] buffer, int offset, int value)
		{
			buffer[offset] = (byte)value;
			buffer[offset + 1] = (byte)(value >> 8);
			buffer[offset + 2] = (byte)(value >> 16);
			buffer[offset + 3] = (byte)(value >> 24);
		}
	}
	public interface IStorableItem
	{
		string ItemId { get; }

		string DisplayName { get; }

		string SearchKey { get; }

		ItemKind Kind { get; }

		int Stack { get; }

		int MaxStackSize { get; }

		int Quality { get; }

		int WorldLevel { get; }

		bool Cheated { get; }

		int Variant { get; }

		string CustomData { get; }
	}
	public enum ItemKind
	{
		Unknown,
		Material,
		Food,
		Weapon,
		Armor,
		Ammo,
		Tool,
		Trophy,
		Misc
	}
	public sealed class ItemOrdering : IComparer<IStorableItem>
	{
		public static ItemOrdering ByName { get; } = new ItemOrdering();

		public int Compare(IStorableItem a, IStorableItem b)
		{
			if (a == b)
			{
				return 0;
			}
			if (a == null)
			{
				return -1;
			}
			if (b == null)
			{
				return 1;
			}
			int num = string.CompareOrdinal(a.SearchKey ?? string.Empty, b.SearchKey ?? string.Empty);
			if (num != 0)
			{
				return num;
			}
			int num2 = b.Quality.CompareTo(a.Quality);
			if (num2 != 0)
			{
				return num2;
			}
			return b.Stack.CompareTo(a.Stack);
		}
	}
	public sealed class ItemQuery
	{
		private static readonly Dictionary<string, ItemKind> KindTokens = new Dictionary<string, ItemKind>(StringComparer.Ordinal)
		{
			{
				"@material",
				ItemKind.Material
			},
			{
				"@food",
				ItemKind.Food
			},
			{
				"@weapon",
				ItemKind.Weapon
			},
			{
				"@armor",
				ItemKind.Armor
			},
			{
				"@ammo",
				ItemKind.Ammo
			},
			{
				"@tool",
				ItemKind.Tool
			},
			{
				"@trophy",
				ItemKind.Trophy
			},
			{
				"@misc",
				ItemKind.Misc
			}
		};

		private readonly List<string> _textTerms;

		private readonly List<ItemKind> _kindTerms;

		public bool IsEmpty
		{
			get
			{
				if (_textTerms.Count == 0)
				{
					return _kindTerms.Count == 0;
				}
				return false;
			}
		}

		private ItemQuery(List<string> textTerms, List<ItemKind> kindTerms)
		{
			_textTerms = textTerms;
			_kindTerms = kindTerms;
		}

		public static ItemQuery Parse(string query)
		{
			List<string> list = new List<string>();
			List<ItemKind> list2 = new List<ItemKind>();
			if (!string.IsNullOrWhiteSpace(query))
			{
				string[] array = query.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries);
				for (int i = 0; i < array.Length; i++)
				{
					string text = TextKey.Of(array[i]);
					if (text.Length != 0)
					{
						if (KindTokens.TryGetValue(text, out var value))
						{
							list2.Add(value);
						}
						else
						{
							list.Add(text);
						}
					}
				}
			}
			return new ItemQuery(list, list2);
		}

		public bool Matches(IStorableItem item)
		{
			if (IsEmpty)
			{
				return true;
			}
			if (_kindTerms.Count > 0 && !_kindTerms.Contains(item.Kind))
			{
				return false;
			}
			if (_textTerms.Count == 0)
			{
				return true;
			}
			string text = item.SearchKey ?? string.Empty;
			foreach (string textTerm in _textTerms)
			{
				if (text.IndexOf(textTerm, StringComparison.Ordinal) < 0)
				{
					return false;
				}
			}
			return true;
		}
	}
	public sealed class OfferQueue<TItem> where TItem : class
	{
		private sealed class Waiting
		{
			internal string StoreId;

			internal bool Message;
		}

		private sealed class InFlight
		{
			internal IReadOnlyList<TItem> Items;

			internal bool Message;

			internal float SentAt;
		}

		private sealed class ByReference : IEqualityComparer<TItem>
		{
			public bool Equals(TItem x, TItem y)
			{
				return x == y;
			}

			public int GetHashCode(TItem obj)
			{
				return RuntimeHelpers.GetHashCode(obj);
			}
		}

		private readonly float _timeout;

		private readonly List<Waiting> _waiting = new List<Waiting>();

		private readonly Dictionary<string, InFlight> _inFlight = new Dictionary<string, InFlight>(StringComparer.Ordinal);

		private readonly Dictionary<TItem, int> _reserved = new Dictionary<TItem, int>(new ByReference());

		public OfferQueue(float timeoutSeconds)
		{
			_timeout = timeoutSeconds;
		}

		public void Enqueue(string storeId, bool message)
		{
			if (string.IsNullOrEmpty(storeId))
			{
				return;
			}
			foreach (Waiting item in _waiting)
			{
				if (item.StoreId == storeId)
				{
					item.Message |= message;
					return;
				}
			}
			_waiting.Add(new Waiting
			{
				StoreId = storeId,
				Message = message
			});
		}

		public bool TryNext(float now, out string storeId, out bool message)
		{
			storeId = null;
			message = false;
			foreach (InFlight value in _inFlight.Values)
			{
				if (now - value.SentAt < _timeout)
				{
					return false;
				}
			}
			for (int i = 0; i < _waiting.Count; i++)
			{
				if (!_inFlight.ContainsKey(_waiting[i].StoreId))
				{
					storeId = _waiting[i].StoreId;
					message = _waiting[i].Message;
					_waiting.RemoveAt(i);
					return true;
				}
			}
			return false;
		}

		public void Sent(string storeId, IReadOnlyList<TItem> items, bool message, float now)
		{
			IReadOnlyList<TItem> readOnlyList = items ?? Array.Empty<TItem>();
			_inFlight[storeId] = new InFlight
			{
				Items = readOnlyList,
				Message = message,
				SentAt = now
			};
			foreach (TItem item in readOnlyList)
			{
				Reserve(item);
			}
		}

		public bool Complete(string storeId, out IReadOnlyList<TItem> items, out bool message)
		{
			items = Array.Empty<TItem>();
			message = false;
			if (storeId == null || !_inFlight.TryGetValue(storeId, out var value))
			{
				return false;
			}
			_inFlight.Remove(storeId);
			foreach (TItem item in value.Items)
			{
				Release(item);
			}
			items = value.Items;
			message = value.Message;
			return true;
		}

		public int OverdueCount(float now)
		{
			int num = 0;
			foreach (InFlight value in _inFlight.Values)
			{
				if (now - value.SentAt >= _timeout)
				{
					num++;
				}
			}
			return num;
		}

		public bool IsReserved(TItem item)
		{
			if (item != null)
			{
				return _reserved.ContainsKey(item);
			}
			return false;
		}

		public void Reserve(TItem item)
		{
			if (item != null)
			{
				_reserved[item] = ((!_reserved.TryGetValue(item, out var value)) ? 1 : (value + 1));
			}
		}

		public void Release(TItem item)
		{
			if (item != null && _reserved.TryGetValue(item, out var value))
			{
				if (value <= 1)
				{
					_reserved.Remove(item);
				}
				else
				{
					_reserved[item] = value - 1;
				}
			}
		}

		public void Clear()
		{
			_waiting.Clear();
			_inFlight.Clear();
			_reserved.Clear();
		}
	}
	public sealed class ReapplyTrigger
	{
		private const int Unset = -1;

		private int _appliedAt = -1;

		public bool NeedsApply(int count)
		{
			return _appliedAt != count;
		}

		public void NoteApplied(int count)
		{
			_appliedAt = count;
		}

		public void Invalidate()
		{
			_appliedAt = -1;
		}
	}
	public static class ReferenceFingerprint
	{
		public static ulong Of<T>(List<T> items) where T : class
		{
			ulong num = (ulong)(-3750763034362895579L ^ (items?.Count ?? 0));
			if (items == null)
			{
				return num;
			}
			for (int i = 0; i < items.Count; i++)
			{
				num ^= (uint)RuntimeHelpers.GetHashCode(items[i]);
				num *= 1099511628211L;
			}
			return num;
		}
	}
	public static class StackIdentity
	{
		public static string Key(string itemId, string sharedName, int quality, int variant, int worldLevel)
		{
			itemId = itemId ?? string.Empty;
			sharedName = sharedName ?? string.Empty;
			return $"{itemId.Length}:{itemId}|{sharedName.Length}:{sharedName}|{quality}|{variant}|{worldLevel}";
		}
	}
	public static class StackRules
	{
		public static int MergeAmount(int incoming, int targetStack, int maxStackSize)
		{
			if (incoming <= 0 || maxStackSize <= 1)
			{
				return 0;
			}
			int num = maxStackSize - targetStack;
			if (num <= 0)
			{
				return 0;
			}
			if (incoming >= num)
			{
				return num;
			}
			return incoming;
		}

		public static int TakeAmount(int requested, int available)
		{
			if (available <= 0)
			{
				return 0;
			}
			if (requested > 0 && requested < available)
			{
				return requested;
			}
			return available;
		}
	}
	public enum WorldLayout
	{
		Flat,
		Chunked
	}
	public readonly struct StoreCandidate
	{
		public string Path { get; }

		public bool FromLocalFallback { get; }

		public StoreCandidate(string path, bool fromLocalFallback)
		{
			Path = path;
			FromLocalFallback = fromLocalFallback;
		}

		public override string ToString()
		{
			return Path;
		}
	}
	public static class StoreLocations
	{
		public const string Extension = ".bottomless.dat";

		private static readonly string[] Generations = new string[3] { "", ".old", ".old2" };

		public static string WritePath(string worldsRoot, string worldName)
		{
			return PathFor(worldsRoot, worldName, WorldLayout.Flat);
		}

		private static string PathFor(string root, string worldName, WorldLayout layout)
		{
			if (layout != WorldLayout.Chunked)
			{
				return Combine(root, worldName + ".bottomless.dat");
			}
			return Combine(Combine(root, worldName), worldName + ".bottomless.dat");
		}

		public static IReadOnlyList<StoreCandidate> ReadCandidates(string worldsRoot, string localWorldsRoot, string worldName)
		{
			List<StoreCandidate> list = new List<StoreCandidate>();
			if (string.IsNullOrEmpty(worldName))
			{
				return list;
			}
			HashSet<string> hashSet = new HashSet<string>();
			(string, bool)[] array = new(string, bool)[2]
			{
				(worldsRoot, false),
				(localWorldsRoot, true)
			};
			for (int i = 0; i < array.Length; i++)
			{
				var (text, fromLocalFallback) = array[i];
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				WorldLayout[] array2 = new WorldLayout[2]
				{
					WorldLayout.Chunked,
					WorldLayout.Flat
				};
				foreach (WorldLayout layout in array2)
				{
					string text2 = PathFor(text, worldName, layout);
					string[] generations = Generations;
					foreach (string text3 in generations)
					{
						string text4 = text2 + text3;
						if (hashSet.Add(text4))
						{
							list.Add(new StoreCandidate(text4, fromLocalFallback));
						}
					}
				}
			}
			return list;
		}

		private static string Combine(string left, string right)
		{
			if (string.IsNullOrEmpty(left))
			{
				return right;
			}
			return left.TrimEnd('/', '\\') + "/" + right;
		}
	}
	public static class TextKey
	{
		public static string Of(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			string text = value.Normalize(NormalizationForm.FormD);
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			string text2 = text;
			foreach (char c in text2)
			{
				if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString().Normalize(NormalizationForm.FormC).ToLowerInvariant();
		}
	}
}