using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AzuExtendedPlayerInventory;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ConditionalConfigSync;
using ExtraSlots;
using GUIFramework;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using TMPro;
using TradersExtended.Compatibility;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using YamlDotNet.Serialization;

[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyProduct("Traders Extended")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: Guid("6d6f243e-c80e-4a33-b2d0-a2657d3b9f7f")]
[assembly: AssemblyTitle("Traders Extended")]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyFileVersion("2.0.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<513676d6-9794-4182-bde6-312741b82216>Embedded]
	internal sealed class <513676d6-9794-4182-bde6-312741b82216>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[<513676d6-9794-4182-bde6-312741b82216>Embedded]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace TradersExtended
{
	internal static class AmountDialog
	{
		[HarmonyPatch(typeof(StoreGui), "OnSelectedItem")]
		public static class StoreGui_OnSelectedItem_SelectItem
		{
			private static void Postfix()
			{
				OnSelectedTradeableItemClick(sellDialog: false);
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction<float> <0>__OnSplitSliderChanged;

			public static UnityAction <1>__OnOkClick;

			public static UnityAction <2>__Close;
		}

		private static float clickTime;

		private static GameObject amountDialog;

		private static Slider sliderDialog;

		private static TMP_Text sliderTitle;

		private static TMP_Text sliderAmountText;

		private static TMP_Text sliderAmountCoinsText;

		private static TMP_Text sliderButtonOk;

		private static Image sliderImage;

		private static Image sliderCurrencyImage;

		private static string sliderTitleText;

		private static string sliderButtonText;

		private static StoreGui storeGui;

		private const float m_splitNumInputTimeoutSec = 0.5f;

		private static string m_splitInput = "";

		private static DateTime m_lastSplitInput;

		private static bool isSellDialog;

		public static GameObject Init(StoreGui store)
		{
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: 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_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: 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_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Expected O, but got Unknown
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Expected O, but got Unknown
			storeGui = store;
			amountDialog = Object.Instantiate<GameObject>(((Component)InventoryGui.instance.m_splitPanel).gameObject, storeGui.m_rootPanel.transform.parent);
			((Object)amountDialog).name = "AmountDialog";
			Transform val = amountDialog.transform.Find("win_bkg");
			sliderTitle = ((Component)val.Find("Text")).GetComponent<TMP_Text>();
			sliderDialog = ((Component)val.Find("Slider")).GetComponent<Slider>();
			sliderAmountText = ((Component)val.Find("amount")).GetComponent<TMP_Text>();
			sliderImage = ((Component)val.Find("Icon_bkg/Icon")).GetComponent<Image>();
			sliderButtonOk = ((Component)val.Find("Button_ok/Text")).GetComponent<TMP_Text>();
			Transform val2 = val.Find("Icon_bkg");
			GameObject val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject, val);
			((Object)val3).name = "Coins_bkg";
			val3.transform.SetSiblingIndex(val2.GetSiblingIndex() + 1);
			sliderCurrencyImage = ((Component)val3.transform.Find("Icon")).GetComponent<Image>();
			UpdateCurrencyIcon(storeGui.m_coinPrefab);
			RectTransform component = val3.GetComponent<RectTransform>();
			component.anchorMax += new Vector2(0.15f, 0f);
			component.anchorMin += new Vector2(0.15f, 0f);
			RectTransform component2 = ((Component)val2).GetComponent<RectTransform>();
			component2.anchorMax -= new Vector2(0.15f, 0f);
			component2.anchorMin -= new Vector2(0.15f, 0f);
			GameObject val4 = Object.Instantiate<GameObject>(((Component)sliderAmountText).gameObject, val);
			((Object)val4).name = "amount_coins";
			val4.transform.SetSiblingIndex(sliderAmountText.transform.GetSiblingIndex() + 1);
			sliderAmountCoinsText = val4.GetComponent<TMP_Text>();
			RectTransform component3 = ((Component)sliderAmountText).GetComponent<RectTransform>();
			component3.anchorMax -= new Vector2(0.15f, 0f);
			component3.anchorMin -= new Vector2(0.15f, 0f);
			RectTransform component4 = val4.GetComponent<RectTransform>();
			component4.anchorMax += new Vector2(0.15f, 0f);
			component4.anchorMin += new Vector2(0.15f, 0f);
			GameObject val5 = Object.Instantiate<GameObject>(((Component)sliderTitle).gameObject, val);
			((Object)val5).name = "equal";
			val5.transform.SetSiblingIndex(sliderTitle.transform.GetSiblingIndex() + 1);
			RectTransform component5 = val5.GetComponent<RectTransform>();
			component5.anchorMin -= new Vector2(0f, 0.5f);
			val5.GetComponent<TMP_Text>().SetText("=");
			((UnityEvent<float>)(object)sliderDialog.onValueChanged).AddListener((UnityAction<float>)OnSplitSliderChanged);
			ButtonClickedEvent onClick = ((Component)val.Find("Button_ok")).GetComponent<Button>().onClick;
			object obj = <>O.<1>__OnOkClick;
			if (obj == null)
			{
				UnityAction val6 = OnOkClick;
				<>O.<1>__OnOkClick = val6;
				obj = (object)val6;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = ((Component)val.Find("Button_cancel")).GetComponent<Button>().onClick;
			object obj2 = <>O.<2>__Close;
			if (obj2 == null)
			{
				UnityAction val7 = Close;
				<>O.<2>__Close = val7;
				obj2 = (object)val7;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			return amountDialog;
		}

		public static void UpdateCurrencyIcon(ItemDrop currency)
		{
			if ((Object)(object)sliderCurrencyImage != (Object)null && (Object)(object)currency != (Object)null)
			{
				sliderCurrencyImage.sprite = currency.m_itemData.GetIcon();
			}
		}

		public static void OnOkClick()
		{
			BuySelectedItem();
		}

		public static void SetSellState(bool sellDialog)
		{
			isSellDialog = sellDialog;
		}

		public static void OnSelectedTradeableItemClick(bool sellDialog)
		{
			SetSellState(sellDialog);
			if (Time.time - clickTime < 0.3f)
			{
				Open();
				clickTime = 0f;
			}
			else
			{
				clickTime = Time.time;
			}
		}

		public static bool IsOpen()
		{
			return (Object)(object)amountDialog != (Object)null && amountDialog.activeInHierarchy;
		}

		public static void Update()
		{
			if ((Object)(object)amountDialog == (Object)null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead() || ((Character)localPlayer).InCutscene() || ((Character)localPlayer).IsTeleporting())
			{
				Close();
			}
			else
			{
				if ((Object)(object)sliderDialog == (Object)null || !((Component)sliderDialog).gameObject.activeInHierarchy)
				{
					return;
				}
				sliderTitle.SetText(sliderTitleText);
				sliderButtonOk.SetText(sliderButtonText);
				for (int i = 0; i < 10; i++)
				{
					if (ZInput.GetKeyDown((KeyCode)(256 + i), true) || ZInput.GetKeyDown((KeyCode)(48 + i), true))
					{
						if (m_lastSplitInput + TimeSpan.FromSeconds(0.5) < DateTime.Now)
						{
							m_splitInput = "";
						}
						m_lastSplitInput = DateTime.Now;
						m_splitInput += i;
						if (int.TryParse(m_splitInput, out var result))
						{
							sliderDialog.value = Mathf.Clamp((float)result, 1f, sliderDialog.maxValue);
							OnSplitSliderChanged();
						}
					}
				}
				if (ZInput.GetKeyDown((KeyCode)276, true) && sliderDialog.value > 1f)
				{
					Slider obj = sliderDialog;
					obj.value -= 1f;
					OnSplitSliderChanged();
				}
				if (ZInput.GetKeyDown((KeyCode)275, true) && sliderDialog.value < sliderDialog.maxValue)
				{
					Slider obj2 = sliderDialog;
					obj2.value += 1f;
					OnSplitSliderChanged();
				}
				if (ZInput.GetButtonDown("JoyLTrigger") && sliderDialog.value > 10f)
				{
					Slider obj3 = sliderDialog;
					obj3.value -= 10f;
					OnSplitSliderChanged();
				}
				if (ZInput.GetButtonDown("JoyRTrigger") && sliderDialog.value < sliderDialog.maxValue)
				{
					Slider obj4 = sliderDialog;
					obj4.value += 10f;
					OnSplitSliderChanged();
				}
				if (ZInput.GetButtonDown("JoyLBumper") && sliderDialog.value > 5f)
				{
					Slider obj5 = sliderDialog;
					obj5.value -= 5f;
					OnSplitSliderChanged();
				}
				if (ZInput.GetButtonDown("JoyRBumper") && sliderDialog.value < sliderDialog.maxValue)
				{
					Slider obj6 = sliderDialog;
					obj6.value += 5f;
					OnSplitSliderChanged();
				}
				if (ZInput.GetKeyDown((KeyCode)271, true) || ZInput.GetKeyDown((KeyCode)13, true))
				{
					BuySelectedItem();
				}
				if (((Object)(object)Chat.instance == (Object)null || !Chat.instance.HasFocus()) && !Console.IsVisible() && !Menu.IsVisible() && Object.op_Implicit((Object)(object)TextViewer.instance) && !TextViewer.instance.IsVisible() && !((Character)localPlayer).InCutscene() && (ZInput.GetButtonDown("JoyButtonB") || ZInput.GetKeyDown((KeyCode)27, true)))
				{
					ZInput.ResetButtonStatus("JoyButtonB");
					Close();
				}
			}
		}

		public static void Close()
		{
			GameObject obj = amountDialog;
			if (obj != null)
			{
				obj.SetActive(false);
			}
		}

		public static void Open()
		{
			if ((Object)(object)amountDialog == (Object)null)
			{
				return;
			}
			TradersExtended.LogInfo(isSellDialog);
			if (isSellDialog)
			{
				StorePanel.ItemToSell selectedItem = StorePanel.selectedItem;
				if (selectedItem == null || selectedItem.itemType != StorePanel.ItemToSell.ItemType.Combined || selectedItem.pricePerItem == 0 || !((Humanoid)Player.m_localPlayer).GetInventory().HaveItem(selectedItem.item.m_shared.m_name, true))
				{
					return;
				}
				int num = Math.Min(selectedItem.amount, selectedItem.item.m_shared.m_maxStackSize);
				if (TraderConfigManager.Get(storeGui.m_trader).TradersUseCoins)
				{
					num = GetMaximumAffordableSellAmount(TraderCoins.GetTraderCoins(), num);
					if (num < 1)
					{
						return;
					}
				}
				SetDialogAndOpen(selectedItem.item, num, selectedItem.currency ?? storeGui.m_coinPrefab);
			}
			else
			{
				if (!((Humanoid)Player.m_localPlayer).GetInventory().HaveEmptySlot())
				{
					return;
				}
				TradeItem selectedItem2 = storeGui.m_selectedItem;
				if (selectedItem2 != null && !StorePanel.ItemToSell.IsBuyBackItem(selectedItem2) && !((Object)(object)selectedItem2.m_prefab == (Object)null) && selectedItem2.m_price > 0)
				{
					int playerCurrencyAmount = TraderCurrency.GetPlayerCurrencyAmount(selectedItem2, storeGui);
					if (TradersExtended.TradeableItem.GetStackFromStack(selectedItem2.m_stack) == 1 && selectedItem2.m_prefab.m_itemData.m_shared.m_maxStackSize != 1 && playerCurrencyAmount >= selectedItem2.m_price)
					{
						SetDialogAndOpen(selectedItem2.m_prefab.m_itemData, playerCurrencyAmount / selectedItem2.m_price, TraderCurrency.GetCurrency(selectedItem2, storeGui));
					}
				}
			}
		}

		private static void SetDialogAndOpen(ItemData item, int maxValue, ItemDrop currency)
		{
			sliderTitleText = Localization.instance.Localize(item.m_shared.m_name);
			sliderButtonText = Localization.instance.Localize(isSellDialog ? "$store_sell" : "$store_buy");
			sliderDialog.value = 1f;
			sliderDialog.minValue = 1f;
			sliderDialog.maxValue = Math.Min(item.m_shared.m_maxStackSize, maxValue);
			sliderImage.sprite = item.GetIcon();
			UpdateCurrencyIcon(currency);
			OnSplitSliderChanged();
			amountDialog.SetActive(true);
		}

		public static void OnSplitSliderChanged(float value = 0f)
		{
			sliderAmountText.SetText(((int)sliderDialog.value).ToString());
			sliderAmountCoinsText.SetText(GetPrice().ToString());
		}

		private static void BuySelectedItem()
		{
			if (isSellDialog)
			{
				if (TraderCanAffordSelectedItem())
				{
					int amount = Mathf.CeilToInt(sliderDialog.value);
					int price = GetPrice();
					StorePanel.selectedItem.amount = amount;
					StorePanel.selectedItem.price = price;
					StorePanel.SellSelectedItem(storeGui);
				}
			}
			else if (CanAffordSelectedItem())
			{
				TradeItem selectedItem = storeGui.m_selectedItem;
				int stack = selectedItem.m_stack;
				int price2 = selectedItem.m_price;
				try
				{
					TradersExtended.TradeableItem.GetStackQualityFromStack(stack, out var _, out var quality);
					int num = Mathf.Min(Mathf.CeilToInt(sliderDialog.value), selectedItem.m_prefab.m_itemData.m_shared.m_maxStackSize);
					selectedItem.m_stack = TradersExtended.TradeableItem.GetStackFromStackQuality(num, quality);
					long num2 = (long)price2 * (long)num;
					selectedItem.m_price = (int)((num2 >= int.MaxValue) ? int.MaxValue : num2);
					storeGui.BuySelectedItem();
				}
				finally
				{
					selectedItem.m_stack = stack;
					selectedItem.m_price = price2;
				}
			}
			Close();
		}

		private static bool TraderCanAffordSelectedItem()
		{
			if (StorePanel.selectedItem == null)
			{
				return false;
			}
			return TraderCoins.CanSell(GetPrice());
		}

		private static bool CanAffordSelectedItem()
		{
			if (storeGui.m_selectedItem == null)
			{
				return false;
			}
			int playerCurrencyAmount = TraderCurrency.GetPlayerCurrencyAmount(storeGui.m_selectedItem, storeGui);
			return GetPrice() <= playerCurrencyAmount && ((Humanoid)Player.m_localPlayer).GetInventory().HaveEmptySlot();
		}

		private static int GetPricePerItem()
		{
			return isSellDialog ? StorePanel.selectedItem.pricePerItem : storeGui.m_selectedItem.m_price;
		}

		internal static int GetPrice()
		{
			return GetPriceForAmount(Mathf.CeilToInt(sliderDialog.value));
		}

		private static int GetPriceForAmount(int amount)
		{
			if (amount <= 0)
			{
				return 0;
			}
			if (isSellDialog)
			{
				return StorePanel.CalculateSellPrice(GetPricePerItem(), amount);
			}
			double num = (double)amount * (double)GetPricePerItem();
			if (double.IsNaN(num) || num >= 2147483647.0)
			{
				return int.MaxValue;
			}
			return Math.Max((int)Math.Ceiling(num), 1);
		}

		private static int GetMaximumAffordableSellAmount(int balance, int maximumAmount)
		{
			int num = 0;
			int num2 = Math.Max(maximumAmount, 0);
			while (num < num2)
			{
				int num3 = num + (num2 - num + 1) / 2;
				if (GetPriceForAmount(num3) <= balance)
				{
					num = num3;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return num;
		}
	}
	internal static class BuybackManager
	{
		[Serializable]
		private sealed class BuybackSaveData
		{
			public Dictionary<string, Dictionary<string, BuybackRecord>> worlds = new Dictionary<string, Dictionary<string, BuybackRecord>>(StringComparer.OrdinalIgnoreCase);
		}

		[Serializable]
		private sealed class BuybackRecord
		{
			public double createdAt;

			public string itemData;

			public StorePanel.ItemToSell.ItemType itemType;

			public int stack;

			public int price;

			public int amount;

			public int quality;

			public string currency;
		}

		private const string CustomDataKey = "shudnal.TradersExtended.Buyback";

		private static BuybackSaveData cachedData;

		private static Player cachedPlayer;

		private static string cachedRawData;

		internal static StorePanel.ItemToSell Get(Trader trader)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			if ((Object)(object)trader == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				return null;
			}
			string text = TradersExtended.TraderName(trader);
			ResolvedTraderConfig resolvedTraderConfig = TraderConfigManager.Get(trader);
			if (!resolvedTraderConfig.EnableBuybackForLastItemSold)
			{
				return null;
			}
			Dictionary<string, BuybackRecord> worldRecords = GetWorldRecords(create: false);
			if (worldRecords == null || !worldRecords.TryGetValue(text, out var value))
			{
				return null;
			}
			int num = Math.Max(resolvedTraderConfig.BuybackLifetimeInWorldSeconds, 0);
			if (num > 0 && GetWorldTime() - value.createdAt >= (double)num)
			{
				worldRecords.Remove(text);
				Save();
				return null;
			}
			try
			{
				Inventory val = new Inventory("Traders Extended buyback", (Sprite)null, 1, 1);
				val.Load(new ZPackage(value.itemData));
				ItemData val2 = val.GetAllItems().FirstOrDefault();
				if (val2 == null)
				{
					worldRecords.Remove(text);
					Save();
					return null;
				}
				return new StorePanel.ItemToSell
				{
					itemType = value.itemType,
					item = val2,
					stack = value.stack,
					price = value.price,
					amount = value.amount,
					quality = value.quality,
					currency = TraderCurrency.GetCurrency(value.currency, StoreGui.instance)
				};
			}
			catch (Exception ex)
			{
				TradersExtended.LogWarning("Could not restore buyback for trader '" + text + "': " + ex.Message);
				worldRecords.Remove(text);
				Save();
				return null;
			}
		}

		internal static void Set(Trader trader, StorePanel.ItemToSell item)
		{
			//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: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			if ((Object)(object)trader == (Object)null || item?.item == null || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			try
			{
				ItemData val = item.item.Clone();
				val.m_equipped = false;
				val.m_gridPos = new Vector2i(0, 0);
				Inventory val2 = new Inventory("Traders Extended buyback", (Sprite)null, 1, 1);
				val2.m_inventory.Add(val);
				ZPackage val3 = new ZPackage();
				val2.Save(val3);
				Dictionary<string, BuybackRecord> worldRecords = GetWorldRecords(create: true);
				if (worldRecords != null)
				{
					worldRecords[TradersExtended.TraderName(trader)] = new BuybackRecord
					{
						createdAt = GetWorldTime(),
						itemData = val3.GetBase64(),
						itemType = item.itemType,
						stack = item.stack,
						price = item.price,
						amount = item.amount,
						quality = item.quality,
						currency = (((Object)(object)item.currency != (Object)null) ? Utils.GetPrefabName(((Component)item.currency).gameObject) : string.Empty)
					};
					Save();
				}
			}
			catch (Exception ex)
			{
				TradersExtended.LogWarning("Could not save buyback for trader '" + TradersExtended.TraderName(trader) + "': " + ex.Message);
			}
		}

		internal static void Remove(Trader trader)
		{
			Dictionary<string, BuybackRecord> worldRecords = GetWorldRecords(create: false);
			if (worldRecords != null && !((Object)(object)trader == (Object)null) && worldRecords.Remove(TradersExtended.TraderName(trader)))
			{
				Save();
			}
		}

		internal static void ResetCache()
		{
			cachedData = null;
			cachedPlayer = null;
			cachedRawData = null;
		}

		private static Dictionary<string, BuybackRecord> GetWorldRecords(bool create)
		{
			BuybackSaveData buybackSaveData = Load();
			if (buybackSaveData == null || (Object)(object)ZNet.instance == (Object)null)
			{
				return null;
			}
			string key = ZNet.instance.GetWorldUID().ToString(CultureInfo.InvariantCulture);
			if (!buybackSaveData.worlds.TryGetValue(key, out var value) && create)
			{
				value = new Dictionary<string, BuybackRecord>(StringComparer.OrdinalIgnoreCase);
				buybackSaveData.worlds[key] = value;
			}
			return value;
		}

		private static BuybackSaveData Load()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return null;
			}
			localPlayer.m_customData.TryGetValue("shudnal.TradersExtended.Buyback", out var value);
			if ((Object)(object)cachedPlayer == (Object)(object)localPlayer && string.Equals(cachedRawData, value, StringComparison.Ordinal) && cachedData != null)
			{
				return cachedData;
			}
			cachedPlayer = localPlayer;
			cachedRawData = value;
			try
			{
				cachedData = (string.IsNullOrWhiteSpace(value) ? new BuybackSaveData() : (JsonConvert.DeserializeObject<BuybackSaveData>(value) ?? new BuybackSaveData()));
			}
			catch (Exception ex)
			{
				TradersExtended.LogWarning("Could not read saved buyback data: " + ex.Message);
				cachedData = new BuybackSaveData();
			}
			BuybackSaveData buybackSaveData = cachedData;
			if (buybackSaveData.worlds == null)
			{
				buybackSaveData.worlds = new Dictionary<string, Dictionary<string, BuybackRecord>>(StringComparer.OrdinalIgnoreCase);
			}
			return cachedData;
		}

		private static void Save()
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && cachedData != null)
			{
				cachedRawData = JsonConvert.SerializeObject((object)cachedData, (Formatting)0);
				localPlayer.m_customData["shudnal.TradersExtended.Buyback"] = cachedRawData;
				cachedPlayer = localPlayer;
			}
		}

		private static double GetWorldTime()
		{
			return ((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetTimeSeconds() : 0.0;
		}
	}
	internal static class CoinsPatches
	{
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		public static class ObjectDB_Awake_CoinsPatch
		{
			[HarmonyPriority(0)]
			private static void Postfix()
			{
				UpdateCoinsPrefab();
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		public static class ObjectDB_CopyOtherDB_CoinsPatch
		{
			[HarmonyPriority(0)]
			private static void Postfix()
			{
				UpdateCoinsPrefab();
			}
		}

		[HarmonyPatch(typeof(Player), "AddKnownItem")]
		public static class Player_AddKnownItem_CoinsPatch
		{
			private static void Postfix(ref ItemData item)
			{
				if (item != null && !(item.m_shared.m_name != "$item_coins"))
				{
					PatchCoinsItemData(item);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		public class Player_OnSpawned_CoinsPatch
		{
			public static void Postfix(Player __instance)
			{
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					PatchCoinsInInventory(((Humanoid)__instance).GetInventory());
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "Load")]
		public class Inventory_Load_CoinsPatch
		{
			public static void Postfix(Inventory __instance)
			{
				PatchCoinsInInventory(__instance);
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		private static class Inventory_AddItem_ItemData_amount_x_y_PatchCircletItemDataOnLoad
		{
			[HarmonyPriority(800)]
			private static void Prefix(ItemData item)
			{
				if (item != null && !(item.m_shared.m_name != "$item_coins"))
				{
					PatchCoinsItemData(item);
				}
			}
		}

		[HarmonyPatch(typeof(ItemDrop), "Start")]
		public static class ItemDrop_Start_CoinsPatch
		{
			private static void Postfix(ItemDrop __instance)
			{
				if (!(__instance.GetPrefabName(((Object)__instance).name) != "Coins"))
				{
					PatchCoinsItemData(__instance.m_itemData);
				}
			}
		}

		public const string itemNameCoins = "Coins";

		public const string itemDropNameCoins = "$item_coins";

		private static readonly List<ItemData> _itemDataList = new List<ItemData>();

		public static void PatchCoinsItemData(ItemData coins)
		{
			if (coins != null && TradersExtended.coinsPatch.Value)
			{
				coins.m_shared.m_weight = TradersExtended.coinsWeight.Value;
				coins.m_shared.m_maxStackSize = Math.Max(TradersExtended.coinsStackSize.Value, 1);
			}
		}

		public static void PatchCoinsInInventory(Inventory inventory)
		{
			if (inventory == null)
			{
				return;
			}
			_itemDataList.Clear();
			inventory.GetAllItems("$item_coins", _itemDataList);
			foreach (ItemData itemData in _itemDataList)
			{
				PatchCoinsItemData(itemData);
			}
		}

		public static void UpdateCoinsPrefab()
		{
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("Coins");
			if ((Object)(object)itemPrefab != (Object)null)
			{
				PatchCoinsItemData(itemPrefab.GetComponent<ItemDrop>()?.m_itemData);
			}
			Player localPlayer = Player.m_localPlayer;
			PatchCoinsInInventory((localPlayer != null) ? ((Humanoid)localPlayer).GetInventory() : null);
		}
	}
	internal sealed class ConfigEditor : IDisposable
	{
		private enum ItemSortColumn
		{
			Prefab,
			LocalizedName,
			Stack,
			Price,
			Quality,
			Currency,
			RequiredGlobalKey,
			BlockedGlobalKey,
			RequiredPlayerKey,
			BlockedPlayerKey
		}

		private enum ItemPickerSortColumn
		{
			Prefab,
			LocalizedName
		}

		private enum ItemRowAction
		{
			None,
			Delete,
			MoveUp,
			MoveDown
		}

		private enum KeyPickerKind
		{
			Global,
			Player
		}

		private sealed class ItemRowValidation
		{
			internal string Prefab = string.Empty;

			internal string Stack = string.Empty;

			internal string Price = string.Empty;

			internal string Quality = string.Empty;

			internal string Currency = string.Empty;

			internal string RequiredGlobalKey = string.Empty;

			internal string BlockedGlobalKey = string.Empty;

			internal string RequiredPlayerKey = string.Empty;

			internal string BlockedPlayerKey = string.Empty;

			internal bool HasErrors => !string.IsNullOrEmpty(Combined);

			internal string Combined => string.Join(" ", new string[9] { Prefab, Stack, Price, Quality, Currency, RequiredGlobalKey, BlockedGlobalKey, RequiredPlayerKey, BlockedPlayerKey }.Where((string value) => !string.IsNullOrWhiteSpace(value)).Distinct<string>(StringComparer.Ordinal));
		}

		private sealed class ItemSortValueComparer : IComparer<object>
		{
			internal static readonly ItemSortValueComparer Instance = new ItemSortValueComparer();

			public int Compare(object left, object right)
			{
				if (left == right)
				{
					return 0;
				}
				if (left == null)
				{
					return -1;
				}
				if (right == null)
				{
					return 1;
				}
				if (left is int num && right is int value)
				{
					return num.CompareTo(value);
				}
				return string.Compare(Convert.ToString(left, CultureInfo.CurrentCulture), Convert.ToString(right, CultureInfo.CurrentCulture), StringComparison.CurrentCultureIgnoreCase);
			}
		}

		private sealed class ItemOption
		{
			internal string Prefab { get; }

			internal string LocalizedName { get; }

			internal Sprite Icon { get; }

			internal bool VisibleByDefault { get; }

			internal ItemOption(string prefab, string localizedName, Sprite icon, bool visibleByDefault)
			{
				Prefab = prefab;
				LocalizedName = localizedName;
				Icon = icon;
				VisibleByDefault = visibleByDefault;
			}
		}

		private sealed class TraderOption
		{
			internal string Prefab { get; }

			internal string DisplayName { get; }

			internal TraderOption(string prefab, string displayName)
			{
				Prefab = prefab;
				DisplayName = displayName;
			}
		}

		private const int WindowId = 924617;

		private const int NewFileWindowId = 924618;

		private const int ItemPickerWindowId = 924619;

		private const int GlobalKeyWindowId = 924620;

		private const int ConfirmWindowId = 924621;

		private const float DefaultLeftPanelWidth = 382f;

		private const float MinimumLeftPanelWidth = 240f;

		private const float MaximumLeftPanelWidth = 800f;

		private const float ColumnSplitterWidth = 7f;

		private const float MinimumWidth = 1000f;

		private const float MinimumHeight = 600f;

		private const float TitleBarHeight = 22f;

		private const float ResizeEdgeHitSize = 4f;

		private const float ResizeHandleHitSize = 12f;

		private const float ResizeHandleVisualSize = 8f;

		private const float WindowBorderWidth = 1f;

		private const float LayoutSaveDelay = 0.5f;

		private const float CompactControlHeight = 20f;

		private const float CompactRowHeight = 22f;

		private const float ItemPickerControlHeight = 18f;

		private const float ItemPickerRowHeight = 20f;

		private const float ItemIconSize = 17f;

		private const float InlinePickerButtonWidth = 20f;

		private const float InlinePickerButtonHeight = 14f;

		private const float QuickDeleteButtonWidth = 18f;

		private const float ItemColumnSpacing = 3f;

		private const int ItemRowsPerPage = 100;

		private const float RequestTimeoutSeconds = 15f;

		private static readonly ItemSortColumn[] ItemColumnOrder = new ItemSortColumn[10]
		{
			ItemSortColumn.Prefab,
			ItemSortColumn.LocalizedName,
			ItemSortColumn.Stack,
			ItemSortColumn.Price,
			ItemSortColumn.Quality,
			ItemSortColumn.Currency,
			ItemSortColumn.RequiredGlobalKey,
			ItemSortColumn.BlockedGlobalKey,
			ItemSortColumn.RequiredPlayerKey,
			ItemSortColumn.BlockedPlayerKey
		};

		private readonly ConfigEditorCursor cursor = new ConfigEditorCursor();

		private readonly ConfigEditorGuiScale scale = new ConfigEditorGuiScale();

		private readonly ConfigEditorTheme theme = new ConfigEditorTheme();

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

		private readonly List<ItemOption> itemOptions = new List<ItemOption>();

		private readonly Dictionary<string, ItemOption> itemOptionsByPrefab = new Dictionary<string, ItemOption>(StringComparer.OrdinalIgnoreCase);

		private bool isOpen;

		private bool layoutLoaded;

		private bool resizing;

		private Vector2 resizeStartMouse;

		private Rect resizeStartRect;

		private bool resizeWidth;

		private bool resizeHeight;

		private bool layoutDirty;

		private bool splitterDragging;

		private Vector2 splitterDragStartMouse;

		private float splitterDragStartWidth;

		private float saveLayoutAfterRealtime;

		private Rect windowRect;

		private List<EditorFileInfo> files = new List<EditorFileInfo>();

		private EditorFileInfo activeFile;

		private ItemConfigDocument itemDocument;

		private TraderConfigDocument traderDocument;

		private string selectAfterList;

		private string fileSearch = string.Empty;

		private string itemSearch = string.Empty;

		private string statusText = string.Empty;

		private bool statusError;

		private bool requestInProgress;

		private float requestStartedAt;

		private Vector2 fileScroll;

		private Vector2 itemScroll;

		private int itemPage;

		private Vector2 settingsScroll;

		private bool showNewFile;

		private Rect newFileRect = new Rect(0f, 0f, 620f, 520f);

		private Vector2 newFileScroll;

		private EditorConfigKind newFileKind = EditorConfigKind.ItemList;

		private string newFileTrader = "common";

		private TradersExtended.ItemsListType newFileListType = TradersExtended.ItemsListType.Buy;

		private string newFileIdentifier = string.Empty;

		private string newFileExtension = "json";

		private bool showItemPicker;

		private Rect itemPickerRect = new Rect(0f, 0f, 572f, 650f);

		private string itemPickerSearch = string.Empty;

		private string itemPickerTitle = "Select item";

		private Vector2 itemPickerScroll;

		private int itemPickerPage;

		private ItemPickerSortColumn itemPickerSortColumn = ItemPickerSortColumn.Prefab;

		private bool itemPickerSortAscending = true;

		private Action<string> itemPickerCallback;

		private bool itemPickerMultiAdd;

		private bool showGlobalKeyPicker;

		private KeyPickerKind keyPickerKind = KeyPickerKind.Global;

		private string newPickerKey = string.Empty;

		private Rect globalKeyRect = new Rect(0f, 0f, 330f, 620f);

		private string globalKeySearch = string.Empty;

		private Vector2 globalKeyScroll;

		private HashSet<string> globalKeySelection = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private Action<string> globalKeyCallback;

		private bool showConfirm;

		private Rect confirmRect = new Rect(0f, 0f, 360f, 112f);

		private string confirmMessage = string.Empty;

		private Action confirmAction;

		private GUISkin styleSourceSkin;

		private GUIStyle windowStyle;

		private GUIStyle panelStyle;

		private GUIStyle selectedFileStyle;

		private GUIStyle fileStyle;

		private GUIStyle headerStyle;

		private GUIStyle toolbarStyle;

		private GUIStyle rowStyle;

		private GUIStyle itemRowStyle;

		private GUIStyle mutedStyle;

		private GUIStyle rightMutedStyle;

		private GUIStyle errorStyle;

		private GUIStyle titleStyle;

		private GUIStyle smallButtonStyle;

		private GUIStyle centeredMutedStyle;

		private GUIStyle centeredMessageStyle;

		private GUIStyle singleLineMutedStyle;

		private GUIStyle itemPrefabTextFieldStyle;

		private GUIStyle invalidItemIconStyle;

		private GUIStyle fileNameStyle;

		private GUIStyle pickerPrefabStyle;

		private GUIStyle pickerNameStyle;

		private GUIStyle keyNameStyle;

		private GUIStyle keySelectedNameStyle;

		private GUIStyle selectedValueLabelStyle;

		private GUIStyle selectedValueStyle;

		private GUIStyle serverSourceStyle;

		private GUIStyle inlineButtonStyle;

		private GUIStyle splitterStyle;

		private bool stylesInitialized;

		private bool itemOptionsBuilt;

		private float itemPrefabColumnWidth = 150f;

		private bool itemPrefabColumnWidthDirty = true;

		private string lastGuiExceptionSignature = string.Empty;

		private bool focusPopupWindow;

		private readonly HashSet<ItemSortColumn> visibleItemColumns = new HashSet<ItemSortColumn>();

		private string visibleItemColumnsSource = string.Empty;

		private List<TraderOption> temporaryTraderOptions;

		internal static bool IsOpenGlobal => TradersExtended.configEditor != null && TradersExtended.configEditor.IsOpen;

		internal bool IsOpen => isOpen;

		internal static bool IsDrawing { get; private set; }

		internal ConfigEditor()
		{
			//IL_008d: 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_00db: 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_0130: 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_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)
			ConfigEditorTransport.ResponseReceived += OnTransportResponse;
		}

		internal void MarkGameWindowReady()
		{
			scale.MarkGameWindowReady();
		}

		internal void Toggle()
		{
			SetOpen(!isOpen);
		}

		internal void Update()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (TradersExtended.configEditorShortcut != null)
			{
				KeyboardShortcut value = TradersExtended.configEditorShortcut.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					Toggle();
					return;
				}
			}
			if (isOpen && !AnyPopupOpen() && IsControlPressed() && UnityInput.Current.GetKeyDown((KeyCode)115))
			{
				if (activeFile != null && activeFile.Kind != EditorConfigKind.Unsupported && IsDirty() && !requestInProgress)
				{
					SaveActiveFile();
				}
				return;
			}
			if (isOpen && UnityInput.Current.GetKeyDown((KeyCode)27))
			{
				if (showConfirm)
				{
					showConfirm = false;
				}
				else if (showItemPicker)
				{
					CloseItemPicker();
				}
				else if (showGlobalKeyPicker)
				{
					showGlobalKeyPicker = false;
				}
				else if (showNewFile)
				{
					showNewFile = false;
				}
				else
				{
					RequestClose();
				}
			}
			if (requestInProgress && Time.realtimeSinceStartup - requestStartedAt > 15f)
			{
				requestInProgress = false;
				selectAfterList = null;
				SetStatus("The configuration request timed out. Check the server connection and mod version.", error: true);
			}
			if (resizing && !UnityInput.Current.GetKey((KeyCode)323))
			{
				ClearResizeState();
				MarkLayoutDirty();
			}
			if (splitterDragging && !UnityInput.Current.GetKey((KeyCode)323))
			{
				splitterDragging = false;
			}
			if (layoutDirty && Time.realtimeSinceStartup >= saveLayoutAfterRealtime)
			{
				SaveLayout();
			}
			cursor.Update(isOpen);
		}

		private bool AnyPopupOpen()
		{
			return showConfirm || showItemPicker || showGlobalKeyPicker || showNewFile;
		}

		private static bool IsControlPressed()
		{
			return UnityInput.Current.GetKey((KeyCode)306) || UnityInput.Current.GetKey((KeyCode)305);
		}

		internal void LateUpdate()
		{
			cursor.Update(isOpen);
		}

		internal void OnGUI()
		{
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0024: 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_0055: 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_00b6: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00db: 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_00f0: 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_00fa: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_0156: 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_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_01b0: 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_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: 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_0273: Expected O, but got Unknown
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Expected O, but got Unknown
			//IL_0218: 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)
			if (!isOpen)
			{
				return;
			}
			Matrix4x4 matrix = GUI.matrix;
			GUISkin skin = GUI.skin;
			Color contentColor = GUI.contentColor;
			IsDrawing = true;
			try
			{
				GUI.matrix = scale.Matrix;
				GUI.skin = theme.Skin;
				GUI.contentColor = theme.TextColor;
				EnsureStyles();
				cursor.Update(active: true);
				ClampWindowToScreen();
				bool flag = showConfirm || showItemPicker || showGlobalKeyPicker || showNewFile;
				bool enabled = GUI.enabled;
				GUI.enabled = !flag;
				Rect left = windowRect;
				windowRect = GUI.Window(924617, windowRect, new WindowFunction(DrawWindow), "Traders Extended configuration editor", windowStyle);
				GUI.enabled = enabled;
				windowRect = ClampRect(windowRect);
				if (RectChanged(left, windowRect))
				{
					MarkLayoutDirty();
				}
				if (showConfirm)
				{
					CenterModal(ref confirmRect);
					confirmRect = GUI.Window(924621, confirmRect, new WindowFunction(DrawConfirmWindow), "Confirm", windowStyle);
					KeepPopupInFront(924621);
				}
				else if (showItemPicker)
				{
					CenterModal(ref itemPickerRect);
					itemPickerRect = GUI.Window(924619, itemPickerRect, new WindowFunction(DrawItemPickerWindow), itemPickerTitle, windowStyle);
					KeepPopupInFront(924619);
				}
				else if (showGlobalKeyPicker)
				{
					CenterModal(ref globalKeyRect);
					globalKeyRect = GUI.Window(924620, globalKeyRect, new WindowFunction(DrawGlobalKeyWindow), (keyPickerKind == KeyPickerKind.Global) ? "Select global keys" : "Select player keys", windowStyle);
					KeepPopupInFront(924620);
				}
				else if (showNewFile)
				{
					CenterModal(ref newFileRect);
					newFileRect = GUI.Window(924618, newFileRect, new WindowFunction(DrawNewFileWindow), "Create configuration", windowStyle);
					KeepPopupInFront(924618);
				}
				lastGuiExceptionSignature = string.Empty;
			}
			catch (Exception ex)
			{
				string a = ex.GetType().FullName + ": " + ex.Message;
				if (!string.Equals(a, lastGuiExceptionSignature, StringComparison.Ordinal))
				{
					lastGuiExceptionSignature = a;
					ManualLogSource logger = TradersExtended.logger;
					if (logger != null)
					{
						logger.LogError((object)$"Configuration editor GUI error: {ex}");
					}
				}
				SetStatus("Editor GUI error: " + ex.Message, error: true);
			}
			finally
			{
				GUI.contentColor = contentColor;
				GUI.skin = skin;
				GUI.matrix = matrix;
				IsDrawing = false;
			}
		}

		public void Dispose()
		{
			ConfigEditorTransport.ResponseReceived -= OnTransportResponse;
			cursor.Release();
			theme.Shutdown();
		}

		private void SetOpen(bool value)
		{
			if (isOpen == value)
			{
				return;
			}
			if (!value && IsDirty())
			{
				ShowConfirmation("Discard unsaved changes and close the editor?", delegate
				{
					SetOpenImmediate(value: false);
				});
			}
			else
			{
				SetOpenImmediate(value);
			}
		}

		private void SetOpenImmediate(bool value)
		{
			isOpen = value;
			if (value)
			{
				LoadLayout();
				traderDisplayNames.Clear();
				RefreshFiles();
				BuildItemOptions();
				return;
			}
			SaveLayout();
			showNewFile = false;
			showItemPicker = false;
			showGlobalKeyPicker = false;
			showConfirm = false;
			resizing = false;
			splitterDragging = false;
			itemOptions.Clear();
			itemOptionsByPrefab.Clear();
			itemOptionsBuilt = false;
			itemPrefabColumnWidthDirty = true;
			cursor.Release();
		}

		private void RequestClose()
		{
			SetOpen(value: false);
		}

		private void DrawWindow(int windowId)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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)
			Event current = Event.current;
			Vector2 mousePosition = current.mousePosition;
			bool flag = TryApplyRealtimeMousePosition(current);
			try
			{
				HandleResizeInput();
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
				DrawFileColumn();
				DrawColumnSplitter();
				DrawEditorColumn();
				GUILayout.EndHorizontal();
				if (requestInProgress || !string.IsNullOrWhiteSpace(statusText))
				{
					GUILayout.BeginHorizontal(toolbarStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(26f) });
					GUILayout.Label(statusText ?? string.Empty, statusError ? errorStyle : mutedStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
					if (requestInProgress)
					{
						GUILayout.Label("Working...", mutedStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
					}
					GUILayout.EndHorizontal();
				}
				DrawWindowBorder();
				DrawResizeHandle();
				GUI.DragWindow(new Rect(0f, 0f, Mathf.Max(0f, ((Rect)(ref windowRect)).width - 4f), 22f));
			}
			finally
			{
				if (flag)
				{
					current.mousePosition = mousePosition;
				}
			}
		}

		private bool TryApplyRealtimeMousePosition(Event current)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0050: 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)
			if (current == null || ((int)current.type != 7 && (int)current.type != 8))
			{
				return false;
			}
			Vector2 val = scale.GetLogicalMousePosition() - ((Rect)(ref windowRect)).position;
			if (!IsFinite(val.x) || !IsFinite(val.y))
			{
				return false;
			}
			current.mousePosition = val;
			return true;
		}

		private static bool IsFinite(float value)
		{
			return !float.IsNaN(value) && !float.IsInfinity(value);
		}

		private static float GetHeaderToggleWidth(string text)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return Mathf.Ceil(GUI.skin.label.CalcSize(new GUIContent(text)).x + 22f);
		}

		private void DrawFileColumn()
		{
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(GetLeftPanelWidth()),
				GUILayout.ExpandHeight(true)
			});
			DrawFilePanel();
			GUILayout.EndVertical();
		}

		private void DrawEditorColumn()
		{
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.ExpandHeight(true)
			});
			DrawEditorPanel();
			GUILayout.EndVertical();
		}

		private float GetLeftPanelWidth()
		{
			float num = TradersExtended.configEditorFileListWidth?.Value ?? 382f;
			float num2 = Mathf.Min(800f, Mathf.Max(240f, ((Rect)(ref windowRect)).width * 0.65f));
			return Mathf.Clamp(num, 240f, num2);
		}

		private void DrawColumnSplitter()
		{
			//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_002d: 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_0058: 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_0078: 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_00a0: Invalid comparison between Unknown and I4
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Invalid comparison between Unknown and I4
			Rect rect = GUILayoutUtility.GetRect(7f, 1f, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(7f),
				GUILayout.ExpandHeight(true)
			});
			GUI.Box(rect, GUIContent.none, splitterStyle);
			Event current = Event.current;
			if ((int)current.type == 0 && current.button == 0 && ((Rect)(ref rect)).Contains(current.mousePosition))
			{
				splitterDragging = true;
				splitterDragStartMouse = current.mousePosition;
				splitterDragStartWidth = GetLeftPanelWidth();
				current.Use();
			}
			if (splitterDragging && (int)current.type == 3 && current.button == 0)
			{
				float num = Mathf.Min(800f, Mathf.Max(240f, ((Rect)(ref windowRect)).width * 0.65f));
				float value = Mathf.Clamp(splitterDragStartWidth + current.mousePosition.x - splitterDragStartMouse.x, 240f, num);
				if (TradersExtended.configEditorFileListWidth != null)
				{
					TradersExtended.configEditorFileListWidth.Value = value;
				}
				current.Use();
			}
			if (splitterDragging && (int)current.type == 1 && current.button == 0)
			{
				splitterDragging = false;
				current.Use();
			}
		}

		private void DrawFileActions()
		{
			GUI.enabled = !requestInProgress;
			if (GUILayout.Button("Refresh", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(62f),
				GUILayout.Height(20f)
			}))
			{
				RefreshFiles();
			}
			if (GUILayout.Button("New", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(42f),
				GUILayout.Height(20f)
			}))
			{
				OpenNewFileWindow();
			}
			GUI.enabled = activeFile != null && !requestInProgress;
			if (GUILayout.Button("Delete", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(54f),
				GUILayout.Height(20f)
			}))
			{
				DeleteActiveFile();
			}
			GUI.enabled = true;
		}

		private void DrawEditorActions()
		{
			bool flag = (GUI.enabled = activeFile != null && activeFile.Kind != EditorConfigKind.Unsupported && IsDirty() && !requestInProgress);
			GUIStyle val = (flag ? theme.AccentButtonStyle : smallButtonStyle);
			if (GUILayout.Button("Save", val, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(48f),
				GUILayout.Height(20f)
			}))
			{
				SaveActiveFile();
			}
			if (GUILayout.Button("Cancel", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(56f),
				GUILayout.Height(20f)
			}))
			{
				RevertActiveFile();
			}
			GUI.enabled = true;
		}

		private void DrawFilePanel()
		{
			//IL_0131: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(panelStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.ExpandHeight(true)
			});
			GUIStyle val = (ConfigEditorTransport.UsesRemoteServer ? serverSourceStyle : singleLineMutedStyle);
			string text = (ConfigEditorTransport.UsesRemoteServer ? "SERVER CONFIGURATION DIRECTORY" : "Local configuration directory");
			GUILayout.Label(text, val, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(20f)
			});
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Search", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(50f),
				GUILayout.Height(20f)
			});
			fileSearch = GUILayout.TextField(fileSearch ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(20f)
			});
			if (GUILayout.Button("×", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(22f),
				GUILayout.Height(20f)
			}))
			{
				fileSearch = string.Empty;
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(4f);
			fileScroll = GUILayout.BeginScrollView(fileScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			List<EditorFileInfo> list = files.Where(FileMatchesSearch).ToList();
			DrawFileGroup("Buy items", list.Where((EditorFileInfo file) => file.Kind == EditorConfigKind.ItemList && file.ListType == TradersExtended.ItemsListType.Buy));
			DrawFileGroup("Sell items", list.Where((EditorFileInfo file) => file.Kind == EditorConfigKind.ItemList && file.ListType == TradersExtended.ItemsListType.Sell));
			DrawFileGroup("Trader Settings", list.Where((EditorFileInfo file) => file.Kind == EditorConfigKind.TraderSettings));
			DrawFileGroup("Other files", list.Where((EditorFileInfo file) => file.Kind == EditorConfigKind.Unsupported));
			if (list.Count == 0)
			{
				GUILayout.Label("No matching files.", mutedStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndScrollView();
			GUILayout.Space(2f);
			GUILayout.BeginHorizontal(toolbarStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) });
			DrawFileActions();
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
		}

		private void DrawFileGroup(string title, IEnumerable<EditorFileInfo> source)
		{
			List<EditorFileInfo> list = source.OrderBy<EditorFileInfo, string>((EditorFileInfo file) => file.Trader, StringComparer.OrdinalIgnoreCase).ThenBy<EditorFileInfo, string>((EditorFileInfo file) => GetFileListDisplayName(file), StringComparer.OrdinalIgnoreCase).ToList();
			if (list.Count == 0)
			{
				return;
			}
			GUILayout.Label(title, headerStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(20f)
			});
			foreach (EditorFileInfo item in list)
			{
				DrawFileEntry(item);
			}
			GUILayout.Space(3f);
		}

		private void DrawFileEntry(EditorFileInfo file)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			GUIStyle val = ((activeFile != null && string.Equals(activeFile.Name, file.Name, StringComparison.OrdinalIgnoreCase)) ? selectedFileStyle : fileStyle);
			string fileListDisplayName = GetFileListDisplayName(file);
			float num = Mathf.Max(80f, GetLeftPanelWidth() - 28f);
			float num2 = Mathf.Max(titleStyle.lineHeight + 2f, fileNameStyle.CalcHeight(new GUIContent(fileListDisplayName), num));
			float num3 = Mathf.Max(30f, num2 + 10f);
			Rect rect = GUILayoutUtility.GetRect(0f, num3, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(num3)
			});
			if (GUI.Button(rect, GUIContent.none, val))
			{
				SelectFile(file);
			}
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref rect)).x + 8f, ((Rect)(ref rect)).y + 5f, Mathf.Max(0f, ((Rect)(ref rect)).width - 16f), num2);
			GUI.Label(val2, new GUIContent(fileListDisplayName, file.Name), fileNameStyle);
		}

		private string GetFileListDisplayName(EditorFileInfo file)
		{
			if (file == null)
			{
				return string.Empty;
			}
			string text = (string.Equals(file.Trader, "common", StringComparison.OrdinalIgnoreCase) ? "Common" : (file.Trader ?? string.Empty));
			string text2 = Path.GetExtension(file.Name).TrimStart(new char[1] { '.' }).ToLowerInvariant();
			if (file.Kind == EditorConfigKind.ItemList && TradersExtended.TryParseConfigFileName(file.Name, out var _, out var _, out var identifier))
			{
				return string.IsNullOrWhiteSpace(identifier) ? (text + " · " + text2) : (text + " · " + identifier + " · " + text2);
			}
			if (file.Kind == EditorConfigKind.TraderSettings)
			{
				return text + " · " + text2;
			}
			return file.Name;
		}

		private void DrawEditorPanel()
		{
			GUILayout.BeginVertical(panelStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.ExpandHeight(true)
			});
			DrawEditorHeader();
			if (activeFile == null)
			{
				GUILayout.FlexibleSpace();
				GUILayout.Label("Select a configuration file or create a new one.", titleStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
				GUILayout.FlexibleSpace();
			}
			else if (activeFile.Kind == EditorConfigKind.Unsupported)
			{
				GUILayout.FlexibleSpace();
				GUILayout.Label("The file name does not match a supported Traders Extended configuration pattern.", errorStyle, Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
			}
			else if (itemDocument != null)
			{
				DrawItemEditor();
			}
			else if (traderDocument != null)
			{
				DrawTraderEditor();
			}
			else
			{
				GUILayout.FlexibleSpace();
				GUILayout.Label(requestInProgress ? "Loading configuration..." : "Configuration is not loaded.", mutedStyle, Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
			}
			GUILayout.EndVertical();
		}

		private void DrawEditorHeader()
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			float num = Mathf.Max(20f, titleStyle.lineHeight + 3f);
			float num2 = Mathf.Max(26f, num + 6f);
			GUILayout.BeginHorizontal(toolbarStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(num2) });
			string text = ((activeFile == null) ? "No file selected" : ((itemDocument != null) ? $"{GetTraderDisplayName(activeFile.Trader)} — {activeFile.ListType}" : ((traderDocument != null) ? (GetTraderDisplayName(traderDocument.Trader) + " (" + traderDocument.Trader + ")") : "Configuration")));
			float num3 = Mathf.Ceil(titleStyle.CalcSize(new GUIContent(text)).x * 1.2f + 4f);
			GUILayout.Label(text, titleStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num3),
				GUILayout.Height(num)
			});
			GUILayout.Space(8f);
			DrawEditorActions();
			GUILayout.Space(8f);
			string text2 = ((activeFile == null) ? string.Empty : activeFile.Name);
			GUILayout.Label(text2, pickerNameStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(false),
				GUILayout.Height(num)
			});
			GUILayout.FlexibleSpace();
			bool flag = ConfigEditorGui.ToggleLayout(theme, TradersExtended.configEditorBlockGameInput?.Value ?? false, new GUIContent("Prevent input", "Block all Valheim gameplay input while the configuration editor is open."), GetHeaderToggleWidth("Prevent input"));
			if (TradersExtended.configEditorBlockGameInput != null && flag != TradersExtended.configEditorBlockGameInput.Value)
			{
				TradersExtended.configEditorBlockGameInput.Value = flag;
			}
			if (GUILayout.Button("Close", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(52f),
				GUILayout.Height(20f)
			}))
			{
				RequestClose();
			}
			GUILayout.EndHorizontal();
		}

		private void DrawItemEditor()
		{
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0562: Unknown result type (might be due to invalid IL or missing references)
			EnsureItemOptions();
			EnsureVisibleItemColumns();
			List<EditorItemRow> list = itemDocument.Rows.Where(ItemMatchesSearch).ToList();
			int num = Math.Max(1, (list.Count + 100 - 1) / 100);
			itemPage = Mathf.Clamp(itemPage, 0, num - 1);
			List<EditorItemRow> list2 = list.Skip(itemPage * 100).Take(100).ToList();
			GUILayout.BeginHorizontal(toolbarStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) });
			if (GUILayout.Button("Add item...", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(88f),
				GUILayout.Height(20f)
			}))
			{
				OpenItemPicker("Add item", delegate(string prefab)
				{
					AddItemRow(prefab);
				}, multiAdd: false);
			}
			GUILayout.Space(2f);
			if (GUILayout.Button("Add items...", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(92f),
				GUILayout.Height(20f)
			}))
			{
				OpenItemPicker("Add items", delegate(string prefab)
				{
					AddItemRow(prefab);
				}, multiAdd: true);
			}
			GUILayout.Space(2f);
			if (GUILayout.Button("Add blank", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(76f),
				GUILayout.Height(20f)
			}))
			{
				itemDocument.Rows.Add(new EditorItemRow(new TradersExtended.TradeableItem()));
				itemDocument.Dirty = true;
			}
			GUILayout.Space(2f);
			if (GUILayout.Button("Select filtered", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(100f),
				GUILayout.Height(20f)
			}))
			{
				foreach (EditorItemRow item in list)
				{
					item.Selected = true;
				}
			}
			GUILayout.Space(2f);
			if (GUILayout.Button("Clear selection", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(100f),
				GUILayout.Height(20f)
			}))
			{
				foreach (EditorItemRow row in itemDocument.Rows)
				{
					row.Selected = false;
				}
			}
			GUILayout.Space(2f);
			int num2 = itemDocument.Rows.Count((EditorItemRow row) => row.Selected);
			GUI.enabled = num2 > 0;
			if (GUILayout.Button($"Delete selected ({num2})", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(140f),
				GUILayout.Height(20f)
			}))
			{
				itemDocument.Rows.RemoveAll((EditorItemRow row) => row.Selected);
				itemDocument.Dirty = true;
			}
			GUI.enabled = true;
			GUILayout.Space(10f);
			GUILayout.Label("Search", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(50f),
				GUILayout.Height(20f)
			});
			string a = GUILayout.TextField(itemSearch ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(150f),
				GUILayout.Height(20f)
			});
			if (!string.Equals(a, itemSearch, StringComparison.Ordinal))
			{
				itemSearch = a;
				itemPage = 0;
			}
			if (GUILayout.Button("×", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(20f),
				GUILayout.Height(20f)
			}))
			{
				itemSearch = string.Empty;
				itemPage = 0;
			}
			GUILayout.FlexibleSpace();
			GUI.enabled = itemPage > 0;
			if (GUILayout.Button("◀", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(28f),
				GUILayout.Height(20f)
			}))
			{
				itemPage--;
				itemScroll = Vector2.zero;
			}
			GUI.enabled = true;
			GUILayout.Label($"Page {itemPage + 1}/{num}", centeredMutedStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(75f),
				GUILayout.Height(20f)
			});
			GUI.enabled = itemPage + 1 < num;
			if (GUILayout.Button("▶", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(28f),
				GUILayout.Height(20f)
			}))
			{
				itemPage++;
				itemScroll = Vector2.zero;
			}
			GUI.enabled = true;
			GUILayout.Label($"Rows: {itemDocument.Rows.Count}; filtered: {list.Count}", centeredMutedStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(180f),
				GUILayout.Height(20f)
			});
			GUILayout.EndHorizontal();
			itemScroll = GUILayout.BeginScrollView(itemScroll, true, true, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.ExpandHeight(true)
			});
			DrawItemHeader();
			EditorItemRow editorItemRow = null;
			ItemRowAction itemRowAction = ItemRowAction.None;
			foreach (EditorItemRow item2 in list2)
			{
				int rowIndex = itemDocument.Rows.IndexOf(item2);
				ItemRowAction itemRowAction2 = DrawItemRow(item2, rowIndex);
				if (itemRowAction2 != ItemRowAction.None)
				{
					editorItemRow = item2;
					itemRowAction = itemRowAction2;
				}
			}
			GUILayout.EndScrollView();
			if (editorItemRow != null)
			{
				int num3 = itemDocument.Rows.IndexOf(editorItemRow);
				if (itemRowAction == ItemRowAction.Delete)
				{
					itemDocument.Rows.Remove(editorItemRow);
				}
				else if (itemRowAction == ItemRowAction.MoveUp && num3 > 0)
				{
					MoveItemRow(num3, num3 - 1);
				}
				else if (itemRowAction == ItemRowAction.MoveDown && num3 >= 0 && num3 + 1 < itemDocument.Rows.Count)
				{
					MoveItemRow(num3, num3 + 1);
				}
				itemDocument.Dirty = true;
			}
			DrawItemSortControls();
			DrawItemColumnVisibilityControls();
		}

		private void AddItemRow(string prefab)
		{
			itemDocument.Rows.Add(new EditorItemRow(new TradersExtended.TradeableItem
			{
				prefab = prefab
			}));
			itemDocument.Dirty = true;
		}

		private void DrawItemHeader()
		{
			float width = GetItemPrefabColumnWidth();
			GUILayout.BeginHorizontal(headerStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(22f) });
			Header("", 22f);
			ItemColumnGap();
			Header("", 17f);
			ItemColumnGap();
			if (IsItemColumnVisible(ItemSortColumn.Prefab))
			{
				Header("Prefab", width);
				ItemColumnGap();
			}
			Header("", 18f);
			ItemColumnGap();
			Header("", 18f);
			ItemColumnGap();
			Header("", 18f);
			ItemColumnGap();
			if (IsItemColumnVisible(ItemSortColumn.LocalizedName))
			{
				Header("Localized name", 170f);
				ItemColumnGap();
			}
			Header("", 20f);
			ItemColumnGap();
			if (IsItemColumnVisible(ItemSortColumn.Stack))
			{
				Header("Stack", 55f);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.Price))
			{
				Header("Price", 60f);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.Quality))
			{
				Header("Quality", 55f);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.Currency))
			{
				Header("Currency", 140f);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.RequiredGlobalKey))
			{
				Header("Required global key", 155f);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.BlockedGlobalKey))
			{
				Header("Blocked global key", 155f);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.RequiredPlayerKey))
			{
				Header("Required player key", 150f);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.BlockedPlayerKey))
			{
				Header("Blocked player key", 150f);
			}
			GUILayout.EndHorizontal();
		}

		private ItemRowAction DrawItemRow(EditorItemRow row, int rowIndex)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Expected O, but got Unknown
			//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0514: Unknown result type (might be due to invalid IL or missing references)
			//IL_0524: Unknown result type (might be due to invalid IL or missing references)
			//IL_0531: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Expected O, but got Unknown
			ItemRowValidation itemRowValidation = BuildItemRowValidation(row);
			row.ValidationError = itemRowValidation.Combined;
			float width = GetItemPrefabColumnWidth();
			ItemRowAction result = ItemRowAction.None;
			GUILayout.BeginHorizontal(itemRowStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(22f) });
			bool flag = ConfigEditorGui.ToggleLayout(theme, row.Selected, GUIContent.none, 22f, mutedStyle, 0f);
			if (flag != row.Selected)
			{
				row.Selected = flag;
			}
			ItemColumnGap();
			if (!string.IsNullOrEmpty(itemRowValidation.Prefab))
			{
				GUILayout.Label(new GUIContent("!", itemRowValidation.Prefab), invalidItemIconStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(17f),
					GUILayout.Height(17f)
				});
			}
			else
			{
				DrawItemIcon(row.Item.prefab, 17f);
			}
			ItemColumnGap();
			if (IsItemColumnVisible(ItemSortColumn.Prefab))
			{
				string text = DrawValidatedTextField(row.Item.prefab ?? string.Empty, itemPrefabTextFieldStyle, string.Empty, width, 20f);
				if (!string.Equals(text, row.Item.prefab, StringComparison.Ordinal))
				{
					row.Item.prefab = text;
					itemDocument.Dirty = true;
				}
				ItemColumnGap();
			}
			if (DrawQuickActionButton("×", "Delete row"))
			{
				result = ItemRowAction.Delete;
			}
			ItemColumnGap();
			GUI.enabled = rowIndex > 0;
			if (DrawQuickActionButton("↑", "Move row up"))
			{
				result = ItemRowAction.MoveUp;
			}
			GUI.enabled = true;
			ItemColumnGap();
			GUI.enabled = rowIndex >= 0 && rowIndex + 1 < itemDocument.Rows.Count;
			if (DrawQuickActionButton("↓", "Move row down"))
			{
				result = ItemRowAction.MoveDown;
			}
			GUI.enabled = true;
			ItemColumnGap();
			if (IsItemColumnVisible(ItemSortColumn.LocalizedName))
			{
				string itemDisplayName = GetItemDisplayName(row.Item.prefab);
				GUILayout.Label(new GUIContent(itemDisplayName, itemDisplayName), pickerNameStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(170f),
					GUILayout.Height(20f)
				});
				ItemColumnGap();
			}
			if (DrawInlinePickerButton())
			{
				OpenItemPicker("Select item prefab", delegate(string value)
				{
					row.Item.prefab = value;
					itemDocument.Dirty = true;
				}, multiAdd: false);
			}
			ItemColumnGap();
			if (IsItemColumnVisible(ItemSortColumn.Stack))
			{
				DrawIntegerField(ref row.StackText, delegate(int value)
				{
					row.Item.stack = value;
				}, 55f, itemRowValidation.Stack);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.Price))
			{
				DrawIntegerField(ref row.PriceText, delegate(int value)
				{
					row.Item.price = value;
				}, 60f, itemRowValidation.Price);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.Quality))
			{
				DrawIntegerField(ref row.QualityText, delegate(int value)
				{
					row.Item.quality = value;
				}, 55f, itemRowValidation.Quality);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.Currency))
			{
				DrawPrefabField(row.Item.currency, delegate(string value)
				{
					row.Item.currency = value;
				}, 140f, "Select currency item", itemRowValidation.Currency);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.RequiredGlobalKey))
			{
				DrawKeyField(row.Item.requiredGlobalKey, delegate(string value)
				{
					row.Item.requiredGlobalKey = value;
				}, 155f, KeyPickerKind.Global, itemRowValidation.RequiredGlobalKey);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.BlockedGlobalKey))
			{
				DrawKeyField(row.Item.notRequiredGlobalKey, delegate(string value)
				{
					row.Item.notRequiredGlobalKey = value;
				}, 155f, KeyPickerKind.Global, itemRowValidation.BlockedGlobalKey);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.RequiredPlayerKey))
			{
				DrawKeyField(row.Item.requiredPlayerKey, delegate(string value)
				{
					row.Item.requiredPlayerKey = value;
				}, 150f, KeyPickerKind.Player, itemRowValidation.RequiredPlayerKey);
				ItemColumnGap();
			}
			if (IsItemColumnVisible(ItemSortColumn.BlockedPlayerKey))
			{
				DrawKeyField(row.Item.notRequiredPlayerKey, delegate(string value)
				{
					row.Item.notRequiredPlayerKey = value;
				}, 150f, KeyPickerKind.Player, itemRowValidation.BlockedPlayerKey);
			}
			GUILayout.EndHorizontal();
			if (itemRowValidation.HasErrors)
			{
				Rect lastRect = GUILayoutUtility.GetLastRect();
				DrawOutline(lastRect, new Color(0.9f, 0.2f, 0.18f, 1f), 1f);
				GUI.Label(lastRect, new GUIContent(string.Empty, itemRowValidation.Combined), GUIStyle.none);
			}
			return result;
		}

		private void MoveItemRow(int sourceIndex, int destinationIndex)
		{
			if (sourceIndex >= 0 && destinationIndex >= 0 && sourceIndex < itemDocument.Rows.Count && destinationIndex < itemDocument.Rows.Count && sourceIndex != destinationIndex)
			{
				EditorItemRow item = itemDocument.Rows[sourceIndex];
				itemDocument.Rows.RemoveAt(sourceIndex);
				itemDocument.Rows.Insert(destinationIndex, item);
			}
		}

		private void DrawItemSortControls()
		{
			int num = itemDocument.Rows.Count((EditorItemRow row) => row.Selected);
			bool flag = num > 1;
			GUILayout.BeginHorizontal(toolbarStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(26f) });
			GUILayout.Label(flag ? "Sort selected by:" : "Sort by:", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(flag ? 102f : 48f),
				GUILayout.Height(20f)
			});
			DrawItemSortCommand("Prefab", ItemSortColumn.Prefab, 48f, flag);
			DrawItemSortCommand("Name", ItemSortColumn.LocalizedName, 40f, flag);
			DrawItemSortCommand("Stack", ItemSortColumn.Stack, 40f, flag);
			DrawItemSortCommand("Price", ItemSortColumn.Price, 36f, flag);
			DrawItemSortCommand("Quality", ItemSortColumn.Quality, 46f, flag);
			DrawItemSortCommand("Currency", ItemSortColumn.Currency, 58f, flag);
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
		}

		private void DrawItemSortCommand(string label, ItemSortColumn column, float labelWidth, bool selectedOnly)
		{
			GUILayout.Label(label, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(labelWidth),
				GUILayout.Height(20f)
			});
			if (GUILayout.Button("↑", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(22f),
				GUILayout.Height(20f)
			}))
			{
				SortItemRows(column, ascending: true, selectedOnly);
			}
			if (GUILayout.Button("↓", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(22f),
				GUILayout.Height(20f)
			}))
			{
				SortItemRows(column, ascending: false, selectedOnly);
			}
			GUILayout.Space(5f);
		}

		private void DrawItemColumnVisibilityControls()
		{
			GUILayout.BeginHorizontal(toolbarStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(29f) });
			GUILayout.Label("Columns:", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(58f),
				GUILayout.Height(20f)
			});
			DrawItemColumnToggle(ItemSortColumn.Prefab, "Prefab", 72f);
			DrawItemColumnToggle(ItemSortColumn.LocalizedName, "Name", 62f);
			DrawItemColumnToggle(ItemSortColumn.Stack, "Stack", 62f);
			DrawItemColumnToggle(ItemSortColumn.Price, "Price", 58f);
			DrawItemColumnToggle(ItemSortColumn.Quality, "Quality", 70f);
			DrawItemColumnToggle(ItemSortColumn.Currency, "Currency", 82f);
			DrawItemColumnToggle(ItemSortColumn.RequiredGlobalKey, "Req global", 96f);
			DrawItemColumnToggle(ItemSortColumn.BlockedGlobalKey, "Block global", 104f);
			DrawItemColumnToggle(ItemSortColumn.RequiredPlayerKey, "Req player", 96f);
			DrawItemColumnToggle(ItemSortColumn.BlockedPlayerKey, "Block player", 104f);
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
		}

		private void DrawItemColumnToggle(ItemSortColumn column, string label, float width)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			bool flag = IsItemColumnVisible(column);
			bool flag2 = ConfigEditorGui.ToggleLayout(theme, flag, new GUIContent(label), width, singleLineMutedStyle, 0f, 22f);
			if (flag2 != flag)
			{
				SetItemColumnVisible(column, flag2);
			}
		}

		private void DrawTraderEditor()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.Label("Enable Override for a field to store a trader-specific value. Disabled fields inherit the synchronized BepInEx configuration.", mutedStyle, Array.Empty<GUILayoutOption>());
			settingsScroll = GUILayout.BeginScrollView(settingsScroll, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.ExpandHeight(true)
			});
			foreach (IGrouping<string, TraderSettingState> item in from state in traderDocument.Settings
				group state by state.Definition.Section)
			{
				GUILayout.Label("— " + item.Key + " —", headerStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(20f) });
				foreach (TraderSettingState item2 in item)
				{
					DrawTraderSetting(item2);
				}
			}
			GUILayout.EndScrollView();
		}

		private void DrawTraderSetting(TraderSettingState state)
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_00e4: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(rowStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			bool flag = ConfigEditorGui.ToggleLayout(theme, state.HasOverride, GUIContent.none, 22f, mutedStyle, 0f);
			if (flag != state.HasOverride)
			{
				state.HasOverride = flag;
				if (flag)
				{
					state.Value = state.Definition.Fallback(traderDocument.Trader);
					state.EditText = TraderConfigSchema.FormatEditText(state.Definition.Type, state.Value);
					state.ValidationError = string.Empty;
					if (state.Definition.Type == TraderSettingType.Vector2)
					{
						Vector2 val = ((state.Value is Vector2 val2) ? val2 : Vector2.zero);
						state.VectorXText = val.x.ToString("0.###", CultureInfo.InvariantCulture);
						state.VectorYText = val.y.ToString("0.###", CultureInfo.InvariantCulture);
					}
				}
				traderDocument.Dirty = true;
			}
			GUILayout.Label(new GUIContent(state.Definition.Name, state.Definition.Description), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(360f) });
			GUI.enabled = state.HasOverride;
			DrawTraderValue(state);
			GUI.enabled = true;
			if (!state.HasOverride)
			{
				GUILayout.Label("Inherited: " + FormatValue(state.Definition.Type, state.Definition.Fallback(traderDocument.Trader)), mutedStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(240f) });
			}
			GUILayout.EndHorizontal();
			if (state.HasOverride && !string.IsNullOrWhiteSpace(state.ValidationError))
			{
				GUILayout.Label(state.ValidationError, errorStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndVertical();
		}

		private void DrawTraderValue(TraderSettingState state)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			switch (state.Definition.Type)
			{
			case TraderSettingType.Boolean:
			{
				object value = state.Value;
				bool flag = default(bool);
				int num;
				if (value is bool)
				{
					flag = (bool)value;
					num = 1;
				}
				else
				{
					num = 0;
				}
				bool flag2 = (byte)((uint)num & (flag ? 1u : 0u)) != 0;
				bool flag3 = ConfigEditorGui.ToggleLayout(theme, flag2, new GUIContent(flag2 ? "Enabled" : "Disabled"), 150f);
				if (flag3 != flag2)
				{
					state.Value = flag3;
					state.ValidationError = string.Empty;
					traderDocument.Dirty = true;
				}
				break;
			}
			case TraderSettingType.Integer:
			{
				string text7 = GUILayout.TextField(state.EditText ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) });
				if (!string.Equals(text7, state.EditText, StringComparison.Ordinal))
				{
					state.EditText = text7;
					if (int.TryParse(text7, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3))
					{
						state.Value = result3;
						state.ValidationError = string.Empty;
						traderDocument.Dirty = true;
					}
					else
					{
						state.ValidationError = "Enter a valid integer.";
					}
				}
				break;
			}
			case TraderSettingType.Float:
			{
				string text8 = GUILayout.TextField(state.EditText ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) });
				if (!string.Equals(text8, state.EditText, StringComparison.Ordinal))
				{
					state.EditText = text8;
					if (float.TryParse(text8, NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
					{
						state.Value = result4;
						state.ValidationError = string.Empty;
						traderDocument.Dirty = true;
					}
					else
					{
						state.ValidationError = "Enter a valid number using a dot as the decimal separator.";
					}
				}
				break;
			}
			case TraderSettingType.String:
			{
				string text5 = state.Value?.ToString() ?? string.Empty;
				string text6 = GUILayout.TextField(text5, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.MinWidth(260f),
					GUILayout.ExpandWidth(true)
				});
				if (!string.Equals(text5, text6, StringComparison.Ordinal))
				{
					state.Value = text6;
					state.ValidationError = string.Empty;
					traderDocument.Dirty = true;
				}
				break;
			}
			case TraderSettingType.ItemPrefab:
			{
				string text3 = state.Value?.ToString() ?? string.Empty;
				string text4 = GUILayout.TextField(text3, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(125f),
					GUILayout.Height(20f)
				});
				if (!string.Equals(text3, text4, StringComparison.Ordinal))
				{
					state.Value = text4;
					state.ValidationError = ValidateItemPrefab(text4);
					traderDocument.Dirty = true;
				}
				else
				{
					state.ValidationError = (state.HasOverride ? ValidateItemPrefab(text3) : string.Empty);
				}
				if (DrawInlinePickerButton())
				{
					OpenItemPicker("Select item prefab", delegate(string prefab)
					{
						state.Value = prefab;
						state.EditText = prefab;
						state.ValidationError = string.Empty;
						traderDocument.Dirty = true;
					}, multiAdd: false);
				}
				GUILayout.Label(GetItemDisplayName(state.Value?.ToString()), pickerNameStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(150f),
					GUILayout.Height(20f)
				});
				break;
			}
			case TraderSettingType.Vector2:
			{
				GUILayout.Label("x", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(12f) });
				string text = GUILayout.TextField(state.VectorXText ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(85f) });
				GUILayout.Label("y", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(12f) });
				string text2 = GUILayout.TextField(state.VectorYText ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(85f) });
				if (!string.Equals(text, state.VectorXText, StringComparison.Ordinal) || !string.Equals(text2, state.VectorYText, StringComparison.Ordinal))
				{
					state.VectorXText = text;
					state.VectorYText = text2;
					if (float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(text2, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
					{
						state.Value = (object)new Vector2(result, result2);
						state.ValidationError = string.Empty;
						traderDocument.Dirty = true;
					}
					else
					{
						state.ValidationError = "Both x and y must be valid numbers using a dot as the decimal separator.";
					}
				}
				break;
			}
			}
		}

		private void DrawNewFileWindow(int windowId)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			newFileScroll = GUILayout.BeginScrollView(newFileScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			GUILayout.Label("Configuration type", headerStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Item list", (newFileKind == EditorConfigKind.ItemList) ? theme.AccentButtonStyle : smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				newFileKind = EditorConfigKind.ItemList;
			}
			if (GUILayout.Button("Trader settings", (newFileKind == EditorConfigKind.TraderSettings) ? theme.AccentButtonStyle : smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				newFileKind = EditorConfigKind.TraderSettings;
				if (string.Equals(newFileTrader, "common", StringComparison.OrdinalIgnoreCase))
				{
					newFileTrader = "Haldor";
				}
				if (newFileExtension == "csv")
				{
					newFileExtension = "json";
				}
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(8f);
			GUILayout.Label("Trader prefab", headerStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			newFileTrader = GUILayout.TextField(newFileTrader ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			if (GUILayout.Button("Select...", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(90f) }))
			{
				OpenTraderPicker();
			}
			GUILayout.EndHorizontal();
			GUILayout.Label(GetTraderDisplayName(newFileTrader), mutedStyle, Array.Empty<GUILayoutOption>());
			if (newFileKind == EditorConfigKind.ItemList)
			{
				GUILayout.Space(8f);
				GUILayout.Label("List type", headerStyle, Array.Empty<GUILayoutOption>());
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (GUILayout.Button("Buy", (newFileListType == TradersExtended.ItemsListType.Buy) ? theme.AccentButtonStyle : smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					newFileListType = TradersExtended.ItemsListType.Buy;
				}
				if (GUILayout.Button("Sell", (newFileListType == TradersExtended.ItemsListType.Sell) ? theme.AccentButtonStyle : smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
				{
					newFileListType = TradersExtended.ItemsListType.Sell;
				}
				GUILayout.EndHorizontal();
				GUILayout.Label("Optional dot-separated identifier", headerStyle, Array.Empty<GUILayoutOption>());
				newFileIdentifier = GUILayout.TextField(newFileIdentifier ?? string.Empty, Array.Empty<GUILayoutOption>());
			}
			GUILayout.Space(8f);
			GUILayout.Label("File format", headerStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			DrawFormatToggle("json");
			DrawFormatToggle("yaml");
			DrawFormatToggle("yml");
			if (newFileKind == EditorConfigKind.ItemList)
			{
				DrawFormatToggle("csv");
			}
			GUILayout.EndHorizontal();
			string text = BuildNewFileName();
			GUILayout.Space(8f);
			GUILayout.Label("File name", headerStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(text, panelStyle, Array.Empty<GUILayoutOption>());
			string text2 = ValidateNewFile(text);
			if (!string.IsNullOrEmpty(text2))
			{
				GUILayout.Label(text2, errorStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndScrollView();
			GUILayout.BeginHorizontal(toolbarStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) });
			GUI.enabled = string.IsNullOrEmpty(text2) && !requestInProgress;
			if (GUILayout.Button("Create", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				CreateNewFile(text);
			}
			GUI.enabled = true;
			if (GUILayout.Button("Cancel", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				showNewFile = false;
			}
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
			DrawModalBorder(((Rect)(ref newFileRect)).width, ((Rect)(ref newFileRect)).height);
			GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref newFileRect)).width, 22f));
		}

		private void DrawItemPickerWindow(int windowId)
		{
			//IL_00ba: 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_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: 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_01cd: Expected O, but got Unknown
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0696: Unknown result type (might be due to invalid IL or missing references)
			//IL_069b: Unknown result type (might be due to invalid IL or missing references)
			//IL_074d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0752: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e5: Unknown result type (might be due to invalid IL or missing references)
			bool flag = temporaryTraderOptions != null;
			bool flag2 = false;
			string text = null;
			string value = null;
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(18f) });
			GUILayout.Label("Search", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(49f),
				GUILayout.Height(18f)
			});
			string a = GUILayout.TextField(itemPickerSearch ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(18f)
			});
			if (!string.Equals(a, itemPickerSearch, StringComparison.Ordinal))
			{
				itemPickerSearch = a;
				itemPickerPage = 0;
				itemPickerScroll = Vector2.zero;
			}
			if (GUILayout.Button("×", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(20f),
				GUILayout.Height(18f)
			}))
			{
				itemPickerSearch = string.Empty;
				itemPickerPage = 0;
				itemPickerScroll = Vector2.zero;
			}
			if (!flag)
			{
				GUILayout.Space(3f);
				GUILayout.Label("Sort", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(29f),
					GUILayout.Height(18f)
				});
				DrawItemPickerSortButton("Prefab", ItemPickerSortColumn.Prefab, 70f);
				DrawItemPickerSortButton("Name", ItemPickerSortColumn.LocalizedName, 64f);
				GUILayout.Space(3f);
				bool flag3 = ConfigEditorGui.ToggleLayout(theme, TradersExtended.configEditorShowAllItems?.Value ?? false, new GUIContent("Show all", "Include AI equipment and items without a normal user-facing name, description or icon."), 70f, singleLineMutedStyle, 0f);
				if (TradersExtended.configEditorShowAllItems != null && flag3 != TradersExtended.configEditorShowAllItems.Value)
				{
					TradersExtended.configEditorShowAllItems.Value = flag3;
					itemPickerPage = 0;
					itemPickerScroll = Vector2.zero;
				}
			}
			GUILayout.Space(3f);
			if (GUILayout.Button("Close", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(52f),
				GUILayout.Height(18f)
			}))
			{
				flag2 = true;
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(4f);
			itemPickerScroll = GUILayout.BeginScrollView(itemPickerScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			int count;
			int num;
			if (flag)
			{
				List<TraderOption> list = temporaryTraderOptions.Where(TraderOptionMatchesSearch).ToList();
				count = list.Count;
				num = Math.Max(1, (count + 100 - 1) / 100);
				itemPickerPage = Mathf.Clamp(itemPickerPage, 0, num - 1);
				foreach (TraderOption item in list.Skip(itemPickerPage * 100).Take(100))
				{
					GUILayout.BeginHorizontal(rowStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(20f) });
					GUILayout.Label(item.DisplayName, pickerNameStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.ExpandWidth(true),
						GUILayout.Height(20f)
					});
					GUILayout.Space(3f);
					GUILayout.Label(item.Prefab, pickerPrefabStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(214f),
						GUILayout.Height(20f)
					});
					GUILayout.Space(3f);
					if (GUILayout.Button("Select", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(56f),
						GUILayout.Height(17f)
					}))
					{
						value = item.Prefab;
					}
					GUILayout.EndHorizontal();
				}
			}
			else
			{
				bool showAll = TradersExtended.configEditorShowAllItems?.Value ?? false;
				List<ItemOption> list2 = SortItemPickerOptions(itemOptions.Where((ItemOption option) => (showAll || option.VisibleByDefault) && ItemOptionMatchesSearch(option)));
				count = list2.Count;
				num = Math.Max(1, (count + 100 - 1) / 100);
				itemPickerPage = Mathf.Clamp(itemPickerPage, 0, num - 1);
				foreach (ItemOption item2 in list2.Skip(itemPickerPage * 100).Take(100))
				{
					GUILayout.BeginHorizontal(rowStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(20f) });
					DrawSprite(item2.Icon, 17f);
					GUILayout.Space(3f);
					GUILayout.Label(item2.Prefab, pickerPrefabStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(214f),
						GUILayout.Height(20f)
					});
					GUILayout.Space(3f);
					GUILayout.Label(item2.LocalizedName, pickerNameStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.ExpandWidth(true),
						GUILayout.Height(20f)
					});
					GUILayout.Space(3f);
					string text2 = (itemPickerMultiAdd ? "Add item" : "Select");
					float num2 = (itemPickerMultiAdd ? 65f : 59f);
					if (GUILayout.Button(text2, smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(num2),
						GUILayout.Height(17f)
					}))
					{
						if (itemPickerMultiAdd)
						{
							itemPickerCallback?.Invoke(item2.Prefab);
						}
						else
						{
							text = item2.Prefab;
						}
					}
					GUILayout.EndHorizontal();
				}
			}
			GUILayout.EndScrollView();
			GUILayout.Space(4f);
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(18f) });
			GUI.enabled = itemPickerPage > 0;
			if (GUILayout.Button("Previous", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(72f),
				GUILayout.Height(18f)
			}))
			{
				itemPickerPage--;
				itemPickerScroll = Vector2.zero;
			}
			GUI.enabled = true;
			GUILayout.Label($"Page {itemPickerPage + 1}/{num} — {count} result(s)", centeredMutedStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(18f)
			});
			GUI.enabled = itemPickerPage + 1 < num;
			if (GUILayout.Button("Next", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(60f),
				GUILayout.Height(18f)
			}))
			{
				itemPickerPage++;
				itemPickerScroll = Vector2.zero;
			}
			GUI.enabled = true;
			if (GUILayout.Button("Close", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(58f),
				GUILayout.Height(18f)
			}))
			{
				flag2 = true;
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(4f);
			GUILayout.EndVertical();
			DrawModalBorder(((Rect)(ref itemPickerRect)).width, ((Rect)(ref itemPickerRect)).height);
			GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref itemPickerRect)).width, 24f));
			if (!string.IsNullOrEmpty(value))
			{
				newFileTrader = value;
				CloseItemPicker();
			}
			else if (!string.IsNullOrEmpty(text))
			{
				Action<string> action = itemPickerCallback;
				CloseItemPicker();
				action?.Invoke(text);
			}
			else if (flag2)
			{
				CloseItemPicker();
			}
		}

		private void DrawGlobalKeyWindow(int windowId)
		{
			//IL_0150: 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_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c9: Expected O, but got Unknown
			//IL_06eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Expected O, but got Unknown
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(18f) });
			GUILayout.Label("Search", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(49f),
				GUILayout.Height(18f)
			});
			globalKeySearch = GUILayout.TextField(globalKeySearch ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(18f)
			});
			if (GUILayout.Button("×", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(20f),
				GUILayout.Height(18f)
			}))
			{
				globalKeySearch = string.Empty;
			}
			if (GUILayout.Button("Close", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(50f),
				GUILayout.Height(18f)
			}))
			{
				showGlobalKeyPicker = false;
				globalKeyCallback = null;
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(4f);
			HashSet<string> activeKeys = GetActiveKeys(keyPickerKind);
			List<string> keyOptions = GetKeyOptions(keyPickerKind);
			HashSet<string> hashSet = new HashSet<string>(GetDefaultKeyOptions(keyPickerKind), StringComparer.OrdinalIgnoreCase);
			globalKeyScroll = GUILayout.BeginScrollView(globalKeyScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			Rect rect2 = default(Rect);
			Rect val = default(Rect);
			Rect val2 = default(Rect);
			foreach (string key in keyOptions.Where(GlobalKeyMatchesSearch).ToList())
			{
				Rect rect = GUILayoutUtility.GetRect(0f, 22f, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.ExpandWidth(true),
					GUILayout.Height(22f)
				});
				GUI.Box(rect, GUIContent.none, rowStyle);
				float compactToggleSize = theme.CompactToggleSize;
				((Rect)(ref rect2))..ctor(((Rect)(ref rect)).x + 4f, ((Rect)(ref rect)).y + Mathf.Max(0f, (((Rect)(ref rect)).height - compactToggleSize) * 0.5f), compactToggleSize, compactToggleSize);
				bool flag = globalKeySelection.Contains(key);
				bool flag2 = ConfigEditorGui.Toggle(theme, rect2, flag, GUIContent.none, keyNameStyle, 0f);
				if (flag2 && !flag)
				{
					globalKeySelection.Add(key);
				}
				else if (!flag2 && flag)
				{
					globalKeySelection.Remove(key);
				}
				bool flag3 = hashSet.Contains(key);
				float num = (flag3 ? 0f : 16f);
				((Rect)(ref val))..ctor(((Rect)(ref rect2)).xMax + 5f, ((Rect)(ref rect)).y, Mathf.Max(0f, ((Rect)(ref rect)).xMax - ((Rect)(ref rect2)).xMax - 9f - num), ((Rect)(ref rect)).height);
				string text = (activeKeys.Contains(key) ? (key + "  [active]") : key);
				GUI.Label(val, new GUIContent(text, key), flag ? keySelectedNameStyle : keyNameStyle);
				if (flag3)
				{
					continue;
				}
				((Rect)(ref val2))..ctor(((Rect)(ref rect)).xMax - 17f, ((Rect)(ref rect)).y + 3f, 14f, 14f);
				if (GUI.Button(val2, "×", inlineButtonStyle))
				{
					keyOptions.RemoveAll((string value) => string.Equals(value, key, StringComparison.OrdinalIgnoreCase));
					globalKeySelection.Remove(key);
					SetKeyOptions(keyPickerKind, keyOptions);
					break;
				}
			}
			GUILayout.EndScrollView();
			GUILayout.Space(4f);
			GUILayout.BeginHorizontal(toolbarStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(18f) });
			newPickerKey = GUILayout.TextField(newPickerKey ?? string.Empty, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(18f)
			});
			GUI.enabled = !string.IsNullOrWhiteSpace(newPickerKey);
			if (GUILayout.Button("Add key", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(58f),
				GUILayout.Height(18f)
			}))
			{
				string text2 = newPickerKey.Trim();
				if (!keyOptions.Contains<string>(text2, StringComparer.OrdinalIgnoreCase))
				{
					keyOptions.Add(text2);
					SetKeyOptions(keyPickerKind, keyOptions);
				}
				newPickerKey = string.Empty;
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.Space(4f);
			string text3 = string.Join(",", globalKeySelection.OrderBy<string, string>((string result) => result, StringComparer.OrdinalIgnoreCase));
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(20f) });
			GUILayout.Label("Selected value:", selectedValueLabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(false),
				GUILayout.Height(20f)
			});
			GUILayout.Label(new GUIContent(text3, text3), selectedValueStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(20f)
			});
			GUILayout.EndHorizontal();
			GUILayout.Space(2f);
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(18f) });
			GUILayout.FlexibleSpace();
			if (GUILayout.Button("Apply", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(50f),
				GUILayout.Height(18f)
			}))
			{
				Action<string> action = globalKeyCallback;
				showGlobalKeyPicker = false;
				globalKeyCallback = null;
				action?.Invoke(text3);
			}
			if (GUILayout.Button("Close", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(50f),
				GUILayout.Height(18f)
			}))
			{
				showGlobalKeyPicker = false;
				globalKeyCallback = null;
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(2f);
			GUILayout.EndVertical();
			DrawModalBorder(((Rect)(ref globalKeyRect)).width, ((Rect)(ref globalKeyRect)).height);
			GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref globalKeyRect)).width, 24f));
		}

		private void DrawConfirmWindow(int windowId)
		{
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.Space(6f);
			GUILayout.Label(confirmMessage ?? string.Empty, centeredMessageStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.ExpandHeight(true)
			});
			GUILayout.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (GUILayout.Button("Confirm", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(72f),
				GUILayout.Height(24f)
			}))
			{
				Action action = confirmAction;
				showConfirm = false;
				confirmAction = null;
				action?.Invoke();
			}
			GUILayout.Space(6f);
			if (GUILayout.Button("Cancel", smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(64f),
				GUILayout.Height(24f)
			}))
			{
				showConfirm = false;
				confirmAction = null;
			}
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUILayout.Space(4f);
			GUILayout.EndVertical();
			DrawModalBorder(((Rect)(ref confirmRect)).width, ((Rect)(ref confirmRect)).height);
			GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref confirmRect)).width, 24f));
		}

		private void RefreshFiles()
		{
			BeginRequest("Loading configuration files...");
			ConfigEditorTransport.RequestList();
		}

		private void SelectFile(EditorFileInfo file)
		{
			if (file == null || (activeFile != null && string.Equals(activeFile.Name, file.Name, StringComparison.OrdinalIgnoreCase)))
			{
				return;
			}
			if (IsDirty())
			{
				ShowConfirmation("Discard unsaved changes and open another file?", delegate
				{
					OpenFile(file);
				});
			}
			else
			{
				OpenFile(file);
			}
		}

		private void OpenFile(EditorFileInfo file)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			activeFile = file;
			itemDocument = null;
			traderDocument = null;
			itemSearch = string.Empty;
			itemPage = 0;
			itemScroll = Vector2.zero;
			if (file.Kind == EditorConfigKind.Unsupported)
			{
				SetStatus("Unsupported configuration file name.", error: true);
				return;
			}
			BeginRequest("Loading " + file.Name + "...");
			ConfigEditorTransport.RequestRead(file.Name);
		}

		private void SaveActiveFile()
		{
			if (activeFile == null || requestInProgress)
			{
				return;
			}
			try
			{
				string extension = Path.GetExtension(activeFile.Name);
				string content;
				if (itemDocument != null)
				{
					if (!itemDocument.Validate(out var error))
					{
						throw new InvalidDataException(error);
					}
					if (!ValidateItemRows(out error))
					{
						throw new InvalidDataException(error);
					}
					content = ConfigEditorSerialization.SerializeItems(itemDocument.GetItems(), extension);
				}
				else
				{
					if (traderDocument == null)
					{
						return;
					}
					TraderSettingState traderSettingState = traderDocument.Settings.FirstOrDefault((TraderSettingState state) => state.HasOverride && !string.IsNullOrWhiteSpace(state.ValidationError));
					if (traderSettingState != null)
					{
						throw new InvalidDataException("Fix invalid value: " + traderSettingState.Definition.Section + " / " + traderSettingState.Definition.Name + ".");
					}
					content = ConfigEditorSerialization.SerializeTrader(traderDocument.BuildRoot(), extension);
				}
				BeginRequest("Saving " + activeFile.Name + "...");
				ConfigEditorTransport.RequestWrite(activeFile.Name, content);
			}
			catch (Exception ex)
			{
				SetStatus(ex.Message, error: true);
			}
		}

		private void RevertActiveFile()
		{
			if (activeFile == null)
			{
				return;
			}
			if (IsDirty())
			{
				ShowConfirmation("Discard unsaved changes and reload this file?", delegate
				{
					OpenFile(activeFile);
				});
			}
			else
			{
				OpenFile(activeFile);
			}
		}

		private void DeleteActiveFile()
		{
			if (activeFile != null && !requestInProgress)
			{
				string fileName = activeFile.Name;
				ShowConfirmation("Delete '" + fileName + "' from " + ConfigEditorTransport.TargetDescription + "?", delegate
				{
					BeginRequest("Deleting " + fileName + "...");
					ConfigEditorTransport.RequestDelete(fileName);
				});
			}
		}

		private void OpenNewFileWindow()
		{
			if (!ConfigEditorTransport.CanEditTarget)
			{
				SetStatus("Administrator access is required to create files on this server.", error: true);
			}
			else if (IsDirty())
			{
				ShowConfirmation("Discard unsaved changes and create a new configuration file?", OpenNewFileWindowImmediate);
			}
			else
			{
				OpenNewFileWindowImmediate();
			}
		}

		private void OpenNewFileWindowImmediate()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			activeFile = null;
			itemDocument = null;
			traderDocument = null;
			showNewFile = true;
			newFileRect = new Rect(0f, 0f, 620f, 520f);
			newFileScroll = Vector2.zero;
			newFileKind = EditorConfigKind.ItemList;
			newFileTrader = "common";
			newFileListType = TradersExtended.ItemsListType.Buy;
			newFileIdentifier = string.Empty;
			newFileExtension = "json";
			focusPopupWindow = true;
		}

		private void CreateNewFile(string fileName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			string content = ((newFileKind == EditorConfigKind.ItemList) ? ConfigEditorSerialization.SerializeItems(Array.Empty<TradersExtended.TradeableItem>(), Path.GetExtension(fileName)) : ConfigEditorSerialization.SerializeTrader(new JObject(), Path.GetExtension(fileName)));
			showNewFile = false;
			selectAfterList = fileName;
			BeginRequest("Creating " + fileName + "...");
			ConfigEditorTransport.RequestCreate(fileName, content);
		}

		private void OnTransportResponse(ConfigEditorOperation operation, bool success, string fileName, string message, string payload)
		{
			requestInProgress = false;
			SetStatus(success ? string.Empty : message, !success);
			if (!success)
			{
				if ((operation == ConfigEditorOperation.Write || operation == ConfigEditorOperation.Create) && string.Equals(selectAfterList, fileName, StringComparison.OrdinalIgnoreCase))
				{
					selectAfterList = null;
				}
				return;
			}
			switch (operation)
			{
			case ConfigEditorOperation.List:
				files = JsonConvert.DeserializeObject<List<EditorFileInfo>>(payload) ?? new List<EditorFileInfo>();
				if (!string.IsNullOrWhiteSpace(selectAfterList))
				{
					string target = selectAfterList;
					selectAfterList = null;
					EditorFileInfo editorFileInfo = files.FirstOrDefault((EditorFileInfo entry) => string.Equals(entry.Name, target, StringComparison.OrdinalIgnoreCase));
					if (editorFileInfo != null)
					{
						OpenFile(editorFileInfo);
					}
				}
				else if (activeFile != null)
				{
					activeFile = files.FirstOrDefault((EditorFileInfo entry) => string.Equals(entry.Name, activeFile.Name, StringComparison.OrdinalIgnoreCase));
					if (activeFile == null)
					{
						itemDocument = null;
						traderDocument = null;
					}
				}
				break;
			case ConfigEditorOperation.Read:
				LoadDocument(fileName, payload);
				break;
			case ConfigEditorOperation.Write:
			case ConfigEditorOperation.Create:
				if (itemDocument != null && string.Equals(itemDocument.FileName, fileName, StringComparison.OrdinalIgnoreCase))
				{
					itemDocument.Dirty = false;
				}
				if (traderDocument != null && string.Equals(traderDocument.FileName, fileName, StringComparison.OrdinalIgnoreCase))
				{
					traderDocument.Dirty = false;
				}
				if (string.IsNullOrWhiteSpace(selectAfterList))
				{
					selectAfterList = fileName;
				}
				RefreshFiles();
				break;
			case ConfigEditorOperation.Delete:
				if (activeFile != null && string.Equals(activeFile.Name, fileName, StringComparison.OrdinalIgnoreCase))
				{
					activeFile = null;
					itemDocument = null;
					traderDocument = null;
				}
				RefreshFiles();
				break;
			}
		}

		private void LoadDocument(string fileName, string content)
		{
			EditorFileInfo editorFileInfo = files.FirstOrDefault((EditorFileInfo entry) => string.Equals(entry.Name, fileName, StringComparison.OrdinalIgnoreCase)) ?? activeFile;
			if (editorFileInfo == null)
			{
				return;
			}
			activeFile = editorFileInfo;
			try
			{
				if (editorFileInfo.Kind == EditorConfigKind.ItemList)
				{
					List<TradersExtended.TradeableItem> list = TradersExtended.DeserializeItems(content, fileName);
					if (list == null)
					{
						throw new InvalidDataException("The item configuration could not be parsed.");
					}
					itemDocument = new ItemConfigDocument(fileName, list);
					traderDocument = null;
				}
				else if (editorFileInfo.Kind == EditorConfigKind.TraderSettings)
				{
					JObject val = TraderConfigManager.DeserializeTraderConfig(content, fileName);
					if (val == null)
					{
						throw new InvalidDataException("The trader configuration could not be parsed.");
					}
					traderDocument = new TraderConfigDocument(fileName, editorFileInfo.Trader, val);
					itemDocument = null;
				}
				SetStatus(string.Empty, error: false);
			}
			catch (Exception ex)
			{
				itemDocument = null;
				traderDocument = null;
				SetStatus(ex.Message, error: true);
			}
		}

		private void OpenItemPicker(string title, Action<string> callback, bool multiAdd)
		{
			//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)
			if (showItemPicker)
			{
				focusPopupWindow = true;
				return;
			}
			temporaryTraderOptions = null;
			EnsureItemOptions();
			itemPickerTitle = title;
			itemPickerCallback = callback;
			itemPickerMultiAdd = multiAdd;
			itemPickerSearch = string.Empty;
			itemPickerPage = 0;
			itemPickerScroll = Vector2.zero;
			((Rect)(ref itemPickerRect)).width = 572f;
			showItemPicker = true;
			focusPopupWindow = true;
		}

		private void CloseItemPicker()
		{
			showItemPicker = false;
			temporaryTraderOptions = null;
			itemPickerCallback = null;
			itemPickerMultiAdd = false;
		}

		private void OpenTraderPicker()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			List<TraderOption> traderOptions = GetTraderOptions();
			showItemPicker = true;
			focusPopupWindow = true;
			itemPickerTitle = "Select trader prefab";
			itemPickerSearch = string.Empty;
			itemPickerPage = 0;
			itemPickerScroll = Vector2.zero;
			itemPickerCallback = null;
			itemPickerMultiAdd = false;
			temporaryTraderOptions = traderOptions;
		}

		private void OpenKeyPicker(string currentValue, KeyPickerKind kind, Action<string> callback)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			keyPickerKind = kind;
			globalKeySelection = new HashSet<string>(SplitKeyValues(currentValue), StringComparer.OrdinalIgnoreCase);
			globalKeyCallback = callback;
			globalKeySearch = string.Empty;
			globalKeyScroll = Vector2.zero;
			newPickerKey = string.Empty;
			((Rect)(ref globalKeyRect)).width = 330f;
			showGlobalKeyPicker = true;
			focusPopupWindow = true;
		}

		private void ShowConfirmation(string message, Action action)
		{
			//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)
			confirmMessage = message ?? string.Empty;
			confirmAction = action;
			int num = Math.Max(1, confirmMessage.Split(new char[1] { '\n' }, StringSplitOptions.None).Length);
			float num2 = Mathf.Clamp(120f + (float)confirmMessage.Length * 5.4f, 300f, 620f);
			float num3 = 92f + (float)Math.Max(0, num - 1) * 18f;
			confirmRect = new Rect(0f, 0f, num2, num3);
			showConfirm = true;
			focusPopupWindow = true;
		}

		private void DrawIntegerField(ref string text, Action<int> setter, float width, string validationError)
		{
			string text2 = DrawValidatedTextField(text ?? string.Empty, GUI.skin.textField, validationError, width, 20f);
			if (!string.Equals(text2, text, StringComparison.Ordinal))
			{
				text = text2;
				if (int.TryParse(text2, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
				{
					setter(result);
				}
				itemDocument.Dirty = true;
			}
		}

		private string DrawValidatedTextField(string value, GUIStyle style, string validationError, float width, float height)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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)
			Color contentColor = GUI.contentColor;
			if (!string.IsNullOrEmpty(validationError))
			{
				GUI.contentColor = new Color(1f, 0.35f, 0.3f, 1f);
			}
			string result = GUILayout.TextField(value ?? string.Empty, style, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(width),
				GUILayout.Height(height)
			});
			GUI.contentColor = contentColor;
			return result;
		}

		private void DrawPrefabField(string value, Action<string> setter, float width, string title, string validationError)
		{
			DrawPickerField(value, setter, width, validationError, delegate
			{
				OpenItemPicker(title, delegate(string prefab)
				{
					setter(prefab);
					itemDocument.Dirty = true;
				}, multiAdd: false);
			});
		}

		private void DrawKeyField(string value, Action<string> setter, float width, KeyPickerKind kind, string validationError)
		{
			DrawPickerField(value, setter, width, validationError, delegate
			{
				OpenKeyPicker(value, kind, delegate(string keys)
				{
					setter(keys);
					itemDocument.Dirty = true;
				});
			});
		}

		private void DrawPickerField(string value, Action<string> setter, float width, string validationError, Action openPicker)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00b0: 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)
			Rect rect = GUILayoutUtility.GetRect(width, 20f, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(width),
				GUILayout.Height(20f)
			});
			float num = Mathf.Max(30f, width - 20f - 3f);
			float y = ((Rect)(ref rect)).y;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref rect)).x, y, num, 20f);
			Color contentColor = GUI.contentColor;
			if (!string.IsNullOrEmpty(validationError))
			{
				GUI.contentColor = new Color(1f, 0.35f, 0.3f, 1f);
			}
			string text = GUI.TextField(val, value ?? string.Empty, GUI.skin.textField);
			GUI.contentColor = contentColor;
			if (!string.Equals(text, value, StringComparison.Ordinal))
			{
				setter(text);
				itemDocument.Dirty = true;
			}
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref val)).xMax + 3f, y + Mathf.Max(0f, 3f), 20f, 14f);
			if (GUI.Button(val2, "...", inlineButtonStyle))
			{
				openPicker?.Invoke();
			}
		}

		private bool DrawInlinePickerButton()
		{
			//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_006e: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = GUILayoutUtility.GetRect(20f, 20f, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(20f),
				GUILayout.Height(20f)
			});
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref rect)).x, ((Rect)(ref rect)).y + Mathf.Max(0f, (((Rect)(ref rect)).height - 14f) * 0.5f), 20f, 14f);
			return GUI.Button(val, "...", inlineButtonStyle);
		}

		private bool DrawQuickActionButton(string text, string tooltip)
		{
			//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_006e: 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_0081: Expected O, but got Unknown
			Rect rect = GUILayoutUtility.GetRect(18f, 20f, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(18f),
				GUILayout.Height(20f)
			});
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref rect)).x, ((Rect)(ref rect)).y + Mathf.Max(0f, (((Rect)(ref rect)).height - 14f) * 0.5f), 18f, 14f);
			return GUI.Button(val, new GUIContent(text, tooltip), inlineButtonStyle);
		}

		private void KeepPopupInFront(int windowId)
		{
			GUI.BringWindowToFront(windowId);
			if (focusPopupWindow)
			{
				GUI.FocusWindow(windowId);
				focusPopupWindow = false;
			}
		}

		private static void ItemColumnGap()
		{
			GUILayout.Space(3f);
		}

		private float GetItemPrefabColumnWidth()
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			EnsureItemOptions();
			if (!itemPrefabColumnWidthDirty)
			{
				return itemPrefabColumnWidth;
			}
			GUISkin skin = GUI.skin;
			object obj = ((skin != null) ? skin.textField : null);
			if (obj == null)
			{
				GUISkin skin2 = GUI.skin;
				obj = ((skin2 != null) ? skin2.label : null);
			}
			GUIStyle val = (GUIStyle)obj;
			float num = 120f;
			if (val != null)
			{
				foreach (ItemOption itemOption in itemOptions)
				{
					num = Mathf.Max(num, val.CalcSize(new GUIContent(itemOption.Prefab ?? string.Empty)).x * 0.96f + 6f);
				}
			}
			itemPrefabColumnWidth = Mathf.Ceil(num);
			itemPrefabColumnWidthDirty = false;
			return itemPrefabColumnWidth;
		}

		private static void DrawOutline(Rect rect, Color color, float thickness)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//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_005c: 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_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_00e2: Unknown result type (might be due to invalid IL or missing references)
			if ((int)Event.current.type == 7 && !(((Rect)(ref rect)).width <= 0f) && !(((Rect)(ref rect)).height <= 0f))
			{
				Color color2 = GUI.color;
				GUI.color = color;
				GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width, thickness), (Texture)(object)Texture2D.whiteTexture);
				GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).yMax - thickness, ((Rect)(ref rect)).width, thickness), (Texture)(object)Texture2D.whiteTexture);
				GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, thickness, ((Rect)(ref rect)).height), (Texture)(object)Texture2D.whiteTexture);
				GUI.DrawTexture(new Rect(((Rect)(ref rect)).xMax - thickness, ((Rect)(ref rect)).y, thickness, ((Rect)(ref rect)).height), (Texture)(object)Texture2D.whiteTexture);
				GUI.color = color2;
			}
		}

		private void DrawItemIcon(string prefab, float size)
		{
			itemOptionsByPrefab.TryGetValue(prefab ?? string.Empty, out var value);
			DrawSprite(value?.Icon, size);
		}

		private void DrawSprite(Sprite sprite, float size)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00aa: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = GUILayoutUtility.GetRect(size, size, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(size),
				GUILayout.Height(size)
			});
			if ((Object)(object)sprite == (Object)null || (Object)(object)sprite.texture == (Object)null)
			{
				GUI.Box(rect, GUIContent.none);
				return;
			}
			Rect textureRect = sprite.textureRect;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref textureRect)).x / (float)((Texture)sprite.texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)sprite.texture).height, ((Rect)(ref textureRect)).width / (float)((Texture)sprite.texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)sprite.texture).height);
			GUI.DrawTextureWithTexCoords(rect, (Texture)(object)sprite.texture, val, true);
		}

		private void DrawItemPickerSortButton(string text, ItemPickerSortColumn column, float width)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			bool flag = itemPickerSortColumn == column;
			string text2 = ((!flag) ? string.Empty : (itemPickerSortAscending ? " ▲" : " ▼"));
			if (GUILayout.Button(text + text2, flag ? theme.AccentButtonStyle : smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(width),
				GUILayout.Height(18f)
			}))
			{
				if (flag)
				{
					itemPickerSortAscending = !itemPickerSortAscending;
				}
				else
				{
					itemPickerSortColumn = column;
					itemPickerSortAscending = true;
				}
				itemPickerPage = 0;
				itemPickerScroll = Vector2.zero;
			}
		}

		private List<ItemOption> SortItemPickerOptions(IEnumerable<ItemOption> options)
		{
			Func<ItemOption, string> keySelector = ((itemPickerSortColumn == ItemPickerSortColumn.LocalizedName) ? ((Func<ItemOption, string>)((ItemOption option) => option.LocalizedName ?? string.Empty)) : ((Func<ItemOption, string>)((ItemOption option) => option.Prefab ?? string.Empty)));
			IOrderedEnumerable<ItemOption> source = (itemPickerSortAscending ? options.OrderBy<ItemOption, string>(keySelector, StringComparer.CurrentCultureIgnoreCase) : options.OrderByDescending<ItemOption, string>(keySelector, StringComparer.CurrentCultureIgnoreCase));
			return source.ThenBy<ItemOption, string>((ItemOption option) => option.Prefab ?? string.Empty, StringComparer.OrdinalIgnoreCase).ToList();
		}

		private void SortItemRows(ItemSortColumn column, bool ascending, bool selectedOnly)
		{
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			Func<EditorItemRow, object> func = column switch
			{
				ItemSortColumn.LocalizedName => (EditorItemRow row) => GetItemDisplayName(row.Item.prefab), 
				ItemSortColumn.Stack => (EditorItemRow row) => row.Item.stack, 
				ItemSortColumn.Price => (EditorItemRow row) => row.Item.price, 
				ItemSortColumn.Quality => (EditorItemRow row) => row.Item.quality, 
				ItemSortColumn.Currency => (EditorItemRow row) => row.Item.currency ?? string.Empty, 
				ItemSortColumn.RequiredGlobalKey => (EditorItemRow row) => row.Item.requiredGlobalKey ?? string.Empty, 
				ItemSortColumn.BlockedGlobalKey => (EditorItemRow row) => row.Item.notRequiredGlobalKey ?? string.Empty, 
				ItemSortColumn.RequiredPlayerKey => (EditorItemRow row) => row.Item.requiredPlayerKey ?? string.Empty, 
				ItemSortColumn.BlockedPlayerKey => (EditorItemRow row) => row.Item.notRequiredPlayerKey ?? string.Empty, 
				_ => (EditorItemRow row) => row.Item.prefab ?? string.Empty, 
			};
			if (1 == 0)
			{
			}
			Func<EditorItemRow, object> keySelector = func;
			List<EditorItemRow> list = (selectedOnly ? itemDocument.Rows.Where((EditorItemRow row) => row.Selected).ToList() : itemDocument.Rows.ToList());
			if (list.Count < 2)
			{
				return;
			}
			List<EditorItemRow> list2 = (ascending ? list.OrderBy(keySelector, ItemSortValueComparer.Instance) : list.OrderByDescending(keySelector, ItemSortValueComparer.Instance)).ToList();
			if (selectedOnly)
			{
				int num = 0;
				for (int num2 = 0; num2 < itemDocument.Rows.Count; num2++)
				{
					if (itemDocument.Rows[num2].Selected)
					{
						itemDocument.Rows[num2] = list2[num++];
					}
				}
			}
			else
			{
				itemDocument.Rows.Clear();
				itemDocument.Rows.AddRange(list2);
				itemPage = 0;
			}
			itemDocument.Dirty = true;
			itemScroll = Vector2.zero;
		}

		private void EnsureVisibleItemColumns()
		{
			string text = TradersExtended.configEditorVisibleItemColumns?.Value ?? "Prefab,Name,Stack,Price,Quality,Currency,RequiredGlobalKey,BlockedGlobalKey,RequiredPlayerKey,BlockedPlayerKey";
			if (string.Equals(text, visibleItemColumnsSource, StringComparison.Ordinal))
			{
				return;
			}
			visibleItemColumns.Clear();
			string[] array = (text ?? string.Empty).Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text2 in array)
			{
				if (TryParseItemColumnToken(text2.Trim(), out var column))
				{
					visibleItemColumns.Add(column);
				}
			}
			visibleItemColumnsSource = text ?? string.Empty;
		}

		private bool IsItemColumnVisible(ItemSortColumn column)
		{
			EnsureVisibleItemColumns();
			return visibleItemColumns.Contains(column);
		}

		private void SetItemColumnVisible(ItemSortColumn column, bool visible)
		{
			EnsureVisibleItemColumns();
			if (visible)
			{
				visibleItemColumns.Add(column);
			}
			else
			{
				visibleItemColumns.Remove(column);
			}
			string value = (visibleItemColumnsSource = string.Join(",", ItemColumnOrder.Where(visibleItemColumns.Contains).Select(GetItemColumnToken)));
			if (TradersExtended.configEditorVisibleItemColumns != null)
			{
				TradersExtended.configEditorVisibleItemColumns.Value = value;
			}
		}

		private static bool TryParseItemColumnToken(string token, out ItemSortColumn column)
		{
			switch (token?.Replace(" ", string.Empty).Replace("_", string.Empty).ToLowerInvariant())
			{
			case "prefab":
				column = ItemSortColumn.Prefab;
				return true;
			case "name":
			case "localizedname":
				column = ItemSortColumn.LocalizedName;
				return true;
			case "stack":
				column = ItemSortColumn.Stack;
				return true;
			case "price":
				column = ItemSortColumn.Price;
				return true;
			case "quality":
				column = ItemSortColumn.Quality;
				return true;
			case "currency":
				column = ItemSortColumn.Currency;
				return true;
			case "requiredglobalkey":
				column = ItemSortColumn.RequiredGlobalKey;
				return true;
			case "blockedglobalkey":
				column = ItemSortColumn.BlockedGlobalKey;
				return true;
			case "requiredplayerkey":
				column = ItemSortColumn.RequiredPlayerKey;
				return true;
			case "blockedplayerkey":
				column = ItemSortColumn.BlockedPlayerKey;
				return true;
			default:
				column = ItemSortColumn.Prefab;
				return false;
			}
		}

		private static string GetItemColumnToken(ItemSortColumn column)
		{
			if (1 == 0)
			{
			}
			string result = column switch
			{
				ItemSortColumn.LocalizedName => "Name", 
				ItemSortColumn.RequiredGlobalKey => "RequiredGlobalKey", 
				ItemSortColumn.BlockedGlobalKey => "BlockedGlobalKey", 
				ItemSortColumn.RequiredPlayerKey => "RequiredPlayerKey", 
				ItemSortColumn.BlockedPlayerKey => "BlockedPlayerKey", 
				_ => column.ToString(), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private string GetItemRowValidation(EditorItemRow row)
		{
			return BuildItemRowValidation(row).Combined;
		}

		private ItemRowValidation BuildItemRowValidation(EditorItemRow row)
		{
			ItemRowValidation itemRowValidation = new ItemRowValidation();
			string text = row.Item.prefab ?? string.Empty;
			string text2 = text.Trim();
			if (string.IsNullOrEmpty(text2))
			{
				itemRowValidation.Prefab = "Item prefab is required.";
			}
			else if (!string.Equals(text, text2, StringComparison.Ordinal))
			{
				itemRowValidation.Prefab = "Item prefab must not contain leading or trailing whitespace.";
			}
			else if (!itemOptionsByPrefab.ContainsKey(text2))
			{
				itemRowValidation.Prefab = "Item prefab '" + text2 + "' was not found in ObjectDB.";
			}
			if (!int.TryParse(row.StackText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				itemRowValidation.Stack = "Stack must be a valid integer.";
			}
			if (!int.TryParse(row.PriceText, NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
			{
				itemRowValidation.Price = "Price must be a valid integer.";
			}
			if (!int.TryParse(row.QualityText, NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
			{
				itemRowValidation.Quality = "Quality must be a valid integer.";
			}
			string text3 = row.Item.currency ?? string.Empty;
			string text4 = text3.Trim();
			if (!string.Equals(text3, text4, StringComparison.Ordinal))
			{
				itemRowValidation.Currency = "Currency prefab must not contain leading or trailing whitespace.";
			}
			else if (!string.IsNullOrEmpty(text4) && !itemOptionsByPrefab.ContainsKey(text4))
			{
				itemRowValidation.Currency = "Currency prefab '" + text4 + "' was not found in ObjectDB.";
			}
			itemRowValidation.RequiredGlobalKey = GetKeyValidation(row.Item.requiredGlobalKey, KeyPickerKind.Global, "Required global key");
			itemRowValidation.BlockedGlobalKey = GetKeyValidation(row.Item.notRequiredGlobalKey, KeyPickerKind.Global, "Blocked global key");
			itemRowValidation.RequiredPlayerKey = GetKeyValidation(row.Item.requiredPlayerKey, KeyPickerKind.Player, "Required player key");
			itemRowValidation.BlockedPlayerKey = GetKeyValidation(row.Item.notRequiredPlayerKey, KeyPickerKind.Player, "Blocked player key");
			string intersectionValidation = GetIntersectionValidation(row.Item.requiredGlobalKey, row.Item.notRequiredGlobalKey, "global");
			if (!string.IsNullOrEmpty(intersectionValidation))
			{
				itemRowValidation.RequiredGlobalKey = AppendValidation(itemRowValidation.RequiredGlobalKey, intersectionValidation);
				itemRowValidation.BlockedGlobalKey = AppendValidation(itemRowValidation.BlockedGlobalKey, intersectionValidation);
			}
			string intersectionValidation2 = GetIntersectionValidation(row.Item.requiredPlayerKey, row.Item.notRequiredPlayerKey, "player");
			if (!string.IsNullOrEmpty(intersectionValidation2))
			{
				itemRowValidation.RequiredPlayerKey = AppendValidation(itemRowValidation.RequiredPlayerKey, intersectionValidation2);
				itemRowValidation.BlockedPlayerKey = AppendValidation(itemRowValidation.BlockedPlayerKey, intersectionValidation2);
			}
			return itemRowValidation;
		}

		private string GetKeyValidation(string value, KeyPickerKind kind, string fieldName)
		{
			HashSet<string> hashSet = new HashSet<string>(GetKeyOptions(kind), StringComparer.OrdinalIgnoreCase);
			List<string> list = new List<string>();
			foreach (string item in SplitKeyValues(value))
			{
				if (!hashSet.Contains(item))
				{
					list.Add(fieldName + " '" + item + "' is not present in the configured " + ((kind == KeyPickerKind.Global) ? "global" : "player") + " key list.");
				}
			}
			return string.Join(" ", list);
		}

		private static string GetIntersectionValidation(string required, string blocked, string type)
		{
			HashSet<string> hashSet = new HashSet<string>(SplitKeyValues(required), StringComparer.OrdinalIgnoreCase);
			hashSet.IntersectWith(SplitKeyValues(blocked));
			return (hashSet.Count == 0) ? string.Empty : ("The same " + type + " key cannot be both required and blocked: " + string.Join(", ", hashSet.OrderBy<string, string>((string value) => value, StringComparer.OrdinalIgnoreCase)) + ".");
		}

		private static string AppendValidation(string current, string addition)
		{
			if (string.IsNullOrEmpty(current))
			{
				return addition ?? string.Empty;
			}
			if (string.IsNullOrEmpty(addition))
			{
				return current;
			}
			return current + " " + addition;
		}

		private bool ValidateItemRows(out string error)
		{
			error = string.Empty;
			EnsureItemOptions();
			for (int i = 0; i < itemDocument.Rows.Count; i++)
			{
				EditorItemRow editorItemRow = itemDocument.Rows[i];
				editorItemRow.ValidationError = GetItemRowValidation(editorItemRow);
				if (!string.IsNullOrWhiteSpace(editorItemRow.ValidationError))
				{
					error = $"Row {i + 1}: {editorItemRow.ValidationError}";
					return false;
				}
			}
			return true;
		}

		private static IEnumerable<string> SplitKeyValues(string value)
		{
			return (from item in (value ?? string.Empty).Split(new char[4] { ',', ';', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
				select item.Trim() into item
				where !string.IsNullOrWhiteSpace(item)
				select item).Distinct<string>(StringComparer.OrdinalIgnoreCase);
		}

		private void Header(string text, float width)
		{
			GUILayout.Label(text, headerStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(width) });
		}

		private bool FileMatchesSearch(EditorFileInfo file)
		{
			if (string.IsNullOrWhiteSpace(fileSearch))
			{
				return true;
			}
			string search = fileSearch.Trim();
			return Contains(file.Name, search) || Contains(GetFileListDisplayName(file), search) || Contains(file.Trader, search) || Contains(GetTraderDisplayName(file.Trader), search);
		}

		private bool ItemMatchesSearch(EditorItemRow row)
		{
			if (string.IsNullOrWhiteSpace(itemSearch))
			{
				return true;
			}
			string search = itemSearch.Trim();
			TradersExtended.TradeableItem item = row.Item;
			return Contains(item.prefab, search) || Contains(GetItemDisplayName(item.prefab), search) || Contains(item.currency, search) || Contains(item.requiredGlobalKey, search) || Contains(item.notRequiredGlobalKey, search) || Contains(item.requiredPlayerKey, search) || Contains(item.notRequiredPlayerKey, search);
		}

		private bool ItemOptionMatchesSearch(ItemOption option)
		{
			if (string.IsNullOrWhiteSpace(itemPickerSearch))
			{
				return true;
			}
			return Contains(option.Prefab, itemPickerSearch) || Contains(option.LocalizedName, itemPickerSearch);
		}

		private bool TraderOptionMatchesSearch(TraderOption option)
		{
			if (string.IsNullOrWhiteSpace(itemPickerSearch))
			{
				return true;
			}
			return Contains(option.Prefab, itemPickerSearch) || Contains(option.DisplayName, itemPickerSearch);
		}

		private bool GlobalKeyMatchesSearch(string key)
		{
			return string.IsNullOrWhiteSpace(globalKeySearch) || Contains(key, globalKeySearch);
		}

		private static bool Contains(string value, string search)
		{
			return !string.IsNullOrEmpty(value) && value.IndexOf(search ?? string.Empty, StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private void BuildItemOptions()
		{
			//IL_022c: 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_0241: Invalid comparison between Unknown and I4
			itemOptions.Clear();
			itemOptionsByPrefab.Clear();
			itemOptionsBuilt = false;
			itemPrefabColumnWidthDirty = true;
			if (ObjectDB.instance?.m_items == null)
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			Humanoid[] array = Resources.FindObjectsOfTypeAll<Humanoid>();
			BaseAI val2 = default(BaseAI);
			ItemDrop val4 = default(ItemDrop);
			foreach (Humanoid val in array)
			{
				if ((Object)(object)val == (Object)null || !((Component)val).TryGetComponent<BaseAI>(ref val2) || val.m_defaultItems == null)
				{
					continue;
				}
				GameObject[] defaultItems = val.m_defaultItems;
				foreach (GameObject val3 in defaultItems)
				{
					if ((Object)(object)val3 != (Object)null && val3.TryGetComponent<ItemDrop>(ref val4))
					{
						hashSet.Add(((Object)val3).name);
					}
				}
			}
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			ItemDrop val5 = default(ItemDrop);
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				try
				{
					if ((Object)(object)item == (Object)null || string.IsNullOrWhiteSpace(((Object)item).name) || !hashSet2.Add(((Object)item).name) || !item.TryGetComponent<ItemDrop>(ref val5))
					{
						continue;
					}
					ItemData itemData = val5.m_itemData;
					if (itemData?.m_shared != null)
					{
						Sprite safeItemIcon = GetSafeItemIcon(itemData);
						string text = (string.IsNullOrWhiteSpace(itemData.m_shared.m_name) ? ((Object)item).name : itemData.m_shared.m_name);
						string text2 = ((Localization.instance != null) ? Localization.instance.Localize(text) : text);
						if (string.IsNullOrWhiteSpace(text2) || text2.StartsWith("$", StringComparison.Ordinal))
						{
							text2 = string.Empty;
						}
						bool flag = !(itemData.m_shared.m_name ?? string.Empty).StartsWith("$", StringComparison.Ordinal) || itemData.m_shared.m_description == null || (int)itemData.m_shared.m_itemType == 0 || (int)itemData.m_shared.m_itemType == 10;
						bool visibleByDefault = (Object)(object)safeItemIcon != (Object)null && (Object)(object)safeItemIcon.texture != (Object)null && !hashSet.Contains(((Object)item).name) && !flag;
						ItemOption itemOption = new ItemOption(((Object)item).name, text2, safeItemIcon, visibleByDefault);
						itemOptions.Add(itemOption);
						itemOptionsByPrefab[((Object)item).name] = itemOption;
					}
				}
				catch (Exception ex)
				{
					TradersExtended.LogWarning("Configuration editor skipped item prefab '" + (((item != null) ? ((Object)item).name : null) ?? "<null>") + "': " + ex.Message);
				}
			}
			itemOptions.Sort(delegate(ItemOption left, ItemOption right)
			{
				int num = string.Compare(left.LocalizedName, right.LocalizedName, StringComparison.CurrentCultureIgnoreCase);
				return (num != 0) ? num : string.Compare(left.Prefab, right.Prefab, StringComparison.OrdinalIgnoreCase);
			});
			itemOptionsBuilt = true;
		}

		private void EnsureItemOptions()
		{
			if (!itemOptionsBuilt)
			{
				BuildItemOptions();
			}
		}

		private static Sprite GetSafeItemIcon(ItemData itemData)
		{
			Sprite[] array = itemData?.m_shared?.m_icons;
			if (array == null || array.Length == 0)
			{
				return null;
			}
			int variant = itemData.m_variant;
			if (variant >= 0 && variant < array.Length)
			{
				return array[variant];
			}
			return array[0];
		}

		private string ValidateItemPrefab(object value)
		{
			EnsureItemOptions();
			string text = Convert.ToString(value, CultureInfo.InvariantCulture) ?? string.Empty;
			string text2 = text.Trim();
			if (string.IsNullOrEmpty(text2))
			{
				return "Item prefab is required.";
			}
			if (!string.Equals(text, text2, StringComparison.Ordinal))
			{
				return "Item prefab must not contain leading or trailing whitespace.";
			}
			return itemOptionsByPrefab.ContainsKey(text2) ? string.Empty : ("Item prefab '" + text2 + "' was not found in ObjectDB.");
		}

		private string GetItemDisplayName(string prefab)
		{
			if (string.IsNullOrWhiteSpace(prefab))
			{
				return string.Empty;
			}
			ItemOption value;
			return itemOptionsByPrefab.TryGetValue(prefab, out value) ? value.LocalizedName : string.Empty;
		}

		private string GetTraderDisplayName(string trader)
		{
			if (string.IsNullOrWhiteSpace(trader))
			{
				return string.Empty;
			}
			if (string.Equals(trader, "common", StringComparison.OrdinalIgnoreCase))
			{
				return "Common";
			}
			if (traderDisplayNames.TryGetValue(trader, out var value))
			{
				return value;
			}
			string normalized = TradersExtended.TraderName(trader);
			Trader val = ((IEnumerable<Trader>)Resources.FindObjectsOfTypeAll<Trader>()).FirstOrDefault((Func<Trader, bool>)((Trader candidate) => (Object)(object)candidate != (Object)null && string.Equals(TradersExtended.TraderName(Utils.GetPrefabName(((Component)candidate).gameObject)), normalized, StringComparison.OrdinalIgnoreCase)));
			string text = (((Object)(object)val != (Object)null && Localization.instance != null) ? Localization.instance.Localize(val.m_name) : trader);
			if (string.IsNullOrWhiteSpace(text) || text.StartsWith("$", StringComparison.Ordinal))
			{
				text = trader;
			}
			traderDisplayNames[trader] = text;
			return text;
		}

		private List<TraderOption> GetTraderOptions()
		{
			Dictionary<string, TraderOption> dictionary = new Dictionary<string, TraderOption>(StringComparer.OrdinalIgnoreCase);
			Trader[] array = Resources.FindObjectsOfTypeAll<Trader>();
			foreach (Trader val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string prefabName = Utils.GetPrefabName(((Component)val).gameObject);
					if (!string.IsNullOrWhiteSpace(prefabName))
					{
						dictionary[prefabName] = new TraderOption(prefabName, GetTraderDisplayName(prefabName));
					}
				}
			}
			foreach (string knownTraderName in TraderConfigManager.GetKnownTraderNames())
			{
				if (!dictionary.ContainsKey(knownTraderName))
				{
					dictionary[knownTraderName] = new TraderOption(knownTraderName, GetTraderDisplayName(knownTraderName));
				}
			}
			return dictionary.Values.OrderBy<TraderOption, string>((TraderOption value) => value.DisplayName, StringComparer.CurrentCultureIgnoreCase).ToList();
		}

		private HashSet<string> GetActiveKeys(KeyPickerKind kind)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (kind == KeyPickerKind.Player)
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					foreach (string uniqueKey in Player.m_localPlayer.GetUniqueKeys())
					{
						if (!string.IsNullOrWhiteSpace(uniqueKey))
						{
							hashSet.Add(uniqueKey);
						}
					}
				}
				return hashSet;
			}
			if ((Object)(object)ZoneSystem.instance == (Object)null)
			{
				return hashSet;
			}
			string text = default(string);
			GlobalKeys val = default(GlobalKeys);
			foreach (string globalKey in ZoneSystem.instance.GetGlobalKeys())
			{
				hashSet.Add(ZoneSystem.GetKeyValue(globalKey, ref text, ref val));
			}
			return hashSet;
		}

		private static IEnumerable<string> GetDefaultKeyOptions(KeyPickerKind kind)
		{
			string value = ((kind == KeyPickerKind.Global) ? "defeated_bonemass,defeated_gdking,defeated_goblinking,defeated_dragon,defeated_eikthyr,defeated_queen,defeated_fader,defeated_serpent,KilledTroll,killed_surtling,KilledBat,Hildir1,Hildir2,Hildir3" : "GP_Eikthyr,GP_TheElder,GP_Bonemass,GP_Moder,GP_Yagluth,GP_Queen,GP_Fader");
			return SplitKeyValues(value);
		}

		private List<string> GetKeyOptions(KeyPickerKind kind)
		{
			string value = ((kind != KeyPickerKind.Global) ? TradersExtended.configEditorPlayerKeys?.Value : TradersExtended.configEditorGlobalKeys?.Value);
			return SplitKeyValues(value).ToList();
		}

		private void SetKeyOptions(KeyPickerKind kind, IEnumerable<string> values)
		{
			string value = string.Join(",", (from key in values ?? Enumerable.Empty<string>()
				select key?.Trim() into key
				where !string.IsNullOrWhiteSpace(key)
				select key).Distinct<string>(StringComparer.OrdinalIgnoreCase));
			if (kind == KeyPickerKind.Global)
			{
				if (TradersExtended.configEditorGlobalKeys != null)
				{
					TradersExtended.configEditorGlobalKeys.Value = value;
				}
			}
			else if (TradersExtended.configEditorPlayerKeys != null)
			{
				TradersExtended.configEditorPlayerKeys.Value = value;
			}
		}

		private string BuildNewFileName()
		{
			string text = (newFileTrader ?? string.Empty).Trim();
			string text2 = newFileExtension;
			if (newFileKind == EditorConfigKind.TraderSettings)
			{
				return text + ".config." + text2;
			}
			string text3 = newFileListType.ToString().ToLowerInvariant();
			string text4 = (string.IsNullOrWhiteSpace(newFileIdentifier) ? string.Empty : ("." + newFileIdentifier.Trim().Trim(new char[1] { '.' })));
			return text + "." + text3 + text4 + "." + text2;
		}

		private string ValidateNewFile(string fileName)
		{
			if (!ConfigEditorTransport.CanEditTarget)
			{
				return "Administrator access is required to create files on this server.";
			}
			if (string.IsNullOrWhiteSpace(newFileTrader))
			{
				return "Trader prefab is required. Use common for shared item lists.";
			}
			if ((newFileTrader ?? string.Empty).IndexOfAny(Path.GetInvalidFileNameChars()) >= 0 || newFileTrader.Contains("/") || newFileTrader.Contains("\\"))
			{
				return "Trader prefab contains invalid file-name characters.";
			}
			if ((newFileIdentifier ?? string.Empty).IndexOfAny(Path.GetInvalidFileNameChars()) >= 0 || newFileIdentifier.Contains("/") || newFileIdentifier.Contains("\\"))
			{
				return "Identifier contains invalid file-name characters.";
			}
			if (files.Any((EditorFileInfo file) => string.Equals(file.Name, fileName, StringComparison.OrdinalIgnoreCase)))
			{
				return "A file with this name already exists.";
			}
			if (newFileKind == EditorConfigKind.TraderSettings && files.Any((EditorFileInfo file) => file.Kind == EditorConfigKind.TraderSettings && string.Equals(TradersExtended.TraderName(file.Trader), TradersExtended.TraderName(newFileTrader), StringComparison.OrdinalIgnoreCase)))
			{
				return "A personal configuration for this trader already exists. Only one personal file per trader is used.";
			}
			if (newFileKind == EditorConfigKind.ItemList && !TradersExtended.TryParseConfigFileName(fileName, out var trader, out var _))
			{
				return "The generated item configuration file name is invalid.";
			}
			if (newFileKind == EditorConfigKind.TraderSettings && !TradersExtended.TryParseTraderConfigFileName(fileName, out trader))
			{
				return "The generated trader configuration file name is invalid.";
			}
			return string.Empty;
		}

		private void DrawFormatToggle(string format)
		{
			bool flag = string.Equals(newFileExtension, format, StringComparison.OrdinalIgnoreCase);
			if (GUILayout.Button(format.ToUpperInvariant(), flag ? theme.AccentButtonStyle : smallButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) }))
			{
				newFileExtension = format;
			}
		}

		private bool IsDirty()
		{
			ItemConfigDocument itemConfigDocument = itemDocument;
			return (itemConfigDocument != null && itemConfigDocument.Dirty) || (traderDocument?.Dirty ?? false);
		}

		private void BeginRequest(string message)
		{
			requestInProgress = true;
			requestStartedAt = Time.realtimeSinceStartup;
			SetStatus(message, error: false);
		}

		private void SetStatus(string message, bool error)
		{
			statusText = message ?? string.Empty;
			statusError = error;
		}

		private static string FormatValue(TraderSettingType type, object value)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (value == null)
			{
				return string.Empty;
			}
			if (1 == 0)
			{
			}
			string result = type switch
			{
				TraderSettingType.Boolean => ((bool)value) ? "true" : "false", 
				TraderSettingType.Float => Convert.ToSingle(value, CultureInfo.InvariantCulture).ToString("0.###", CultureInfo.InvariantCulture), 
				TraderSettingType.Vector2 => (value is Vector2 val) ? ("{ x: " + val.x.ToString("0.###", CultureInfo.InvariantCulture) + ", y: " + val.y.ToString("0.###", CultureInfo.InvariantCulture) + " }") : value.ToString(), 
				_ => Convert.ToString(value, CultureInfo.InvariantCulture), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private void LoadLayout()
		{
			//IL_002a: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_009b: 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_00a8: 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_0102: 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_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			if (!layoutLoaded)
			{
				Vector2 val = (Vector2)(((??)TradersExtended.configEditorWindowSize?.Value) ?? new Vector2(1500f, 850f));
				val.x = Mathf.Clamp(val.x, 1000f, Mathf.Max(1000f, scale.LogicalWidth));
				val.y = Mathf.Clamp(val.y, 600f, Mathf.Max(600f, scale.LogicalHeight));
				Vector2 val2 = (Vector2)(((??)TradersExtended.configEditorWindowPosition?.Value) ?? new Vector2(-1f, -1f));
				if (val2.x < 0f || val2.y < 0f)
				{
					((Vector2)(ref val2))..ctor((scale.LogicalWidth - val.x) * 0.5f, (scale.LogicalHeight - val.y) * 0.5f);
				}
				windowRect = ClampRect(new Rect(val2, val));
				layoutLoaded = true;
			}
		}

		private void SaveLayout()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (layoutLoaded)
			{
				if (TradersExtended.configEditorWindowPosition != null)
				{
					TradersExtended.configEditorWindowPosition.Value = ((Rect)(ref windowRect)).position;
				}
				if (TradersExtended.configEditorWindowSize != null)
				{
					TradersExtended.configEditorWindowSize.Value = ((Rect)(ref windowRect)).size;
				}
				layoutDirty = false;
			}
		}

		private void ClampWindowToScreen()
		{
			//IL_0004: 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)
			windowRect = ClampRect(windowRect);
		}

		private Rect ClampRect(Rect rect)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(1000f, scale.LogicalWidth);
			float num2 = Mathf.Max(600f, scale.LogicalHeight);
			((Rect)(ref rect)).width = Mathf.Clamp(((Rect)(ref rect)).width, 1000f, num);
			((Rect)(ref rect)).height = Mathf.Clamp(((Rect)(ref rect)).height, 600f, num2);
			((Rect)(ref rect)).x = Mathf.Clamp(((Rect)(ref rect)).x, 0f, Mathf.Max(0f, scale.LogicalWidth - 40f));
			((Rect)(ref rect)).y = Mathf.Clamp(((Rect)(ref rect)).y, 0f, Mathf.Max(0f, scale.LogicalHeight - 22f));
			return rect;
		}

		private void HandleResizeInput()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0017: 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_003a: 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_004d: 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_008a: 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_009d: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: 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_016a: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Invalid comparison between Unknown and I4
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Invalid comparison between Unknown and I4
			Event current = Event.current;
			Vector2 mousePosition = current.mousePosition;
			Rect resizeHandleHitRect = GetResizeHandleHitRect();
			bool flag = ((Rect)(ref resizeHandleHitRect)).Contains(mousePosition);
			bool flag2 = !flag && mousePosition.x >= ((Rect)(ref windowRect)).width - 4f && mousePosition.x <= ((Rect)(ref windowRect)).width && mousePosition.y >= 22f && mousePosition.y < ((Rect)(ref resizeHandleHitRect)).yMin;
			bool flag3 = !flag && mousePosition.y >= ((Rect)(ref windowRect)).height - 4f && mousePosition.y <= ((Rect)(ref windowRect)).height && mousePosition.x >= 0f && mousePosition.x < ((Rect)(ref resizeHandleHitRect)).xMin;
			if ((int)current.type == 0 && current.button == 0 && (flag || flag2 || flag3))
			{
				resizing = true;
				resizeStartMouse = scale.GetLogicalMousePosition();
				resizeStartRect = windowRect;
				resizeWidth = flag || flag2;
				resizeHeight = flag || flag3;
				current.Use();
			}
			if (!resizing)
			{
				return;
			}
			if (UnityInput.Current.GetKey((KeyCode)323))
			{
				Vector2 val = scale.GetLogicalMousePosition() - resizeStartMouse;
				Rect rect = resizeStartRect;
				if (resizeWidth)
				{
					((Rect)(ref rect)).width = ((Rect)(ref resizeStartRect)).width + val.x;
				}
				if (resizeHeight)
				{
					((Rect)(ref rect)).height = ((Rect)(ref resizeStartRect)).height + val.y;
				}
				windowRect = ClampRect(rect);
				MarkLayoutDirty();
				if ((int)current.type == 3 || (int)current.type == 0)
				{
					current.Use();
				}
			}
			if (UnityInput.Current.GetKeyUp((KeyCode)323))
			{
				ClearResizeState();
				MarkLayoutDirty();
			}
		}

		private static bool RectChanged(Rect left, Rect right)
		{
			return Mathf.Abs(((Rect)(ref left)).x - ((Rect)(ref right)).x) > 0.01f || Mathf.Abs(((Rect)(ref left)).y - ((Rect)(ref right)).y) > 0.01f || Mathf.Abs(((Rect)(ref left)).width - ((Rect)(ref right)).width) > 0.01f || Mathf.Abs(((Rect)(ref left)).height - ((Rect)(ref right)).height) > 0.01f;
		}

		private void MarkLayoutDirty()
		{
			layoutDirty = true;
			saveLayoutAfterRealtime = Time.realtimeSinceStartup + 0.5f;
		}

		private void DrawWindowBorder()
		{
			DrawModalBorder(((Rect)(ref windowRect)).width, ((Rect)(ref windowRect)).height);
		}

		private void DrawModalBorder(float width, float height)
		{
			//IL_0047: 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_0081: 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)
			Texture2D borderTexture = theme.BorderTexture;
			if (!((Object)(object)borderTexture == (Object)null))
			{
				width = Mathf.Max(1f, width);
				height = Mathf.Max(1f, height);
				GUI.DrawTexture(new Rect(0f, 0f, width, 1f), (Texture)(object)borderTexture);
				GUI.DrawTexture(new Rect(0f, height - 1f, width, 1f), (Texture)(object)borderTexture);
				GUI.DrawTexture(new Rect(0f, 0f, 1f, height), (Texture)(object)borderTexture);
				GUI.DrawTexture(new Rect(width - 1f, 0f, 1f, height), (Texture)(object)borderTexture);
			}
		}

		private void DrawResizeHandle()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_006c: 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: Invalid comparison between Unknown and I4
			//IL_001f: 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_00ab: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			Rect resizeHandleHitRect = GetResizeHandleHitRect();
			if ((Object)(object)theme.WindowTexture != (Object)null)
			{
				GUI.DrawTexture(resizeHandleHitRect, (Texture)(object)theme.WindowTexture);
			}
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref resizeHandleHitRect)).xMax - 8f, ((Rect)(ref resizeHandleHitRect)).yMax - 8f, 8f, 8f);
			GUIContent val2 = new GUIContent(string.Empty, "Drag to resize");
			GUI.Label(val, val2, GUIStyle.none);
			if ((int)Event.current.type == 7)
			{
				bool flag = ((Rect)(ref val)).Contains(Event.current.mousePosition);
				theme.ResizeHandleStyle.Draw(val, val2, flag, resizing, false, false);
			}
			Texture2D borderTexture = theme.BorderTexture;
			if (!((Object)(object)borderTexture == (Object)null))
			{
				float num = ((Rect)(ref val)).xMax - 1f;
				float num2 = ((Rect)(ref val)).yMax - 1f;
				GUI.DrawTexture(new Rect(num - 3f, num2, 3f, 1f), (Texture)(object)borderTexture);
				GUI.DrawTexture(new Rect(num - 1f, num2 - 2f, 1f, 2f), (Texture)(object)borderTexture);
			}
		}

		private Rect GetResizeHandleHitRect()
		{
			//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_0055: Unknown result type (might be due to invalid IL or missing references)
			return new Rect(Mathf.Max(0f, ((Rect)(ref windowRect)).width - 12f - 2f), Mathf.Max(0f, ((Rect)(ref windowRect)).height - 12f - 2f), 12f, 12f);
		}

		private void ClearResizeState()
		{
			resizing = false;
			resizeWidth = false;
			resizeHeight = false;
		}

		private void CenterModal(ref Rect rect)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(320f, scale.LogicalWidth - 20f);
			float num2 = Mathf.Max(240f, scale.LogicalHeight - 20f);
			((Rect)(ref rect)).width = Mathf.Min(((Rect)(ref rect)).width, num);
			((Rect)(ref rect)).height = Mathf.Min(((Rect)(ref rect)).height, num2);
			if (((Rect)(ref rect)).x <= 0f && ((Rect)(ref rect)).y <= 0f)
			{
				((Rect)(ref rect)).position = new Vector2((scale.LogicalWidth - ((Rect)(ref rect)).width) * 0.5f, (scale.LogicalHeight - ((Rect)(ref rect)).height) * 0.5f);
			}
			((Rect)(ref rect)).x = Mathf.Clamp(((Rect)(ref rect)).x, 0f, Mathf.Max(0f, scale.LogicalWidth - ((Rect)(ref rect)).width));
			((Rect)(ref rect)).y = Mathf.Clamp(((Rect)(ref rect)).y, 0f, Mathf.Max(0f, scale.LogicalHeight - ((Rect)(ref rect)).height));
		}

		private void EnsureStyles()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//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_008e: Expected O, but got Unknown
			//IL_0094: Expected O, but got Unknown
			//IL_00b6: 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_00c3: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_00db: 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_00ea: Expected O, but got Unknown
			//IL_00f0: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_0136: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			//IL_0176: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_018b: 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_019a: Expected O, but got Unknown
			//IL_01a0: Expected O, but got Unknown
			//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_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_0210: 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_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Expected O, but got Unknown
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Expected O, but got Unknown
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Expected O, but got Unknown
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Expected O, but got Unknown
			//IL_02d8: Expected O, but got Unknown
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Expected O, but got Unknown
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Expected O, but got Unknown
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Expected O, but got Unknown
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Expected O, but got Unknown
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Expected O, but got Unknown
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f7: Expected O, but got Unknown
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Expected O, but got Unknown
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Expected O, but got Unknown
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a0: Expected O, but got Unknown
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Expected O, but got Unknown
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Expected O, but got Unknown
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Expected O, but got Unknown
			//IL_0514: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0528: Expected O, but got Unknown
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			//IL_052e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0538: Expected O, but got Unknown
			//IL_0539: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0548: Expected O, but got Unknown
			//IL_054e: Expected O, but got Unknown
			//IL_0559: Unknown result type (might be due to invalid IL or missing references)
			//IL_055e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Expected O, but got Unknown
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_058f: Unknown result type (might be due to invalid IL or missing references)
			//IL_059c: Expected O, but got Unknown
			//IL_05a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bb: Expected O, but got Unknown
			//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Expected O, but got Unknown
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d9: Expected O, but got Unknown
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f8: Expected O, but got Unknown
			//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0608: Expected O, but got Unknown
			//IL_0609: Unknown result type (might be due to invalid IL or missing references)
			//IL_0611: Unknown result type (might be due to invalid IL or missing references)
			//IL_0637: Expected O, but got Unknown
			theme.EnsureStyles();
			if (!stylesInitialized || !((Object)(object)styleSourceSkin == (Object)(object)GUI.skin))
			{
				stylesInitialized = true;
				styleSourceSkin = GUI.skin;
				itemPrefabColumnWidthDirty = true;
				windowStyle = new GUIStyle(GUI.skin.window);
				panelStyle = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(7, 7, 7, 7),
					margin = new RectOffset(3, 3, 3, 3)
				};
				SetStyleBackground(panelStyle, theme.WindowTexture);
				fileStyle = new GUIStyle(GUI.skin.button)
				{
					alignment = (TextAnchor)0,
					wordWrap = true,
					padding = new RectOffset(7, 7, 5, 5),
					margin = new RectOffset(1, 1, 1, 1)
				};
				selectedFileStyle = new GUIStyle(theme.AccentButtonStyle)
				{
					alignment = (TextAnchor)0,
					wordWrap = true,
					padding = new RectOffset(7, 7, 5, 5),
					margin = new RectOffset(1, 1, 1, 1)
				};
				headerStyle = new GUIStyle(GUI.skin.box)
				{
					fontStyle = (FontStyle)1,
					padding = new RectOffset(4, 4, 1, 1),
					alignment = (TextAnchor)3
				};
				toolbarStyle = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(4, 4, 2, 2),
					margin = new RectOffset(2, 2, 1, 1)
				};
				rowStyle = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(2, 2, 1, 1),
					margin = new RectOffset(1, 1, 1, 1),
					alignment = (TextAnchor)3
				};
				itemRowStyle = new GUIStyle(rowStyle);
				SetStyleBackground(itemRowStyle, theme.WindowTexture);
				mutedStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = Mathf.Max(9, (TradersExtended.configEditorFontSize?.Value ?? 13) - 1),
					wordWrap = true
				};
				mutedStyle.normal.textColor = new Color(0.7f, 0.73f, 0.76f);
				rightMutedStyle = new GUIStyle(mutedStyle)
				{
					alignment = (TextAnchor)5
				};
				centeredMutedStyle = new GUIStyle(mutedStyle)
				{
					alignment = (TextAnchor)4,
					wordWrap = false
				};
				centeredMessageStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					wordWrap = true,
					padding = new RectOffset(8, 8, 4, 4)
				};
				singleLineMutedStyle = new GUIStyle(mutedStyle)
				{
					alignment = (TextAnchor)3,
					wordWrap = false,
					clipping = (TextClipping)1
				};
				errorStyle = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(5, 5, 3, 3),
					wordWrap = true
				};
				errorStyle.normal.textColor = new Color(1f, 0.72f, 0.72f);
				itemPrefabTextFieldStyle = new GUIStyle(GUI.skin.textField)
				{
					alignment = (TextAnchor)3
				};
				invalidItemIconStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					fontStyle = (FontStyle)1,
					wordWrap = false
				};
				SetStyleTextColor(invalidItemIconStyle, new Color(1f, 0.22f, 0.18f, 1f));
				pickerPrefabStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					wordWrap = false,
					clipping = (TextClipping)1,
					fontStyle = (FontStyle)1
				};
				SetStyleTextColor(pickerPrefabStyle, new Color(0.94f, 0.94f, 0.94f, 1f));
				pickerNameStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					wordWrap = false,
					clipping = (TextClipping)1
				};
				SetStyleTextColor(pickerNameStyle, new Color(0.88f, 0.9f, 0.92f, 1f));
				keyNameStyle = new GUIStyle(pickerPrefabStyle)
				{
					fontStyle = (FontStyle)0
				};
				keySelectedNameStyle = new GUIStyle(keyNameStyle)
				{
					fontStyle = (FontStyle)1
				};
				selectedValueLabelStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					wordWrap = false
				};
				SetStyleTextColor(selectedValueLabelStyle, Color.white);
				selectedValueStyle = new GUIStyle(selectedValueLabelStyle)
				{
					fontStyle = (FontStyle)1
				};
				serverSourceStyle = new GUIStyle(pickerPrefabStyle)
				{
					fontStyle = (FontStyle)1
				};
				splitterStyle = new GUIStyle(theme.ResizeHandleStyle)
				{
					padding = new RectOffset(0, 0, 0, 0),
					margin = new RectOffset(2, 2, 3, 3),
					border = new RectOffset(0, 0, 0, 0)
				};
				titleStyle = new GUIStyle(GUI.skin.label)
				{
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)3
				};
				fileNameStyle = new GUIStyle(titleStyle)
				{
					wordWrap = true,
					clipping = (TextClipping)1,
					alignment = (TextAnchor)0
				};
				smallButtonStyle = new GUIStyle(GUI.skin.button)
				{
					padding = new RectOffset(5, 5, 2, 2),
					margin = new RectOffset(1, 1, 1, 1),
					alignment = (TextAnchor)4
				};
				inlineButtonStyle = new GUIStyle(GUI.skin.button)
				{
					padding = new RectOffset(0, 0, 0, 1),
					margin = new RectOffset(0, 0, 0, 0),
					alignment = (TextAnchor)4,
					fontSize = Mathf.Max(8, (TradersExtended.configEditorFontSize?.Value ?? 13) - 2)
				};
			}
		}

		private static void SetStyleBackground(GUIStyle style, Texture2D texture)
		{
			if (style != null)
			{
				style.normal.background = texture;
				style.hover.background = texture;
				style.active.background = texture;
				style.focused.background = texture;
				style.onNormal.background = texture;
				style.onHover.background = texture;
				style.onActive.background = texture;
				style.onFocused.background = texture;
			}
		}

		private static void SetStyleTextColor(GUIStyle style, Color color)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			if (style != null)
			{
				style.normal.textColor = color;
				style.hover.textColor = color;
				style.active.textColor = color;
				style.focused.textColor = color;
				style.onNormal.textColor = color;
				style.onHover.textColor = color;
				style.onActive.textColor = color;
				style.onFocused.textColor = color;
			}
		}
	}
	internal enum EditorConfigKind
	{
		ItemList,
		TraderSettings,
		Unsupported
	}
	[Serializable]
	internal sealed class EditorFileInfo
	{
		public string Name { get; set; }

		public EditorConfigKind Kind { get; set; }

		public string Trader { get; set; }

		public TradersExtended.ItemsListType ListType { get; set; }

		public long Length { get; set; }

		public long LastWriteUtcTicks { get; set; }
	}
	internal sealed class EditorItemRow
	{
		internal TradersExtended.TradeableItem Item;

		internal bool Selected;

		internal string StackText;

		internal string PriceText;

		internal string QualityText;

		internal string ValidationError;

		internal EditorItemRow(TradersExtended.TradeableItem item)
		{
			Item = item ?? new TradersExtended.TradeableItem();
			StackText = Item.stack.ToString(CultureInfo.InvariantCulture);
			PriceText = Item.price.ToString(CultureInfo.InvariantCulture);
			QualityText = Item.quality.ToString(CultureInfo.InvariantCulture);
		}
	}
	internal sealed class ItemConfigDocument
	{
		internal string FileName { get; }

		internal List<EditorItemRow> Rows { get; }

		internal bool Dirty { get; set; }

		internal ItemConfigDocument(string fileName, IEnumerable<TradersExtended.TradeableItem> items)
		{
			FileName = fileName;
			Rows = (items ?? Enumerable.Empty<TradersExtended.TradeableItem>()).Select((TradersExtended.TradeableItem item) => new EditorItemRow(item)).ToList();
		}

		internal bool Validate(out string error)
		{
			error = string.Empty;
			for (int i = 0; i < Rows.Count; i++)
			{
				EditorItemRow editorItemRow = Rows[i];
				if (!int.TryParse(editorItemRow.StackText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
				{
					error = $"Row {i + 1}: stack must be a valid integer.";
					return false;
				}
				if (!int.TryParse(editorItemRow.PriceText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
				{
					error = $"Row {i + 1}: price must be a valid integer.";
					return false;
				}
				if (!int.TryParse(editorItemRow.QualityText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3))
				{
					error = $"Row {i + 1}: quality must be a valid integer.";
					return false;
				}
				editorItemRow.Item.stack = result;
				editorItemRow.Item.price = result2;
				editorItemRow.Item.quality = result3;
			}
			return true;
		}

		internal List<TradersExtended.TradeableItem> GetItems()
		{
			return Rows.Select((EditorItemRow row) => row.Item).ToList();
		}
	}
	internal enum TraderSettingType
	{
		Boolean,
		Integer,
		Float,
		String,
		ItemPrefab,
		Vector2
	}
	internal sealed class TraderSettingDefinition
	{
		internal string Section { get; }

		internal string Name { get; }

		internal TraderSettingType Type { get; }

		internal Func<string, object> Fallback { get; }

		internal string Description { get; }

		internal TraderSettingDefinition(string section, string name, TraderSettingType type, Func<string, object> fallback, string description)
		{
			Section = section;
			Name = name;
			Type = type;
			Fallback = fallback;
			Description = description;
		}
	}
	internal sealed class TraderSettingState
	{
		internal TraderSettingDefinition Definition;

		internal bool HasOverride;

		internal object Value;

		internal string EditText;

		internal string ValidationError;

		internal string VectorXText;

		internal string VectorYText;

		internal object EffectiveValue(string trader)
		{
			return HasOverride ? Value : Definition.Fallback(trader);
		}
	}
	internal sealed class TraderConfigDocument
	{
		internal string FileName { get; }

		internal string Trader { get; }

		internal JObject Source { get; }

		internal List<TraderSettingState> Settings { get; }

		internal bool Dirty { get; set; }

		internal TraderConfigDocument(string fileName, string trader, JObject source)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			FileName = fileName;
			Trader = trader;
			Source = (JObject)(((object)source) ?? ((object)new JObject()));
			Settings = TraderConfigSchema.CreateStates(Trader, Source);
		}

		internal JObject BuildRoot()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			JObject val = (JObject)((JToken)Source).DeepClone();
			foreach (TraderSettingState state in Settings)
			{
				JProperty val2 = val.Properties().FirstOrDefault((Func<JProperty, bool>)((JProperty candidate) => string.Equals(candidate.Name, state.Definition.Section, StringComparison.OrdinalIgnoreCase)));
				JToken obj = ((val2 != null) ? val2.Value : null);
				JObject val3 = (JObject)(object)((obj is JObject) ? obj : null);
				if (state.HasOverride)
				{
					if (val3 == null)
					{
						val3 = new JObject();
						if (val2 != null)
						{
							val2.Value = (JToken)(object)val3;
						}
						else
						{
							val2 = new JProperty(state.Definition.Section, (object)val3);
							((JContainer)val).Add((object)val2);
						}
					}
					JProperty val4 = val3.Properties().FirstOrDefault((Func<JProperty, bool>)((JProperty candidate) => string.Equals(candidate.Name, state.Definition.Name, StringComparison.OrdinalIgnoreCase)));
					JToken val5 = TraderConfigSchema.ToToken(state.Definition.Type, state.Value);
					if (val4 != null)
					{
						val4.Value = val5;
					}
					else
					{
						val3.Add(state.Definition.Name, val5);
					}
				}
				else if (val3 != null)
				{
					JProperty val6 = val3.Properties().FirstOrDefault((Func<JProperty, bool>)((JProperty candidate) => string.Equals(candidate.Name, state.Definition.Name, StringComparison.OrdinalIgnoreCase)));
					if (val6 != null)
					{
						((JToken)val6).Remove();
					}
					if (!val3.Properties().Any() && val2 != null)
					{
						((JToken)val2).Remove();
					}
				}
			}
			return val;
		}
	}
	internal static class TraderConfigSchema
	{
		internal static readonly IReadOnlyList<TraderSettingDefinition> Definitions = new List<TraderSettingDefinition>
		{
			new TraderSettingDefinition("Item discovery", "Sell only discovered items", TraderSettingType.Boolean, (string _) => TradersExtended.checkForDiscovery.Value, "Prevent the trader from selling items that the player has not discovered."),
			new TraderSettingDefinition("Item discovery", "Undiscovered items list to sell", TraderSettingType.String, (string _) => TradersExtended.checkForDiscoveryIgnoreItems.Value, "Comma-separated item prefab names that bypass discovery checks."),
			new TraderSettingDefinition("Trader repair", "Weapons", TraderSettingType.Boolean, (string trader) => ContainsTrader(TradersExtended.tradersToRepairWeapons.Value, trader), "Allow this trader to repair weapons."),
			new TraderSettingDefinition("Trader repair", "Armor", TraderSettingType.Boolean, (string trader) => ContainsTrader(TradersExtended.tradersToRepairArmor.Value, trader), "Allow this trader to repair armor."),
			new TraderSettingDefinition("Trader repair", "Repair cost", TraderSettingType.Integer, (string _) => TradersExtended.traderRepairCost.Value, "Currency amount charged for one repair."),
			new TraderSettingDefinition("Trader repair", "Repair currency", TraderSettingType.ItemPrefab, (string _) => TradersExtended.traderRepairCurrency.Value, "Item prefab used to pay for repairs."),
			new TraderSettingDefinition("Trader coins", "Use currency", TraderSettingType.Boolean, (string _) => TradersExtended.traderUseCoins.Value, "Use a limited replenishing trader balance."),
			new TraderSettingDefinition("Trader coins", "Use flexible pricing", TraderSettingType.Boolean, (string _) => TradersExtended.traderUseFlexiblePricing.Value, "Adjust prices according to the current trader balance."),
			new TraderSettingDefinition("Trader pricing", "Amount of currency after replenishment minimum", TraderSettingType.Integer, (string _) => TradersExtended.traderCoinsMinimumAmount.Value, "Minimum trader balance after replenishment."),
			new TraderSettingDefinition("Trader pricing", "Amount of currency replenished daily", TraderSettingType.Integer, (string _) => TradersExtended.traderCoinsIncreaseAmount.Value, "Currency added during a daily balance update."),
			new TraderSettingDefinition("Trader pricing", "Amount of currency removed daily", TraderSettingType.Integer, (string _) => TradersExtended.traderCoinsDecreaseAmount.Value, "Currency removed during a daily balance update."),
			new TraderSettingDefinition("Trader pricing", "Amount of currency after replenishment maximum", TraderSettingType.Integer, (string _) => TradersExtended.traderCoinsMaximumAmount.Value, "Maximum trader balance after replenishment."),
			new TraderSettingDefinition("Trader pricing", "Trader discount", TraderSettingType.Float, (string _) => TradersExtended.traderDiscount.Value, "Multiplier used when the trader pays the player."),
			new TraderSettingDefinition("Trader pricing", "Trader markup", TraderSettingType.Float, (string _) => TradersExtended.traderMarkup.Value, "Multiplier used when the trader sells to the player."),
			new TraderSettingDefinition("Trader pricing", "Currency replenishment rate in days", TraderSettingType.Integer, (string _) => TradersExtended.traderCoinsReplenishmentRate.Value, "Number of world days between balance updates."),
			new TraderSettingDefinition("Trader pricing", "Send replenishment message in the morning", TraderSettingType.Boolean, (string _) => TradersExtended.traderCoinsSendReplenishmentMessage.Value, "Show a message when the trader balance is replenished."),
			new TraderSettingDefinition("Trader currency", "Override", TraderSettingType.ItemPrefab, (string trader) => TraderConfigManager.ResolveCurrencyForTrader(TradersExtended.traderCurrencyOverrides.Value, TradersExtended.TraderName(trader)), "Default currency item prefab for this trader."),
			new TraderSettingDefinition("Trader buyback", "Enable buyback for last item sold", TraderSettingType.Boolean, (string _) => TradersExtended.enableBuyBack.Value, "Allow buying back the last item sold to this trader."),
			new TraderSettingDefinition("Trader buyback", "Buyback lifetime in world seconds", TraderSettingType.Integer, (string _) => TradersExtended.buybackLifetime.Value, "World-time duration before the saved buyback expires. Zero disables expiration."),
			new TraderSettingDefinition("Misc", "Disable vanilla items", TraderSettingType.Boolean, (string _) => TradersExtended.disableVanillaItems.Value, "Hide the trader's vanilla item list."),
			new TraderSettingDefinition("Misc", "Disable other mods items", TraderSettingType.Boolean, (string _) => TradersExtended.disableOtherModsItems.Value, "Hide trader entries added by other mods."),
			new TraderSettingDefinition("Misc", "Add common valuable items to sell list", TraderSettingType.Boolean, (string _) => TradersExtended.addCommonValuableItemsToSellList.Value, "Automatically add valuable ObjectDB items to this trader's sell list."),
			new TraderSettingDefinition("Misc", "Fixed position for Store GUI", TraderSettingType.Vector2, (string _) => TradersExtended.fixedStoreGuiPosition.Value, "Fixed Store GUI position. Use zero coordinates to retain the normal position."),
			new TraderSettingDefinition("Misc", "Store GUI EpicLoot compatibility", TraderSettingType.Boolean, (string trader) => ContainsTrader(TradersExtended.epicLootShiftedTraders.Value, trader), "Shift the Store GUI for EpicLoot Adventure Mode compatibility.")
		};

		internal static List<TraderSettingState> CreateStates(string trader, JObject root)
		{
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: 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)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Invalid comparison between Unknown and I4
			List<TraderSettingState> list = new List<TraderSettingState>();
			foreach (TraderSettingDefinition definition in Definitions)
			{
				TraderSettingState traderSettingState = new TraderSettingState
				{
					Definition = definition,
					Value = definition.Fallback(trader)
				};
				JToken obj = ((root != null) ? root.GetValue(definition.Section, StringComparison.OrdinalIgnoreCase) : null);
				JObject val = (JObject)(object)((obj is JObject) ? obj : null);
				JToken val2 = ((val != null) ? val.GetValue(definition.Name, StringComparison.OrdinalIgnoreCase) : null);
				if (val2 != null && (int)val2.Type != 10)
				{
					traderSettingState.HasOverride = true;
					try
					{
						traderSettingState.Value = FromToken(definition.Type, val2);
					}
					catch (Exception ex)
					{
						traderSettingState.ValidationError = ex.Message;
						traderSettingState.Value = definition.Fallback(trader);
					}
				}
				traderSettingState.EditText = FormatEditText(definition.Type, traderSettingState.Value);
				if (definition.Type == TraderSettingType.Vector2)
				{
					Vector2 val3 = ((traderSettingState.Value is Vector2 val4) ? val4 : Vector2.zero);
					traderSettingState.VectorXText = val3.x.ToString("0.###", CultureInfo.InvariantCulture);
					traderSettingState.VectorYText = val3.y.ToString("0.###", CultureInfo.InvariantCulture);
				}
				list.Add(traderSettingState);
			}
			return list;
		}

		internal static object FromToken(TraderSettingType type, JToken token)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			object result = type switch
			{
				TraderSettingType.Boolean => Extensions.Value<bool>((IEnumerable<JToken>)token), 
				TraderSettingType.Integer => Extensions.Value<int>((IEnumerable<JToken>)token), 
				TraderSettingType.Float => Extensions.Value<float>((IEnumerable<JToken>)token), 
				TraderSettingType.String => TokenToString(token), 
				TraderSettingType.ItemPrefab => TokenToString(token), 
				TraderSettingType.Vector2 => ParseVector2(token), 
				_ => throw new ArgumentOutOfRangeException("type", type, null), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		internal static JToken ToToken(TraderSettingType type, object value)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (type == TraderSettingType.Vector2)
			{
				Vector2 val = ((value is Vector2 val2) ? val2 : Vector2.zero);
				return (JToken)new JObject
				{
					["x"] = JToken.op_Implicit(val.x),
					["y"] = JToken.op_Implicit(val.y)
				};
			}
			return (JToken)((value == null) ? ((object)JValue.CreateNull()) : ((object)JToken.FromObject(value)));
		}

		internal static string FormatEditText(TraderSettingType type, object value)
		{
			if (1 == 0)
			{
			}
			string result = type switch
			{
				TraderSettingType.Integer => Convert.ToInt32(value, CultureInfo.InvariantCulture).ToString(CultureInfo.InvariantCulture), 
				TraderSettingType.Float => Convert.ToSingle(value, CultureInfo.InvariantCulture).ToString("0.###", CultureInfo.InvariantCulture), 
				TraderSettingType.String => value?.ToString() ?? string.Empty, 
				TraderSettingType.ItemPrefab => value?.ToString() ?? string.Empty, 
				_ => string.Empty, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static string TokenToString(JToken token)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)token.Type == 8)
			{
				return Extensions.Value<string>((IEnumerable<JToken>)token) ?? string.Empty;
			}
			JArray val = (JArray)(object)((token is JArray) ? token : null);
			if (val != null)
			{
				return string.Join(",", ((IEnumerable<JToken>)val).Select((JToken item) => item.ToString((Formatting)0, Array.Empty<JsonConverter>())));
			}
			return token.ToString((Formatting)0, Array.Empty<JsonConverter>());
		}

		private static Vector2 ParseVector2(JToken token)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			JObject val = (JObject)(object)((token is JObject) ? token : null);
			if (val == null)
			{
				throw new FormatException("Expected an object with numeric x and y fields.");
			}
			JToken value = val.GetValue("x", StringComparison.OrdinalIgnoreCase);
			JToken value2 = val.GetValue("y", StringComparison.OrdinalIgnoreCase);
			if (value == null || value2 == null)
			{
				throw new FormatException("Expected an object with numeric x and y fields.");
			}
			return new Vector2(Extensions.Value<float>((IEnumerable<JToken>)value), Extensions.Value<float>((IEnumerable<JToken>)value2));
		}

		private static bool ContainsTrader(string value, string trader)
		{
			string normalized = TradersExtended.TraderName(trader);
			return (value ?? string.Empty).Split(new char[4] { ',', ';', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Select(TradersExtended.TraderName).Any((string entry) => string.Equals(entry, normalized, StringComparison.OrdinalIgnoreCase));
		}
	}
	internal static class ConfigEditorSerialization
	{
		private static readonly string[] CsvHeaders = new string[9] { "prefab", "stack", "price", "quality", "currency", "requiredGlobalKey", "notRequiredGlobalKey", "requiredPlayerKey", "notRequiredPlayerKey" };

		internal static string SerializeItems(IEnumerable<TradersExtended.TradeableItem> items, string extension)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			List<TradersExtended.TradeableItem> list = (items ?? Enumerable.Empty<TradersExtended.TradeableItem>()).ToList();
			extension = NormalizeExtension(extension);
			if (extension == ".json")
			{
				return JsonConvert.SerializeObject((object)list, (Formatting)1);
			}
			if (extension == ".yaml" || extension == ".yml")
			{
				ISerializer val = new SerializerBuilder().DisableAliases().Build();
				return val.Serialize((object)list);
			}
			if (extension == ".csv")
			{
				List<string> list2 = new List<string> { string.Join(",", CsvHeaders) };
				list2.AddRange(list.Select((TradersExtended.TradeableItem item) => string.Join(",", Csv(item.prefab), item.stack.ToString(CultureInfo.InvariantCulture), item.price.ToString(CultureInfo.InvariantCulture), item.quality.ToString(CultureInfo.InvariantCulture), Csv(item.currency), Csv(item.requiredGlobalKey), Csv(item.notRequiredGlobalKey), Csv(item.requiredPlayerKey), Csv(item.notRequiredPlayerKey))));
				return string.Join(Environment.NewLine, list2) + Environment.NewLine;
			}
			throw new NotSupportedException("Unsupported item configuration extension '" + extension + "'.");
		}

		internal static string SerializeTrader(JObject root, string extension)
		{
			//IL_001d: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			extension = NormalizeExtension(extension);
			if (extension == ".json")
			{
				return ((JToken)(((object)root) ?? ((object)new JObject()))).ToString((Formatting)1, Array.Empty<JsonConverter>());
			}
			if (extension == ".yaml" || extension == ".yml")
			{
				object obj = JsonConvert.DeserializeObject<object>(((JToken)(((object)root) ?? ((object)new JObject()))).ToString((Formatting)0, Array.Empty<JsonConverter>()));
				ISerializer val = new SerializerBuilder().DisableAliases().Build();
				return val.Serialize(obj);
			}
			throw new NotSupportedException("Unsupported trader configuration extension '" + extension + "'.");
		}

		internal static bool Validate(string fileName, string content, out string error)
		{
			error = string.Empty;
			try
			{
				if (TradersExtended.TryParseConfigFileName(fileName, out var trader, out var _))
				{
					if (TradersExtended.DeserializeItems(content, fileName) == null)
					{
						error = "The item configuration could not be parsed.";
						return false;
					}
					return true;
				}
				if (TradersExtended.TryParseTraderConfigFileName(fileName, out trader))
				{
					if (TraderConfigManager.DeserializeTraderConfig(content, fileName) == null)
					{
						error = "The trader configuration could not be parsed.";
						return false;
					}
					return true;
				}
				error = "The file name does not match a supported Traders Extended configuration pattern.";
				return false;
			}
			catch (Exception ex)
			{
				error = ex.Message;
				return false;
			}
		}

		internal static string NormalizeExtension(string extension)
		{
			if (string.IsNullOrWhiteSpace(extension))
			{
				return string.Empty;
			}
			extension = extension.Trim().ToLowerInvariant();
			if (!extension.StartsWith(".", StringComparison.Ordinal))
			{
				extension = "." + extension;
			}
			return extension;
		}

		internal static string Csv(string value)
		{
			if (value == null)
			{
				value = string.Empty;
			}
			if (value.IndexOfAny(new char[4] { ',', '"', '\r', '\n' }) < 0)
			{
				return value;
			}
			return "\"" + value.Replace("\"", "\"\"") + "\"";
		}
	}
	internal sealed class ConfigEditorGuiScale
	{
		private bool temporaryUnity6000Window = true;

		internal float ScaleFactor
		{
			get
			{
				float num = Mathf.Clamp(TradersExtended.configEditorUiScale?.Value ?? 1f, 0.25f, 4f);
				ConfigEntry<bool> configEditorUseValheimGuiScale = TradersExtended.configEditorUseValheimGuiScale;
				if (configEditorUseValheimGuiScale == null || configEditorUseValheimGuiScale.Value)
				{
					num *= GetValheimGuiScale();
				}
				return Mathf.Max(0.01f, num);
			}
		}

		internal int PhysicalWidth => temporaryUnity6000Window ? GetDisplayWidth() : Mathf.Max(1, Screen.width);

		internal int PhysicalHeight => temporaryUnity6000Window ? GetDisplayHeight() : Mathf.Max(1, Screen.height);

		internal float LogicalWidth => (float)PhysicalWidth / ScaleFactor;

		internal float LogicalHeight => (float)PhysicalHeight / ScaleFactor;

		internal Matrix4x4 Matrix => Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(ScaleFactor, ScaleFactor, 1f));

		internal void MarkGameWindowReady()
		{
			temporaryUnity6000Window = false;
		}

		internal Vector2 GetLogicalMousePosition()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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)
			//IL_001c: 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_0022: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			Matrix4x4 val = Matrix;
			val = ((Matrix4x4)(ref val)).inverse;
			Vector3 val2 = ((Matrix4x4)(ref val)).MultiplyPoint(UnityInput.Current.mousePosition);
			return new Vector2(val2.x, LogicalHeight - val2.y);
		}

		private float GetValheimGuiScale()
		{
			try
			{
				float num = (float)PhysicalWidth / (float)GuiScaler.m_minWidth;
				float num2 = (float)PhysicalHeight / (float)GuiScaler.m_minHeight;
				return Mathf.Max(0.01f, Mathf.Min(num, num2) * GuiScaler.m_largeGuiScale);
			}
			catch
			{
				return 1f;
			}
		}

		private static int GetDisplayWidth()
		{
			try
			{
				return (Display.main != null) ? Mathf.Max(1, Display.main.systemWidth) : Mathf.Max(1, Screen.width);
			}
			catch
			{
				return Mathf.Max(1, Screen.width);
			}
		}

		private static int GetDisplayHeight()
		{
			try
			{
				return (Display.main != null) ? Mathf.Max(1, Display.main.systemHeight) : Mathf.Max(1, Screen.height);
			}
			catch
			{
				return Mathf.Max(1, Screen.height);
			}
		}
	}
	internal sealed class ConfigEditorTheme
	{
		private static readonly Color WindowColor = new Color(0.16f, 0.16f, 0.16f, 1f);

		private static readonly Color BorderColor = new Color(0.48f, 0.48f, 0.48f, 1f);

		private static readonly Color EntryColor = new Color(0.12f, 0.12f, 0.12f, 0.95f);

		private static readonly Color TextColorValue = new Color(0.92f, 0.92f, 0.92f, 1f);

		private static readonly Color ButtonColor = new Color(0.24f, 0.24f, 0.24f, 1f);

		private static readonly Color AccentColorValue = new Color(0.38f, 0.55f, 0.72f, 1f);

		private GUISkin sourceSkin;

		private GUISkin runtimeSkin;

		private int currentFontSize = -1;

		private Texture2D windowTexture;

		private Texture2D borderTexture;

		private Texture2D entryTexture;

		private Texture2D buttonTexture;

		private Texture2D buttonHoverTexture;

		private Texture2D buttonActiveTexture;

		private Texture2D accentTexture;

		private Texture2D accentHoverTexture;

		private Texture2D scrollbarTrackTexture;

		private Texture2D toggleOffTexture;

		private Texture2D toggleOnTexture;

		private Texture2D toggleOffHoverTexture;

		private Texture2D toggleOnHoverTexture;

		private GUIStyle accentButtonStyle;

		private GUIStyle resizeHandleStyle;

		private GUIStyle compactToggleOffStyle;

		private GUIStyle compactToggleOnStyle;

		internal GUISkin Skin
		{
			get
			{
				EnsureStyles();
				return runtimeSkin ?? GUI.skin;
			}
		}

		internal Texture2D WindowTexture
		{
			get
			{
				EnsureStyles();
				return windowTexture;
			}
		}

		internal Texture2D BorderTexture
		{
			get
			{
				EnsureStyles();
				return borderTexture;
			}
		}

		internal GUIStyle AccentButtonStyle
		{
			get
			{
				EnsureStyles();
				return accentButtonStyle ?? GUI.skin.button;
			}
		}

		internal GUIStyle ResizeHandleStyle
		{
			get
			{
				EnsureStyles();
				return resizeHandleStyle ?? GUI.skin.box;
			}
		}

		internal GUIStyle CompactToggleOffStyle
		{
			get
			{
				EnsureStyles();
				return compactToggleOffStyle ?? GUI.skin.box;
			}
		}

		internal GUIStyle CompactToggleOnStyle
		{
			get
			{
				EnsureStyles();
				return compactToggleOnStyle ?? GUI.skin.box;
			}
		}

		internal float CompactToggleSize
		{
			get
			{
				EnsureStyles();
				return Mathf.Clamp((float)(TradersExtended.configEditorFontSize?.Value ?? 13) - 2f, 9f, 16f);
			}
		}

		internal Color TextColor => TextColorValue;

		internal void EnsureStyles()
		{
			GUISkin skin = GUI.skin;
			int num = Mathf.Clamp(TradersExtended.configEditorFontSize?.Value ?? 13, 9, 28);
			if (!((Object)(object)runtimeSkin != (Object)null) || currentFontSize != num || (!((Object)(object)sourceSkin == (Object)(object)skin) && !((Object)(object)runtimeSkin == (Object)(object)skin)))
			{
				Rebuild(((Object)(object)skin == (Object)(object)runtimeSkin) ? sourceSkin : skin, num);
			}
		}

		internal void Shutdown()
		{
			DestroyResources();
		}

		private void Rebuild(GUISkin baseSkin, int fontSize)
		{
			//IL_0027: 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_0047: 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_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_0081: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: 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_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: 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_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Expected O, but got Unknown
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Expected O, but got Unknown
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Expected O, but got Unknown
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Expected O, but got Unknown
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Expected O, but got Unknown
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected O, but got Unknown
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Expected O, but got Unknown
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Expected O, but got Unknown
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Expected O, but got Unknown
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Expected O, but got Unknown
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Expected O, but got Unknown
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Expected O, but got Unknown
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Expected O, but got Unknown
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Expected O, but got Unknown
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Expected O, but got Unknown
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Expected O, but got Unknown
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Expected O, but got Unknown
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Expected O, but got Unknown
			//IL_04db: Expected O, but got Unknown
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0531: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Expected O, but got Unknown
			//IL_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_054b: Expected O, but got Unknown
			//IL_054c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_055b: Expected O, but got Unknown
			//IL_0561: Expected O, but got Unknown
			//IL_05a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bc: Expected O, but got Unknown
			//IL_05c2: Expected O, but got Unknown
			DestroyResources();
			sourceSkin = baseSkin;
			currentFontSize = fontSize;
			if (!((Object)(object)baseSkin == (Object)null))
			{
				windowTexture = CreateTexture(WindowColor);
				borderTexture = CreateTexture(BorderColor);
				entryTexture = CreateTexture(EntryColor);
				buttonTexture = CreateTexture(ButtonColor);
				buttonHoverTexture = CreateTexture(Lighten(ButtonColor, 0.12f));
				buttonActiveTexture = CreateTexture(Darken(AccentColorValue, 0.1f));
				accentTexture = CreateTexture(AccentColorValue);
				accentHoverTexture = CreateTexture(Lighten(AccentColorValue, 0.12f));
				scrollbarTrackTexture = CreateTexture(Darken(EntryColor, 0.08f));
				Color val = CreateNeutralToggleColor(EntryColor, ButtonColor);
				toggleOffTexture = CreateBorderedTexture(val, BorderColor);
				toggleOnTexture = CreateBorderedTexture(AccentColorValue, BorderColor);
				toggleOffHoverTexture = CreateBorderedTexture(Lighten(val, 0.12f), Lighten(BorderColor, 0.2f));
				toggleOnHoverTexture = CreateBorderedTexture(Lighten(AccentColorValue, 0.12f), Lighten(BorderColor, 0.2f));
				runtimeSkin = Object.Instantiate<GUISkin>(baseSkin);
				((Object)runtimeSkin).name = "TradersExtendedConfigEditorSkin";
				((Object)runtimeSkin).hideFlags = (HideFlags)61;
				ConfigureTextStyle(runtimeSkin.label, TextColorValue, fontSize);
				ConfigureTextStyle(runtimeSkin.box, TextColorValue, fontSize);
				ConfigureTextStyle(runtimeSkin.window, Color.white, fontSize);
				ConfigureTextStyle(runtimeSkin.button, Color.white, fontSize);
				ConfigureTextStyle(runtimeSkin.toggle, TextColorValue, fontSize);
				ConfigureTextStyle(runtimeSkin.textField, TextColorValue, fontSize);
				ConfigureTextStyle(runtimeSkin.textArea, TextColorValue, fontSize);
				SetAllBackgrounds(runtimeSkin.window, windowTexture);
				runtimeSkin.window.padding = new RectOffset(4, 4, 21, 4);
				runtimeSkin.window.margin = new RectOffset(0, 0, 0, 0);
				runtimeSkin.window.border = new RectOffset(0, 0, 0, 0);
				SetAllBackgrounds(runtimeSkin.box, entryTexture);
				runtimeSkin.box.padding = new RectOffset(4, 4, 3, 3);
				runtimeSkin.box.margin = new RectOffset(1, 1, 1, 1);
				runtimeSkin.box.border = new RectOffset(0, 0, 0, 0);
				SetAllBackgrounds(runtimeSkin.textField, entryTexture);
				runtimeSkin.textField.padding = new RectOffset(4, 4, 1, 1);
				runtimeSkin.textField.margin = new RectOffset(1, 1, 1, 1);
				runtimeSkin.textField.border = new RectOffset(0, 0, 0, 0);
				runtimeSkin.textField.alignment = (TextAnchor)3;
				runtimeSkin.button.padding = new RectOffset(5, 5, 2, 2);
				runtimeSkin.button.margin = new RectOffset(2, 2, 1, 1);
				runtimeSkin.button.border = new RectOffset(0, 0, 0, 0);
				runtimeSkin.toggle.margin = new RectOffset(1, 1, 1, 1);
				runtimeSkin.label.margin = new RectOffset(1, 1, 0, 0);
				SetButtonBackgrounds(runtimeSkin.button);
				ConfigureSquareScrollbars(runtimeSkin);
				accentButtonStyle = new GUIStyle(runtimeSkin.button);
				SetAllBackgrounds(accentButtonStyle, accentTexture);
				accentButtonStyle.hover.background = accentHoverTexture;
				accentButtonStyle.onHover.background = accentHoverTexture;
				accentButtonStyle.active.background = buttonActiveTexture;
				accentButtonStyle.onActive.background = buttonActiveTexture;
				resizeHandleStyle = new GUIStyle(runtimeSkin.box)
				{
					padding = new RectOffset(0, 0, 0, 0),
					margin = new RectOffset(0, 0, 0, 0),
					border = new RectOffset(0, 0, 0, 0)
				};
				SetAllBackgrounds(resizeHandleStyle, accentTexture);
				resizeHandleStyle.hover.background = accentHoverTexture;
				resizeHandleStyle.active.background = buttonActiveTexture;
				compactToggleOffStyle = new GUIStyle(runtimeSkin.box)
				{
					padding = new RectOffset(0, 0, 0, 0),
					margin = new RectOffset(0, 0, 0, 0),
					border = new RectOffset(1, 1, 1, 1)
				};
				SetAllBackgrounds(compactToggleOffStyle, toggleOffTexture);
				compactToggleOffStyle.hover.background = toggleOffHoverTexture;
				compactToggleOffStyle.active.background = toggleOffHoverTexture;
				compactToggleOnStyle = new GUIStyle(compactToggleOffStyle)
				{
					border = new RectOffset(1, 1, 1, 1)
				};
				SetAllBackgrounds(compactToggleOnStyle, toggleOnTexture);
				compactToggleOnStyle.hover.background = toggleOnHoverTexture;
				compactToggleOnStyle.active.background = toggleOnHoverTexture;
			}
		}

		private void ConfigureSquareScrollbars(GUISkin skin)
		{
			ConfigureScrollbarTrack(skin.horizontalScrollbar, horizontal: true, 13f);
			ConfigureScrollbarTrack(skin.verticalScrollbar, horizontal: false, 13f);
			ConfigureScrollbarThumb(skin.horizontalScrollbarThumb, horizontal: true, 13f);
			ConfigureScrollbarThumb(skin.verticalScrollbarThumb, horizontal: false, 13f);
			HideScrollbarButton(skin.horizontalScrollbarLeftButton);
			HideScrollbarButton(skin.horizontalScrollbarRightButton);
			HideScrollbarButton(skin.verticalScrollbarUpButton);
			HideScrollbarButton(skin.verticalScrollbarDownButton);
		}

		private void ConfigureScrollbarTrack(GUIStyle style, bool horizontal, float size)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_003b: 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_0045: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			if (style != null)
			{
				SetAllBackgrounds(style, scrollbarTrackTexture);
				style.border = new RectOffset(0, 0, 0, 0);
				style.margin = (horizontal ? new RectOffset(0, 0, 0, 0) : new RectOffset(0, 1, 0, 0));
				style.padding = new RectOffset(0, 0, 0, 0);
				if (horizontal)
				{
					style.fixedHeight = size;
				}
				else
				{
					style.fixedWidth = size;
				}
			}
		}

		private void ConfigureScrollbarThumb(GUIStyle style, bool horizontal, float size)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			if (style != null)
			{
				SetAllBackgrounds(style, accentTexture);
				style.hover.background = accentHoverTexture;
				style.active.background = buttonActiveTexture;
				style.border = new RectOffset(0, 0, 0, 0);
				style.margin = new RectOffset(1, 1, 1, 1);
				style.padding = new RectOffset(0, 0, 0, 0);
				if (horizontal)
				{
					style.fixedHeight = Mathf.Max(1f, size - 2f);
				}
				else
				{
					style.fixedWidth = Mathf.Max(1f, size - 2f);
				}
			}
		}

		private static void HideScrollbarButton(GUIStyle style)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			if (style != null)
			{
				SetAllBackgrounds(style, null);
				style.border = new RectOffset(0, 0, 0, 0);
				style.margin = new RectOffset(0, 0, 0, 0);
				style.padding = new RectOffset(0, 0, 0, 0);
				style.fixedWidth = 0f;
				style.fixedHeight = 0f;
				style.stretchWidth = false;
				style.stretchHeight = false;
			}
		}

		private void SetButtonBackgrounds(GUIStyle style)
		{
			style.normal.background = buttonTexture;
			style.onNormal.background = accentTexture;
			style.hover.background = buttonHoverTexture;
			style.onHover.background = buttonHoverTexture;
			style.active.background = buttonActiveTexture;
			style.onActive.background = buttonActiveTexture;
			style.focused.background = buttonTexture;
			style.onFocused.background = accentTexture;
		}

		private static void SetAllBackgrounds(GUIStyle style, Texture2D texture)
		{
			if (style != null)
			{
				style.normal.background = texture;
				style.hover.background = texture;
				style.active.background = texture;
				style.focused.background = texture;
				style.onNormal.background = texture;
				style.onHover.background = texture;
				style.onActive.background = texture;
				style.onFocused.background = texture;
			}
		}

		private static void ConfigureTextStyle(GUIStyle style, Color color, int fontSize)
		{
			//IL_0019: 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_0040: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (style != null)
			{
				style.fontSize = fontSize;
				SetTextColor(style.normal, color);
				SetTextColor(style.hover, color);
				SetTextColor(style.active, color);
				SetTextColor(style.focused, color);
				SetTextColor(style.onNormal, color);
				SetTextColor(style.onHover, color);
				SetTextColor(style.onActive, color);
				SetTextColor(style.onFocused, color);
			}
		}

		private static void SetTextColor(GUIStyleState state, Color color)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (state != null)
			{
				state.textColor = color;
			}
		}

		private static Texture2D CreateTexture(Color color)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(1, 1, (TextureFormat)4, false)
			{
				hideFlags = (HideFlags)61,
				name = "TradersExtendedConfigEditorColor"
			};
			val.SetPixel(0, 0, color);
			val.Apply(false, true);
			return val;
		}

		private static Texture2D CreateBorderedTexture(Color fill, Color border)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_003c: 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)
			Texture2D val = new Texture2D(3, 3, (TextureFormat)4, false)
			{
				hideFlags = (HideFlags)61,
				name = "TradersExtendedConfigEditorBorderedColor"
			};
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					val.SetPixel(j, i, (j == 0 || i == 0 || j == 2 || i == 2) ? border : fill);
				}
			}
			val.Apply(false, true);
			return val;
		}

		private static Color Lighten(Color color, float amount)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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)
			return new Color(Mathf.Lerp(color.r, 1f, amount), Mathf.Lerp(color.g, 1f, amount), Mathf.Lerp(color.b, 1f, amount), color.a);
		}

		private static Color Darken(Color color, float amount)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			return new Color(color.r * (1f - amount), color.g * (1f - amount), color.b * (1f - amount), color.a);
		}

		private static Color CreateNeutralToggleColor(Color entry, Color button)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Color val = Color.Lerp(entry, button, 0.55f);
			float num = val.r * 0.299f + val.g * 0.587f + val.b * 0.114f;
			num = Mathf.Lerp(num, 1f, 0.08f);
			return new Color(num, num, num, 1f);
		}

		private void DestroyResources()
		{
			Destroy((Object)(object)runtimeSkin);
			Destroy((Object)(object)windowTexture);
			Destroy((Object)(object)borderTexture);
			Destroy((Object)(object)entryTexture);
			Destroy((Object)(object)buttonTexture);
			Destroy((Object)(object)buttonHoverTexture);
			Destroy((Object)(object)buttonActiveTexture);
			Destroy((Object)(object)accentTexture);
			Destroy((Object)(object)accentHoverTexture);
			Destroy((Object)(object)scrollbarTrackTexture);
			Destroy((Object)(object)toggleOffTexture);
			Destroy((Object)(object)toggleOnTexture);
			Destroy((Object)(object)toggleOffHoverTexture);
			Destroy((Object)(object)toggleOnHoverTexture);
			runtimeSkin = null;
			sourceSkin = null;
			accentButtonStyle = null;
			resizeHandleStyle = null;
			compactToggleOffStyle = null;
			compactToggleOnStyle = null;
		}

		private static void Destroy(Object value)
		{
			if (value != (Object)null)
			{
				Object.Destroy(value);
			}
		}
	}
	internal static class ConfigEditorGui
	{
		internal static bool ToggleLayout(ConfigEditorTheme theme, bool value, GUIContent content, float width, GUIStyle labelStyle = null, float verticalOffset = 1f, float minimumHeight = 0f)
		{
			//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_005b: Unknown result type (might be due to invalid IL or missing references)
			GUIStyle val = labelStyle ?? GUI.skin.label;
			float num = Mathf.Max(new float[3]
			{
				18f,
				val.lineHeight + 4f,
				minimumHeight
			});
			Rect rect = GUILayoutUtility.GetRect(width, num, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(width),
				GUILayout.Height(num)
			});
			return Toggle(theme, rect, value, content, val, verticalOffset);
		}

		internal static bool Toggle(ConfigEditorTheme theme, Rect rect, bool value, GUIContent content, GUIStyle labelStyle = null, float verticalOffset = 1f)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0094: 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_00b7: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			GUIStyle val = labelStyle ?? GUI.skin.label;
			string text = ((content != null) ? content.tooltip : null) ?? string.Empty;
			bool flag = GUI.Toggle(rect, value, new GUIContent(string.Empty, text), GUIStyle.none);
			float num = theme?.CompactToggleSize ?? 10f;
			float num2 = Mathf.Ceil(Mathf.Max(0f, (((Rect)(ref rect)).height - num) * 0.5f));
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref rect)).x + 1f, ((Rect)(ref rect)).y + num2 + verticalOffset, num, num);
			GUI.Box(val2, new GUIContent(string.Empty, text), flag ? theme.CompactToggleOnStyle : theme.CompactToggleOffStyle);
			string text2 = ((content != null) ? content.text : null) ?? string.Empty;
			if (!string.IsNullOrEmpty(text2))
			{
				float num3 = ((Rect)(ref val2)).xMax + 4f;
				GUI.Label(new Rect(num3, ((Rect)(ref rect)).y, Mathf.Max(0f, ((Rect)(ref rect)).xMax - num3), ((Rect)(ref rect)).height), new GUIContent(text2, text), val);
			}
			return flag;
		}
	}
	internal sealed class ConfigEditorCursor
	{
		private bool captured;

		private CursorLockMode previousLockState;

		private bool previousVisible;

		internal void Update(bool active)
		{
			if (active)
			{
				Unlock();
			}
			else
			{
				Release();
			}
		}

		internal void Release()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (captured)
			{
				Cursor.lockState = previousLockState;
				Cursor.visible = previousVisible;
				captured = false;
			}
		}

		private void Unlock()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!captured || (int)Cursor.lockState != 0 || !Cursor.visible)
			{
				previousLockState = Cursor.lockState;
				previousVisible = Cursor.visible;
				captured = true;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}
	}
	internal static class ConfigEditorInputState
	{
		internal static bool ShouldBlockAll => ConfigEditor.IsOpenGlobal && (TradersExtended.configEditorBlockGameInput?.Value ?? false);

		internal static bool ShouldBlockMouse => ShouldBlockAll;
	}
	internal static class ZInputPatchMethods
	{
		private const BindingFlags AllMethods = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		internal static IEnumerable<MethodBase> FindBooleanMethods(params string[] names)
		{
			HashSet<string> acceptedNames = new HashSet<string>(names ?? Array.Empty<string>(), StringComparer.Ordinal);
			return (from method in typeof(ZInput).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where method.ReturnType == typeof(bool) && acceptedNames.Contains(method.Name)
				select method).Cast<MethodBase>().Distinct();
		}

		internal static IEnumerable<MethodBase> FindStringButtonMethods()
		{
			return FindBooleanMethods("GetButton", "GetButtonDown", "GetButtonUp").Where(delegate(MethodBase method)
			{
				ParameterInfo[] parameters = method.GetParameters();
				return parameters.Length != 0 && parameters[0].ParameterType == typeof(string);
			});
		}
	}
	internal static class ZInputMouseBindingResolver
	{
		private sealed class CachedMouseBindings
		{
			public bool DefinitionFound;

			public bool BindingSourceResolved;

			public object ButtonAction;

			public object[] MouseControls = Array.Empty<object>();

			public int MouseButtonMask;
		}

		private const BindingFlags InstanceMembers = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

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

		internal static void ClearCache()
		{
			BindingCache.Clear();
		}

		internal static void Invalidate(string action)
		{
			if (!string.IsNullOrWhiteSpace(action))
			{
				BindingCache.Remove(action);
			}
		}

		internal static bool IsMouseBindingActive(string action, string queryMethodName, bool actionResultIsKnownTrue = false)
		{
			if (string.IsNullOrWhiteSpace(action))
			{
				return false;
			}
			CachedMouseBindings configuredMouseBindings = GetConfiguredMouseBindings(action);
			if (configuredMouseBindings.DefinitionFound)
			{
				object memberValue = GetMemberValue(configuredMouseBindings.ButtonAction, "activeControl");
				if (memberValue != null)
				{
					bool flag = IsMouseControl(memberValue);
					bool flag2 = IsControlActive(memberValue, queryMethodName);
					if (flag && (actionResultIsKnownTrue || flag2))
					{
						return true;
					}
					if (!flag && (actionResultIsKnownTrue || flag2))
					{
						return false;
					}
				}
				for (int i = 0; i < configuredMouseBindings.MouseControls.Length; i++)
				{
					if (IsControlActive(configuredMouseBindings.MouseControls[i], queryMethodName))
					{
						return true;
					}
				}
				int num = configuredMouseBindings.MouseButtonMask;
				int num2 = 0;
				while (num != 0 && num2 < 31)
				{
					if ((num & 1) != 0 && IsMouseButtonActive(num2, queryMethodName))
					{
						return true;
					}
					num2++;
					num >>= 1;
				}
				if (configuredMouseBindings.BindingSourceResolved)
				{
					return false;
				}
			}
			if (1 == 0)
			{
			}
			int num3;
			switch (action)
			{
			case "Attack":
				num3 = 0;
				break;
			case "Block":
			case "BuildMenu":
				num3 = 1;
				break;
			case "SecondaryAttack":
			case "Remove":
				num3 = 2;
				break;
			default:
				num3 = -1;
				break;
			}
			if (1 == 0)
			{
			}
			int num4 = num3;
			return num4 >= 0 && IsMouseButtonActive(num4, queryMethodName);
		}

		private static CachedMouseBindings GetConfiguredMouseBindings(string action)
		{
			if (BindingCache.TryGetValue(action, out var value))
			{
				return value;
			}
			CachedMouseBindings cachedMouseBindings = ResolveConfiguredMouseBindings(action);
			BindingCache[action] = cachedMouseBindings;
			return cachedMouseBindings;
		}

		private static CachedMouseBindings ResolveConfiguredMouseBindings(string action)
		{
			CachedMouseBindings cachedMouseBindings = new CachedMouseBindings();
			try
			{
				ZInput instance = ZInput.instance;
				if (instance?.m_buttons == null || !instance.m_buttons.TryGetValue(action, out var value))
				{
					return cachedMouseBindings;
				}
				cachedMouseBindings.DefinitionFound = true;
				ResolveDirectButtonDefinition(value, cachedMouseBindings);
				object memberValue = GetMemberValue(value, "ButtonAction");
				if (memberValue == null)
				{
					memberValue = GetMemberValue(value, "m_buttonAction");
				}
				if (memberValue == null)
				{
					return cachedMouseBindings;
				}
				cachedMouseBindings.BindingSourceResolved = true;
				cachedMouseBindings.ButtonAction = memberValue;
				object memberValue2 = GetMemberValue(memberValue, "bindings");
				if (memberValue2 is IEnumerable enumerable)
				{
					foreach (object item in enumerable)
					{
						string text = GetMemberValue(item, "effectivePath") as string;
						if (string.IsNullOrWhiteSpace(text))
						{
							text = GetMemberValue(item, "path") as string;
						}
						if (TryParseMouseButton(text, out var mouseButton) && mouseButton < 31)
						{
							cachedMouseBindings.MouseButtonMask |= 1 << mouseButton;
						}
					}
				}
				object memberValue3 = GetMemberValue(memberValue, "controls");
				if (memberValue3 is IEnumerable enumerable2)
				{
					List<object> list = new List<object>();
					foreach (object item2 in enumerable2)
					{
						if (item2 != null && IsMouseControl(item2))
						{
							list.Add(item2);
						}
					}
					cachedMouseBindings.MouseControls = list.ToArray();
				}
			}
			catch
			{
				return new CachedMouseBindings();
			}
			return cachedMouseBindings;
		}

		private static void ResolveDirectButtonDefinition(object definition, CachedMouseBindings resolved)
		{
			if (definition == null || resolved == null)
			{
				return;
			}
			bool value;
			bool flag = TryGetBooleanMember(definition, "m_bMouseButtonSet", out value) || TryGetBooleanMember(definition, "m_mouseButtonSet", out value);
			object memberValue = GetMemberValue(definition, "m_mouseButton");
			int mouseButton2;
			if (flag)
			{
				resolved.BindingSourceResolved = true;
				if (value && TryConvertMouseButton(memberValue, out var mouseButton))
				{
					resolved.MouseButtonMask |= 1 << mouseButton;
				}
			}
			else if (memberValue != null && TryConvertMouseButton(memberValue, out mouseButton2))
			{
				string text = memberValue.ToString() ?? string.Empty;
				if (!text.Equals("None", StringComparison.OrdinalIgnoreCase) && !text.Equals("Back", StringComparison.OrdinalIgnoreCase))
				{
					resolved.BindingSourceResolved = true;
					resolved.MouseButtonMask |= 1 << mouseButton2;
				}
			}
			object memberValue2 = GetMemberValue(definition, "m_key");
			if (memberValue2 != null)
			{
				string text2 = memberValue2.ToString() ?? string.Empty;
				if (TryParseLegacyMouseKeyName(text2, out var mouseButton3))
				{
					resolved.BindingSourceResolved = true;
					resolved.MouseButtonMask |= 1 << mouseButton3;
				}
				else if (!text2.Equals("None", StringComparison.OrdinalIgnoreCase))
				{
					resolved.BindingSourceResolved = true;
				}
			}
		}

		private static bool TryConvertMouseButton(object value, out int mouseButton)
		{
			mouseButton = -1;
			if (value == null)
			{
				return false;
			}
			string text = value.ToString() ?? string.Empty;
			if (text.Equals("Left", StringComparison.OrdinalIgnoreCase) || text.Equals("LeftButton", StringComparison.OrdinalIgnoreCase))
			{
				mouseButton = 0;
				return true;
			}
			if (text.Equals("Right", StringComparison.OrdinalIgnoreCase) || text.Equals("RightButton", StringComparison.OrdinalIgnoreCase))
			{
				mouseButton = 1;
				return true;
			}
			if (text.Equals("Middle", StringComparison.OrdinalIgnoreCase) || text.Equals("MiddleButton", StringComparison.OrdinalIgnoreCase))
			{
				mouseButton = 2;
				return true;
			}
			if (text.Equals("Forward", StringComparison.OrdinalIgnoreCase) || text.Equals("ForwardButton", StringComparison.OrdinalIgnoreCase))
			{
				mouseButton = 3;
				return true;
			}
			if (text.Equals("Back", StringComparison.OrdinalIgnoreCase) || text.Equals("BackButton", StringComparison.OrdinalIgnoreCase))
			{
				mouseButton = 4;
				return true;
			}
			try
			{
				int num = Convert.ToInt32(value);
				if (num >= 0 && num < 31)
				{
					mouseButton = num;
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool TryParseLegacyMouseKeyName(string keyName, out int mouseButton)
		{
			mouseButton = -1;
			if (string.IsNullOrWhiteSpace(keyName) || !keyName.StartsWith("Mouse", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			return int.TryParse(keyName.Substring(5), out mouseButton) && mouseButton >= 0 && mouseButton < 31;
		}

		private static object GetMemberValue(object instance, string memberName)
		{
			if (instance == null || string.IsNullOrEmpty(memberName))
			{
				return null;
			}
			try
			{
				Type type = instance.GetType();
				PropertyInfo property = type.GetProperty(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null && property.GetIndexParameters().Length == 0)
				{
					return property.GetValue(instance, null);
				}
				return type.GetField(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(instance);
			}
			catch
			{
				return null;
			}
		}

		private static bool TryGetBooleanMember(object instance, string memberName, out bool value)
		{
			value = false;
			if (!(GetMemberValue(instance, memberName) is bool flag) || 1 == 0)
			{
				return false;
			}
			value = flag;
			return true;
		}

		private static bool IsMouseControl(object control)
		{
			if (control == null)
			{
				return false;
			}
			string text = GetMemberValue(control, "path") as string;
			if (!string.IsNullOrWhiteSpace(text) && text.IndexOf("/Mouse/", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			object memberValue = GetMemberValue(control, "device");
			string text2 = memberValue?.GetType().FullName ?? string.Empty;
			if (text2.EndsWith(".Mouse", StringComparison.Ordinal) || string.Equals(memberValue?.GetType().Name, "Mouse", StringComparison.Ordinal))
			{
				return true;
			}
			string a = GetMemberValue(memberValue, "displayName") as string;
			return string.Equals(a, "Mouse", StringComparison.OrdinalIgnoreCase);
		}

		private static bool IsControlActive(object control, string queryMethodName)
		{
			if (control == null)
			{
				return false;
			}
			if (1 == 0)
			{
			}
			string text = ((queryMethodName == "GetButtonDown") ? "wasPressedThisFrame" : ((!(queryMethodName == "GetButtonUp")) ? "isPressed" : "wasReleasedThisFrame"));
			if (1 == 0)
			{
			}
			string memberName = text;
			if (TryGetBooleanMember(control, memberName, out var value))
			{
				return value;
			}
			MethodInfo method = control.GetType().GetMethod("ReadValueAsButton", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			if (method != null && method.ReturnType == typeof(bool))
			{
				try
				{
					return (bool)method.Invoke(control, null);
				}
				catch
				{
				}
			}
			return false;
		}

		private static bool TryParseMouseButton(string path, out int mouseButton)
		{
			mouseButton = -1;
			if (string.IsNullOrWhiteSpace(path) || path.IndexOf("<Mouse>", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return false;
			}
			string text = path.Replace(" ", string.Empty).ToLowerInvariant();
			if (text.EndsWith("/leftbutton", StringComparison.Ordinal))
			{
				mouseButton = 0;
			}
			else if (text.EndsWith("/rightbutton", StringComparison.Ordinal))
			{
				mouseButton = 1;
			}
			else if (text.EndsWith("/middlebutton", StringComparison.Ordinal))
			{
				mouseButton = 2;
			}
			else if (text.EndsWith("/forwardbutton", StringComparison.Ordinal))
			{
				mouseButton = 3;
			}
			else if (text.EndsWith("/backbutton", StringComparison.Ordinal))
			{
				mouseButton = 4;
			}
			else
			{
				int num = text.LastIndexOf("/button", StringComparison.Ordinal);
				if (num < 0 || !int.TryParse(text.Substring(num + 7), out mouseButton))
				{
					return false;
				}
			}
			return mouseButton >= 0;
		}

		private static bool IsMouseButtonActive(int mouseButton, string queryMethodName)
		{
			if (TryGetInputSystemMouseButton(mouseButton, out var control) && IsControlActive(control, queryMethodName))
			{
				return true;
			}
			try
			{
				if (1 == 0)
				{
				}
				bool result = ((queryMethodName == "GetButtonDown") ? Input.GetMouseButtonDown(mouseButton) : ((!(queryMethodName == "GetButtonUp")) ? Input.GetMouseButton(mouseButton) : Input.GetMouseButtonUp(mouseButton)));
				if (1 == 0)
				{
				}
				return result;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryGetInputSystemMouseButton(int mouseButton, out object control)
		{
			control = null;
			try
			{
				object obj = Type.GetType("UnityEngine.InputSystem.Mouse, Unity.InputSystem", throwOnError: false)?.GetProperty("current", BindingFlags.Static | BindingFlags.Public)?.GetValue(null, null);
				if (obj == null)
				{
					return false;
				}
				if (1 == 0)
				{
				}
				string text = mouseButton switch
				{
					0 => "leftButton", 
					1 => "rightButton", 
					2 => "middleButton", 
					3 => "forwardButton", 
					4 => "backButton", 
					_ => null, 
				};
				if (1 == 0)
				{
				}
				string text2 = text;
				if (text2 == null)
				{
					return false;
				}
				control = GetMemberValue(obj, text2);
				return control != null;
			}
			catch
			{
				return false;
			}
		}
	}
	[HarmonyPatch]
	internal static class ZInputMouseBindingCachePatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return typeof(ZInput).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Where(delegate(MethodInfo method)
			{
				if (method.Name == "Load")
				{
					return true;
				}
				if (method.Name != "AddButton")
				{
					return false;
				}
				ParameterInfo[] parameters = method.GetParameters();
				return parameters.Length != 0 && parameters[0].ParameterType == typeof(string);
			}).Cast<MethodBase>()
				.Distinct();
		}

		private static void Postfix(MethodBase __originalMethod, object[] __args)
		{
			if (__originalMethod?.Name == "Load")
			{
				ZInputMouseBindingResolver.ClearCache();
				return;
			}
			string action = ((__args != null && __args.Length != 0) ? (__args[0] as string) : null);
			ZInputMouseBindingResolver.Invalidate(action);
		}
	}
	[HarmonyPatch(typeof(PlayerController), "TakeInput")]
	[HarmonyPriority(0)]
	internal static class PlayerControllerTakeInputPatch
	{
		private static void Postfix(ref bool __result)
		{
			if (ConfigEditorInputState.ShouldBlockAll)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(TextInput), "IsVisible")]
	[HarmonyPriority(0)]
	internal static class TextInputIsVisiblePatch
	{
		private static void Postfix(ref bool __result)
		{
			if (ConfigEditorInputState.ShouldBlockAll)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch]
	internal static class ValheimMouseInteractionBlockPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return new MethodInfo[7]
			{
				AccessTools.Method(typeof(InventoryGrid), "OnLeftClick", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(InventoryGrid), "OnRightClick", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(InventoryGui), "OnSelectedItem", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(InventoryGui), "OnRightClickItem", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(Toggle), "OnPointerClick", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(Button), "OnPointerClick", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(ScrollRect), "OnScroll", (Type[])null, (Type[])null)
			}.Where((MethodInfo method) => method != null);
		}

		[HarmonyPriority(800)]
		private static bool Prefix()
		{
			return !ConfigEditorInputState.ShouldBlockMouse;
		}
	}
	[HarmonyPatch]
	internal static class ValheimAllInputInteractionBlockPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return new MethodInfo[4]
			{
				AccessTools.Method(typeof(Toggle), "OnSubmit", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(Button), "OnSubmit", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(Button), "Press", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(Player), "UseHotbarItem", (Type[])null, (Type[])null)
			}.Where((MethodInfo method) => method != null);
		}

		[HarmonyPriority(800)]
		private static bool Prefix()
		{
			return !ConfigEditorInputState.ShouldBlockAll;
		}
	}
	[HarmonyPatch]
	internal static class ZInputAllBooleanBlockPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return ZInputPatchMethods.FindBooleanMethods("ShouldAcceptInputFromSource", "GetKey", "GetKeyUp", "GetKeyDown", "GetButton", "GetButtonDown", "GetButtonUp", "GetRadialTap", "GetRadialMultiTap");
		}

		[HarmonyPriority(800)]
		private static bool Prefix(ref bool __result)
		{
			if (!ConfigEditorInputState.ShouldBlockAll)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch]
	internal static class ZInputMouseMappedButtonBlockPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return ZInputPatchMethods.FindStringButtonMethods();
		}

		[HarmonyPriority(0)]
		private static Exception Finalizer(Exception __exception, MethodBase __originalMethod, object[] __args, ref bool __result)
		{
			if (__exception != null || !__result || ConfigEditorInputState.ShouldBlockAll || !ConfigEditorInputState.ShouldBlockMouse)
			{
				return __exception;
			}
			string action = ((__args != null && __args.Length != 0) ? (__args[0] as string) : null);
			if (ZInputMouseBindingResolver.IsMouseBindingActive(action, __originalMethod?.Name, actionResultIsKnownTrue: true))
			{
				__result = false;
			}
			return __exception;
		}
	}
	[HarmonyPatch]
	internal static class PlayerSetControlsMouseBlockPatch
	{
		private const BindingFlags AllMethods = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		private static IEnumerable<MethodBase> TargetMethods()
		{
			string[] requiredNames = new string[6] { "attack", "attackHold", "secondaryAttack", "secondaryAttackHold", "block", "blockHold" };
			return (from method in typeof(Player).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where method.Name == "SetControls"
				select method).Where(delegate(MethodInfo method)
			{
				HashSet<string> hashSet = new HashSet<string>(from parameter in method.GetParameters()
					select parameter.Name, StringComparer.Ordinal);
				return requiredNames.All(hashSet.Contains);
			}).Cast<MethodBase>().Distinct();
		}

		[HarmonyPriority(0)]
		private static void Prefix(ref bool attack, ref bool attackHold, ref bool secondaryAttack, ref bool secondaryAttackHold, ref bool block, ref bool blockHold)
		{
			if (ConfigEditorInputState.ShouldBlockMouse && !ConfigEditorInputState.ShouldBlockAll)
			{
				if ((attack | attackHold) && ZInputMouseBindingResolver.IsMouseBindingActive("Attack", "GetButton", actionResultIsKnownTrue: true))
				{
					attack = false;
					attackHold = false;
				}
				if ((secondaryAttack | secondaryAttackHold) && ZInputMouseBindingResolver.IsMouseBindingActive("SecondaryAttack", "GetButton", actionResultIsKnownTrue: true))
				{
					secondaryAttack = false;
					secondaryAttackHold = false;
				}
				if ((block | blockHold) && ZInputMouseBindingResolver.IsMouseBindingActive("Block", "GetButton", actionResultIsKnownTrue: true))
				{
					block = false;
					blockHold = false;
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class ZInputMouseBooleanBlockPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return ZInputPatchMethods.FindBooleanMethods("GetMouseButton", "GetMouseButtonDown", "GetMouseButtonUp");
		}

		[HarmonyPriority(800)]
		private static bool Prefix(ref bool __result)
		{
			if (!ConfigEditorInputState.ShouldBlockMouse)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch]
	internal static class ZInputAllFloatBlockPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return new MethodInfo[6]
			{
				AccessTools.Method(typeof(ZInput), "GetJoyLeftStickX", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(ZInput), "GetJoyLeftStickY", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(ZInput), "GetJoyRTrigger", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(ZInput), "GetJoyLTrigger", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(ZInput), "GetJoyRightStickX", (Type[])null, (Type[])null),
				AccessTools.Method(typeof(ZInput), "GetJoyRightStickY", (Type[])null, (Type[])null)
			}.Where((MethodInfo method) => method != null);
		}

		[HarmonyPriority(0)]
		private static void Postfix(ref float __result)
		{
			if (ConfigEditorInputState.ShouldBlockAll)
			{
				__result = 0f;
			}
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetMouseScrollWheel")]
	internal static class ZInputMouseScrollBlockPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(ref float __result)
		{
			if (ConfigEditorInputState.ShouldBlockMouse)
			{
				__result = 0f;
			}
		}
	}
	[HarmonyPatch(typeof(ZInput), "GetMouseDelta")]
	internal static class ZInputMouseDeltaBlockPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(ref Vector2 __result)
		{
			//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)
			if (ConfigEditorInputState.ShouldBlockMouse)
			{
				__result = Vector2.zero;
			}
		}
	}
	internal enum ConfigEditorOperation
	{
		Access,
		List,
		Read,
		Write,
		Delete,
		Create
	}
	internal static class ConfigEditorTransport
	{
		private enum RemoteAdminAccessState
		{
			Unknown,
			Checking,
			Allowed,
			Denied
		}

		private sealed class PendingRequest
		{
			internal ConfigEditorOperation Operation;

			internal string FileName;

			internal string Content;
		}

		private const string RequestRpc = "shudnal.TradersExtended.ConfigEditorRequest";

		private const string ResponseRpc = "shudnal.TradersExtended.ConfigEditorResponse";

		private static RemoteAdminAccessState remoteAdminAccess;

		private static long remoteAdminServerPeerId;

		private static PendingRequest pendingRequest;

		internal static bool UsesRemoteServer => (Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer() && ZRoutedRpc.instance != null && ZRoutedRpc.instance.GetServerPeerID() != 0;

		internal static bool CanEditTarget
		{
			get
			{
				if (!UsesRemoteServer)
				{
					return true;
				}
				RefreshRemoteAdminState();
				return remoteAdminAccess == RemoteAdminAccessState.Allowed;
			}
		}

		internal static string TargetDescription => UsesRemoteServer ? "dedicated server" : "local configuration directory";

		internal static string EditorDirectory => Path.Combine(Paths.ConfigPath, "shudnal.TradersExtended");

		internal static event Action<ConfigEditorOperation, bool, string, string, string> ResponseReceived;

		internal static void RegisterRpc()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode("shudnal.TradersExtended.ConfigEditorRequest");
				if (!instance.m_functions.ContainsKey(stableHashCode))
				{
					instance.Register<ZPackage>("shudnal.TradersExtended.ConfigEditorRequest", (Action<long, ZPackage>)RPC_Request);
				}
				int stableHashCode2 = StringExtensionMethods.GetStableHashCode("shudnal.TradersExtended.ConfigEditorResponse");
				if (!instance.m_functions.ContainsKey(stableHashCode2))
				{
					instance.Register<ZPackage>("shudnal.TradersExtended.ConfigEditorResponse", (Action<long, ZPackage>)RPC_Response);
				}
			}
		}

		internal static void RequestList()
		{
			SendRequest(ConfigEditorOperation.List, string.Empty, string.Empty, forceAdminRefresh: true);
		}

		internal static void RequestRead(string fileName)
		{
			SendRequest(ConfigEditorOperation.Read, fileName, string.Empty);
		}

		internal static void RequestWrite(string fileName, string content)
		{
			SendRequest(ConfigEditorOperation.Write, fileName, content ?? string.Empty);
		}

		internal static void RequestCreate(string fileName, string content)
		{
			SendRequest(ConfigEditorOperation.Create, fileName, content ?? string.Empty);
		}

		internal static void RequestDelete(string fileName)
		{
			SendRequest(ConfigEditorOperation.Delete, fileName, string.Empty);
		}

		private static void SendRequest(ConfigEditorOperation operation, string fileName, string content, bool forceAdminRefresh = false)
		{
			RegisterRpc();
			if (!UsesRemoteServer)
			{
				ExecuteRequest(operation, fileName, content, Emit);
				return;
			}
			RefreshRemoteAdminState();
			PendingRequest request = new PendingRequest
			{
				Operation = operation,
				FileName = (fileName ?? string.Empty),
				Content = (content ?? string.Empty)
			};
			if (!forceAdminRefresh && remoteAdminAccess == RemoteAdminAccessState.Allowed)
			{
				SendRemoteRequest(request);
				return;
			}
			pendingRequest = request;
			RequestRemoteAdminAccess(forceAdminRefresh);
		}

		private static void RequestRemoteAdminAccess(bool forceRefresh)
		{
			RefreshRemoteAdminState();
			if (remoteAdminAccess == RemoteAdminAccessState.Checking)
			{
				return;
			}
			if (!forceRefresh && remoteAdminAccess == RemoteAdminAccessState.Allowed)
			{
				PendingRequest pendingRequest = ConfigEditorTransport.pendingRequest;
				ConfigEditorTransport.pendingRequest = null;
				if (pendingRequest != null)
				{
					SendRemoteRequest(pendingRequest);
				}
			}
			else
			{
				remoteAdminAccess = RemoteAdminAccessState.Checking;
				SendRemoteRequest(new PendingRequest
				{
					Operation = ConfigEditorOperation.Access,
					FileName = string.Empty,
					Content = string.Empty
				});
			}
		}

		private static void SendRemoteRequest(PendingRequest request)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			if (request != null && ZRoutedRpc.instance != null)
			{
				ZPackage val = new ZPackage();
				val.Write((int)request.Operation);
				val.Write(request.FileName ?? string.Empty);
				val.Write(request.Content ?? string.Empty);
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "shudnal.TradersExtended.ConfigEditorRequest", new object[1] { val });
			}
		}

		private static void RefreshRemoteAdminState()
		{
			long num = ((UsesRemoteServer && ZRoutedRpc.instance != null) ? ZRoutedRpc.instance.GetServerPeerID() : 0);
			if (num != remoteAdminServerPeerId)
			{
				remoteAdminServerPeerId = num;
				remoteAdminAccess = RemoteAdminAccessState.Unknown;
				pendingRequest = null;
			}
		}

		private static void RPC_Request(long sender, ZPackage package)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			ConfigEditorOperation configEditorOperation = (ConfigEditorOperation)package.ReadInt();
			string fileName = package.ReadString();
			string content = package.ReadString();
			bool flag = IsSenderAdmin(sender);
			if (configEditorOperation == ConfigEditorOperation.Access)
			{
				SendResponse(sender, configEditorOperation, success: true, string.Empty, flag ? "Administrator access granted." : "Administrator access denied.", flag ? "1" : "0");
				return;
			}
			if (!flag)
			{
				SendResponse(sender, configEditorOperation, success: false, fileName, "Administrator access is required to edit Traders Extended files.", string.Empty);
				return;
			}
			ExecuteRequest(configEditorOperation, fileName, content, delegate(ConfigEditorOperation responseOperation, bool success, string responseFile, string message, string payload)
			{
				SendResponse(sender, responseOperation, success, responseFile, message, payload);
			});
		}

		private static void RPC_Response(long sender, ZPackage package)
		{
			if (UsesRemoteServer && ZRoutedRpc.instance != null && sender != ZRoutedRpc.instance.GetServerPeerID())
			{
				return;
			}
			ConfigEditorOperation configEditorOperation = (ConfigEditorOperation)package.ReadInt();
			bool flag = package.ReadBool();
			string fileName = package.ReadString();
			string text = package.ReadString();
			string text2 = package.ReadString();
			if (configEditorOperation == ConfigEditorOperation.Access)
			{
				remoteAdminAccess = ((flag && text2 == "1") ? RemoteAdminAccessState.Allowed : RemoteAdminAccessState.Denied);
				PendingRequest pendingRequest = ConfigEditorTransport.pendingRequest;
				ConfigEditorTransport.pendingRequest = null;
				if (pendingRequest != null)
				{
					if (remoteAdminAccess == RemoteAdminAccessState.Allowed)
					{
						SendRemoteRequest(pendingRequest);
					}
					else
					{
						Emit(pendingRequest.Operation, success: false, pendingRequest.FileName, "Administrator access is required to edit Traders Extended files on this server.", string.Empty);
					}
				}
			}
			else
			{
				if (!flag && text.IndexOf("Administrator access", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					remoteAdminAccess = RemoteAdminAccessState.Denied;
				}
				Emit(configEditorOperation, flag, fileName, text, text2);
			}
		}

		private static void SendResponse(long target, ConfigEditorOperation operation, bool success, string fileName, string message, string payload)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write((int)operation);
			val.Write(success);
			val.Write(fileName ?? string.Empty);
			val.Write(message ?? string.Empty);
			val.Write(payload ?? string.Empty);
			ZRoutedRpc.instance.InvokeRoutedRPC(target, "shudnal.TradersExtended.ConfigEditorResponse", new object[1] { val });
		}

		private static void ExecuteRequest(ConfigEditorOperation operation, string fileName, string content, Action<ConfigEditorOperation, bool, string, string, string> responder)
		{
			try
			{
				Directory.CreateDirectory(EditorDirectory);
				switch (operation)
				{
				case ConfigEditorOperation.List:
				{
					List<EditorFileInfo> list = (from path in Directory.EnumerateFiles(EditorDirectory, "*", SearchOption.TopDirectoryOnly)
						where TradersExtended.IsSupportedConfigExtension(Path.GetExtension(path))
						select BuildFileInfo(new FileInfo(path)) into info
						where info != null
						orderby info.Kind
						select info).ThenBy<EditorFileInfo, string>((EditorFileInfo info) => info.Name, StringComparer.OrdinalIgnoreCase).ToList();
					responder(operation, arg2: true, string.Empty, $"Loaded {list.Count} configuration file(s).", JsonConvert.SerializeObject((object)list));
					break;
				}
				case ConfigEditorOperation.Read:
				{
					string safePath2 = GetSafePath(fileName);
					if (!File.Exists(safePath2))
					{
						throw new FileNotFoundException("The selected configuration file no longer exists.", fileName);
					}
					string arg;
					using (FileStream stream = new FileStream(safePath2, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
					{
						using StreamReader streamReader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true);
						arg = streamReader.ReadToEnd();
					}
					responder(operation, arg2: true, fileName, "Configuration loaded.", arg);
					break;
				}
				case ConfigEditorOperation.Write:
				case ConfigEditorOperation.Create:
				{
					string safePath3 = GetSafePath(fileName);
					if (operation == ConfigEditorOperation.Create && File.Exists(safePath3))
					{
						throw new IOException("A configuration file with this name already exists.");
					}
					if (!ConfigEditorSerialization.Validate(fileName, content, out var error))
					{
						throw new InvalidDataException(error);
					}
					File.WriteAllText(safePath3, content ?? string.Empty, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
					TradersExtended.ReadConfigs();
					string arg2 = ((operation == ConfigEditorOperation.Create) ? "Configuration created and reloaded." : "Configuration saved and reloaded.");
					responder(operation, arg2: true, fileName, arg2, string.Empty);
					break;
				}
				case ConfigEditorOperation.Delete:
				{
					string safePath = GetSafePath(fileName, requireSupportedPattern: false);
					if (File.Exists(safePath))
					{
						File.Delete(safePath);
					}
					TradersExtended.ReadConfigs();
					responder(operation, arg2: true, fileName, "Configuration deleted and reloaded.", string.Empty);
					break;
				}
				default:
					throw new InvalidOperationException("Unknown configuration editor operation.");
				}
			}
			catch (Exception ex)
			{
				responder(operation, arg2: false, fileName, ex.Message, string.Empty);
			}
		}

		private static EditorFileInfo BuildFileInfo(FileInfo file)
		{
			if (file == null || !TradersExtended.IsSupportedConfigExtension(file.Extension))
			{
				return null;
			}
			EditorFileInfo editorFileInfo = new EditorFileInfo
			{
				Name = file.Name,
				Length = file.Length,
				LastWriteUtcTicks = file.LastWriteTimeUtc.Ticks,
				Kind = EditorConfigKind.Unsupported
			};
			if (TradersExtended.TryParseConfigFileName(file.Name, out var trader, out var listType))
			{
				editorFileInfo.Kind = EditorConfigKind.ItemList;
				editorFileInfo.Trader = trader;
				editorFileInfo.ListType = listType;
			}
			else if (TradersExtended.TryParseTraderConfigFileName(file.Name, out trader))
			{
				editorFileInfo.Kind = EditorConfigKind.TraderSettings;
				editorFileInfo.Trader = trader;
			}
			return editorFileInfo;
		}

		private static string GetSafePath(string fileName, bool requireSupportedPattern = true)
		{
			if (string.IsNullOrWhiteSpace(fileName) || !string.Equals(fileName, Path.GetFileName(fileName), StringComparison.Ordinal) || !TradersExtended.IsSupportedConfigExtension(Path.GetExtension(fileName)) || (requireSupportedPattern && !TradersExtended.TryParseConfigFileName(fileName, out var trader, out var _) && !TradersExtended.TryParseTraderConfigFileName(fileName, out trader)))
			{
				throw new InvalidDataException("Invalid Traders Extended configuration file name.");
			}
			string fullPath = Path.GetFullPath(EditorDirectory);
			string fullPath2 = Path.GetFullPath(Path.Combine(fullPath, fileName));
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			if (!fullPath2.StartsWith(fullPath + directorySeparatorChar, StringComparison.OrdinalIgnoreCase))
			{
				throw new InvalidDataException("The selected path is outside the Traders Extended configuration directory.");
			}
			return fullPath2;
		}

		private static bool IsSenderAdmin(long sender)
		{
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || !instance.IsServer())
			{
				return false;
			}
			if (ZRoutedRpc.instance != null && sender == ZRoutedRpc.instance.m_id)
			{
				return true;
			}
			ZNetPeer peer = instance.GetPeer(sender);
			if (peer == null || peer.m_socket == null || instance.m_adminList == null)
			{
				return false;
			}
			string hostName = peer.m_socket.GetHostName();
			return !string.IsNullOrWhiteSpace(hostName) && instance.ListContainsId(instance.m_adminList, hostName);
		}

		private static void Emit(ConfigEditorOperation operation, bool success, string fileName, string message, string payload)
		{
			ConfigEditorTransport.ResponseReceived?.Invoke(operation, success, fileName ?? string.Empty, message ?? string.Empty, payload ?? string.Empty);
		}
	}
	[HarmonyPatch(typeof(ZNet), "Awake")]
	internal static class ZNet_Awake_RegisterConfigEditorRpc
	{
		private static void Postfix()
		{
			ConfigEditorTransport.RegisterRpc();
		}
	}
	internal static class StorePanel
	{
		public class ItemToSell
		{
			public enum ItemType
			{
				Single,
				Stack,
				Combined
			}

			private const string c_buybackItem = "buybackItem";

			public ItemType itemType = ItemType.Single;

			public ItemData item;

			public int stack;

			public int price;

			public int amount;

			public int quality;

			public int pricePerItem;

			public ItemDrop currency;

			public ItemToSell Clone()
			{
				ItemToSell itemToSell = MemberwiseClone() as ItemToSell;
				itemToSell.item = item.Clone();
				return itemToSell;
			}

			public static bool IsBuyBackItem(TradeItem item)
			{
				return item?.m_requiredGlobalKey == "buybackItem";
			}

			public static TradeItem SetBuyBackItem(TradeItem item)
			{
				item.m_requiredGlobalKey = "buybackItem";
				return item;
			}
		}

		private sealed class SellPrice
		{
			internal int Price;

			internal string CurrencyPrefab;
		}

		[HarmonyPatch(typeof(StoreGui), "Awake")]
		public static class StoreGui_Awake_InitializePanel
		{
			private static GuiInputField InitFilterField(Transform parent)
			{
				//IL_0038: 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_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = Object.Instantiate<GameObject>(((Component)TextInput.instance.m_inputField).gameObject, parent);
				((Object)val).name = "FilterField";
				val.transform.localPosition = new Vector3(125f, -51f, 0f);
				val.transform.SetSiblingIndex(val.transform.parent.Find("topic").GetSiblingIndex() + 1);
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(1f, 0.5f);
				component.anchorMax = new Vector2(0f, 0.5f);
				component.sizeDelta -= new Vector2(0f, 10f);
				GuiInputField component2 = val.GetComponent<GuiInputField>();
				component2.VirtualKeyboardTitle = "$menu_filter";
				((Component)((Component)component2).transform.Find("Text Area/Placeholder")).GetComponent<TMP_Text>().SetText(Localization.instance.Localize("$menu_filter"));
				return component2;
			}

			[HarmonyPriority(800)]
			private static void Postfix(StoreGui __instance)
			{
				//IL_006f: 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_00b6: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0203: Unknown result type (might be due to invalid IL or missing references)
				//IL_0361: Unknown result type (might be due to invalid IL or missing references)
				//IL_0375: Unknown result type (might be due to invalid IL or missing references)
				//IL_037a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0398: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f4: Expected O, but got Unknown
				//IL_0473: Unknown result type (might be due to invalid IL or missing references)
				//IL_0478: Unknown result type (might be due to invalid IL or missing references)
				//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0516: Unknown result type (might be due to invalid IL or missing references)
				//IL_0585: Unknown result type (might be due to invalid IL or missing references)
				//IL_0594: Unknown result type (might be due to invalid IL or missing references)
				//IL_0599: Unknown result type (might be due to invalid IL or missing references)
				TraderCurrency.CaptureVanillaCurrency(__instance);
				InitializeNonTeleportableIcon(__instance.m_listElement);
				TradersExtended.FillConfigLists();
				sellPanel = Object.Instantiate<GameObject>(__instance.m_rootPanel, __instance.m_rootPanel.transform);
				sellPanel.transform.localPosition = new Vector3(250f, 0f, 0f);
				((Object)sellPanel).name = "StoreSell";
				sellPanel.SetActive(true);
				RectTransform component = __instance.m_rootPanel.GetComponent<RectTransform>();
				component.sizeDelta += new Vector2(0f, 35f);
				RectTransform component2 = __instance.m_listElement.GetComponent<RectTransform>();
				((Transform)component2).localPosition = ((Transform)component2).localPosition - new Vector3(0f, 35f, 0f);
				Object.Destroy((Object)(object)((Component)sellPanel.transform.Find("SellPanel")).gameObject);
				Object.Destroy((Object)(object)((Component)sellPanel.transform.Find("border (1)")).gameObject);
				Object.Destroy((Object)(object)((Component)sellPanel.transform.Find("bkg")).gameObject);
				Transform obj = __instance.m_rootPanel.transform.Find("ItemList");
				obj.localPosition -= new Vector3(0f, 35f, 0f);
				Transform obj2 = sellPanel.transform.Find("ItemList");
				obj2.localPosition -= new Vector3(0f, 35f, 0f);
				RectTransform component3 = ((Component)sellPanel.transform.Find("coins")).GetComponent<RectTransform>();
				((Transform)component3).localPosition = ((Transform)component3).localPosition - new Vector3(0f, 35f, 0f);
				Transform val = sellPanel.transform.Find("ItemList/Items");
				listRoot = ((Component)val.Find("ListRoot")).GetComponent<RectTransform>();
				listElement = ((Component)val.Find("ItemElement")).gameObject;
				InitializeNonTeleportableIcon(listElement);
				itemEnsureVisible = ((Component)val).GetComponent<ScrollRectEnsureVisible>();
				StorePanel.tooltipAnchor = ((Component)sellPanel.transform.Find("TooltipAnchor")).GetComponent<RectTransform>();
				storeName = ((Component)__instance.m_rootPanel.transform.Find("topic")).GetComponent<TMP_Text>();
				playerName = ((Component)sellPanel.transform.Find("topic")).GetComponent<TMP_Text>();
				TraderCoins.playerCoins = ((Component)sellPanel.transform.Find("coins/coins")).GetComponent<TMP_Text>();
				TraderCoins.traderCoins = __instance.m_coinText;
				TraderCoins.traderCoinsPanel = ((Component)__instance.m_rootPanel.transform.Find("coins")).gameObject;
				Transform val2 = sellPanel.transform.Find("BuyButton");
				((Component)val2.Find("Text")).GetComponent<TMP_Text>().SetText(Localization.instance.Localize("$store_sell"));
				((Component)val2).GetComponent<UIGamePad>().m_zinputKey = "JoyButtonX";
				val2.localPosition -= new Vector3(0f, 35f, 0f);
				GameObject val3 = RepairPanel.RepurposeSellButton(__instance);
				Transform transform = val3.transform;
				transform.localPosition -= new Vector3(0f, 35f, 0f);
				sellButton = ((Component)val2).GetComponent<Button>();
				((UnityEventBase)sellButton.onClick).SetPersistentListenerState(0, (UnityEventCallState)0);
				((UnityEvent)sellButton.onClick).AddListener((UnityAction)delegate
				{
					__instance.OnSellItem();
				});
				traderFilter = InitFilterField(__instance.m_rootPanel.transform);
				((UnityEvent<string>)(object)((TMP_InputField)traderFilter).onValueChanged).AddListener((UnityAction<string>)delegate
				{
					__instance.FillList();
				});
				playerFilter = InitFilterField(sellPanel.transform);
				((UnityEvent<string>)(object)((TMP_InputField)playerFilter).onValueChanged).AddListener((UnityAction<string>)delegate
				{
					FillSellableList(__instance);
				});
				UIGamePad component4 = ((Component)sellButton).GetComponent<UIGamePad>();
				Vector3 localPosition = component4.m_hint.transform.localPosition;
				Object.Destroy((Object)(object)component4.m_hint);
				component4.m_hint = Object.Instantiate<GameObject>(((Component)InventoryGui.instance.m_craftButton).GetComponent<UIGamePad>().m_hint, ((Component)sellButton).transform);
				component4.m_hint.transform.localPosition = localPosition;
				((Object)component4.m_hint).name = ((Object)component4.m_hint).name.Replace("(clone)", "");
				((Component)__instance.m_rootPanel.transform.Find("border (1)")).GetComponent<RectTransform>().anchorMax = new Vector2(2f, 1f);
				GameObject val4 = AmountDialog.Init(__instance);
				((Component)__instance.m_rootPanel.transform.Find("BuyButton")).GetComponent<UIGamePad>().m_blockingElements.Add(val4);
				((Component)sellButton).GetComponent<UIGamePad>().m_blockingElements.Add(val4);
				RepairPanel.AddButtonBlocker(val4);
				RectTransform tooltipAnchor = __instance.m_tooltipAnchor;
				tooltipAnchor.anchorMax += new Vector2(1f, 0f);
				TradersExtended.LogInfo("StoreGui panel patched");
				buybackItem = null;
			}
		}

		[HarmonyPatch(typeof(Trader), "GetAvailableItems")]
		public static class Trader_GetAvailableItems_FinalizeItems
		{
			public static bool ItemIsValid(ItemDrop item)
			{
				try
				{
					object obj;
					if (item == null)
					{
						obj = null;
					}
					else
					{
						ItemData itemData = item.m_itemData;
						obj = ((itemData != null) ? itemData.GetIcon() : null);
					}
					return (Object)obj != (Object)null;
				}
				catch
				{
					return false;
				}
			}

			[HarmonyPriority(0)]
			[HarmonyFinalizer]
			public static Exception Finalizer(Exception __exception, Trader __instance, ref List<TradeItem> __result)
			{
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Expected O, but got Unknown
				if (__exception != null)
				{
					return __exception;
				}
				if ((Object)(object)__instance == (Object)null)
				{
					return null;
				}
				if (__result == null)
				{
					__result = new List<TradeItem>();
				}
				ResolvedTraderConfig resolvedTraderConfig = TraderConfigManager.Get(__instance);
				if (resolvedTraderConfig.DisableOtherModsItems)
				{
					__result.Clear();
					if (!resolvedTraderConfig.DisableVanillaItems)
					{
						AddVanillaAvailableItems(__instance, __result);
					}
				}
				else if (resolvedTraderConfig.DisableVanillaItems)
				{
					RemoveVanillaItems(__instance, __result);
				}
				AddAvailableItems(TradersExtended.CommonListKey(TradersExtended.ItemsListType.Buy), __instance, __result);
				AddAvailableItems(TradersExtended.TraderListKey(__instance, TradersExtended.ItemsListType.Buy), __instance, __result);
				ApplyFilterAndFlexiblePrices(__instance, __result);
				buybackItem = BuybackManager.Get(__instance);
				if (buybackItem != null)
				{
					TradeItem val = ItemToSell.SetBuyBackItem(new TradeItem
					{
						m_prefab = null,
						m_stack = 0,
						m_price = buybackItem.price
					});
					TraderCurrency.RegisterCurrency(val, buybackItem.currency, __instance);
					__result.Insert(0, val);
				}
				return null;
			}

			private static void AddVanillaAvailableItems(Trader trader, List<TradeItem> result)
			{
				List<TradeItem> items = trader.m_items;
				if (items == null || items.Count == 0)
				{
					return;
				}
				for (int i = 0; i < items.Count; i++)
				{
					TradeItem val = items[i];
					if (val != null && (string.IsNullOrEmpty(val.m_requiredGlobalKey) || ZoneSystem.instance.GetGlobalKey(val.m_requiredGlobalKey)))
					{
						result.Add(val);
					}
				}
			}

			private static void RemoveVanillaItems(Trader trader, List<TradeItem> result)
			{
				if (result == null || result.Count == 0)
				{
					return;
				}
				List<TradeItem> items = trader.m_items;
				if (items == null || items.Count == 0)
				{
					return;
				}
				if (result.Count == items.Count)
				{
					bool flag = true;
					for (int i = 0; i < result.Count; i++)
					{
						if (result[i] != items[i])
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						result.Clear();
						return;
					}
				}
				HashSet<TradeItem> hashSet = new HashSet<TradeItem>(items);
				int num = 0;
				for (int j = 0; j < result.Count; j++)
				{
					TradeItem val = result[j];
					if (val != null && !hashSet.Contains(val))
					{
						if (num != j)
						{
							result[num] = val;
						}
						num++;
					}
				}
				if (num < result.Count)
				{
					result.RemoveRange(num, result.Count - num);
				}
			}

			private static void ApplyFilterAndFlexiblePrices(Trader trader, List<TradeItem> result)
			{
				if (result == null || result.Count == 0)
				{
					return;
				}
				float priceFactor = TraderCoins.GetPriceFactor(buyPrice: true);
				GuiInputField traderFilter = StorePanel.traderFilter;
				string value = ((traderFilter != null) ? ((TMP_InputField)traderFilter).text : null);
				bool flag = !string.IsNullOrWhiteSpace(value);
				for (int num = result.Count - 1; num >= 0; num--)
				{
					TradeItem val = result[num];
					if (val == null || !ItemIsValid(val.m_prefab))
					{
						result.RemoveAt(num);
						continue;
					}
					if (flag)
					{
						string text = Localization.instance.Localize(val.m_prefab.m_itemData.m_shared.m_name);
						if (text.IndexOf(value, StringComparison.OrdinalIgnoreCase) < 0)
						{
							result.RemoveAt(num);
							continue;
						}
					}
					if (TraderConfigManager.Get(trader).TradersUseFlexiblePricing)
					{
						val = CloneTradeItem(val);
						val.m_price = Math.Max((int)((float)val.m_price * priceFactor), 1);
						TradersExtended.TradeableItem.NormalizeStack(val);
						result[num] = val;
					}
				}
			}

			private static TradeItem CloneTradeItem(TradeItem item)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				TradeItem val = new TradeItem
				{
					m_prefab = item.m_prefab,
					m_stack = item.m_stack,
					m_price = item.m_price,
					m_requiredGlobalKey = item.m_requiredGlobalKey
				};
				TraderCurrency.CopyCurrency(item, val);
				return val;
			}
		}

		[HarmonyPatch(typeof(StoreGui), "UpdateSellButton")]
		public static class StoreGui_UpdateSellButton_Patch
		{
			private static void Postfix(StoreGui __instance)
			{
				UpdateSellButton();
				RepairPanel.Update(__instance);
			}
		}

		[HarmonyPatch(typeof(StoreGui), "Show")]
		public static class StoreGui_Show_Patch
		{
			private static void Prefix(StoreGui __instance, Trader trader)
			{
				TraderCoins.ResetCurrentTrader(trader);
				TraderCurrency.ApplyTraderCurrency(__instance, trader);
				buybackItem = BuybackManager.Get(trader);
			}

			private static void Postfix(StoreGui __instance)
			{
				if (IsOpen())
				{
					TraderCoins.UpdateTraderCoinsVisibility();
					UpdateNames();
					((TMP_InputField)playerFilter).SetTextWithoutNotify("");
					((TMP_InputField)traderFilter).SetTextWithoutNotify("");
					SetStoreGuiPosition();
				}
			}
		}

		[HarmonyPatch(typeof(StoreGui), "Hide")]
		public static class StoreGui_Hide_Patch
		{
			private static bool Prefix(Trader ___m_trader, float ___m_hideDistance)
			{
				//IL_0026: 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)
				if ((Object)(object)___m_trader == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return true;
				}
				if (Vector3.Distance(((Component)___m_trader).transform.position, ((Component)Player.m_localPlayer).transform.position) > ___m_hideDistance)
				{
					return true;
				}
				if (AmountDialog.IsOpen())
				{
					return false;
				}
				return true;
			}

			private static void Postfix()
			{
				if (!IsOpen())
				{
					AmountDialog.Close();
					TraderCoins.UpdateTraderCoins();
					TraderCoins.ResetCurrentTrader(null);
				}
			}
		}

		[HarmonyPatch(typeof(StoreGui), "UpdateRecipeGamepadInput")]
		public static class StoreGui_UpdateRecipeGamepadInput_SellListGamepadNavigation
		{
			private static bool Prefix(StoreGui __instance, List<GameObject> ___m_itemList)
			{
				if (AmountDialog.IsOpen() || Console.IsVisible())
				{
					return false;
				}
				if (ZInput.GetButtonDown("JoyButtonA") && ZInput.GetButton("JoyAltKeys"))
				{
					AmountDialog.Open();
					ZInput.ResetButtonStatus("JoyButtonA");
					return false;
				}
				if (ZInput.GetButtonDown("JoyDPadDown"))
				{
					if (GetSelectedItemIndex() != -1)
					{
						SelectItem(Mathf.Min(sellItemList.Count - 1, GetSelectedItemIndex() + 1), center: true);
					}
					else if (__instance.GetSelectedItemIndex() != -1)
					{
						__instance.SelectItem(Mathf.Min(___m_itemList.Count - 1, __instance.GetSelectedItemIndex() + 1), true);
					}
				}
				if (ZInput.GetButtonDown("JoyDPadUp"))
				{
					if (GetSelectedItemIndex() != -1)
					{
						SelectItem(Mathf.Max(0, GetSelectedItemIndex() - 1), center: true);
					}
					else if (__instance.GetSelectedItemIndex() != -1)
					{
						__instance.SelectItem(Mathf.Max(0, __instance.GetSelectedItemIndex() - 1), true);
					}
				}
				if (___m_itemList.Count > 0)
				{
					if (ZInput.GetButtonDown("JoyLStickDown"))
					{
						__instance.SelectItem(Mathf.Min(___m_itemList.Count - 1, __instance.GetSelectedItemIndex() + 1), true);
					}
					if (ZInput.GetButtonDown("JoyLStickUp"))
					{
						__instance.SelectItem(Mathf.Max(0, __instance.GetSelectedItemIndex() - 1), true);
					}
					if (ZInput.GetButtonDown("JoyDPadLeft") || ZInput.GetButtonDown("JoyRStickLeft"))
					{
						__instance.SelectItem(Mathf.Min(___m_itemList.Count - 1, Math.Max(__instance.GetSelectedItemIndex(), 0)), true);
					}
				}
				if (sellItemList.Count > 0)
				{
					if (ZInput.GetButtonDown("JoyDPadRight") || ZInput.GetButtonDown("JoyRStickRight"))
					{
						SelectItem(Mathf.Min(sellItemList.Count - 1, Math.Max(GetSelectedItemIndex(), 0)), center: true);
					}
					if (ZInput.GetButtonDown("JoyRStickDown"))
					{
						SelectItem(Mathf.Min(sellItemList.Count - 1, GetSelectedItemIndex() + 1), center: true);
					}
					if (ZInput.GetButtonDown("JoyRStickUp"))
					{
						SelectItem(Mathf.Max(0, GetSelectedItemIndex() - 1), center: true);
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(StoreGui), "SellItem")]
		public static class StoreGui_SellItem_SellItemFromSellableList
		{
			private static bool Prefix(StoreGui __instance)
			{
				if (!AmountDialog.IsOpen())
				{
					SellSelectedItem(__instance);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(StoreGui), "GetSelectedItemIndex")]
		public static class StoreGui_GetSelectedItemIndex_GamePadScrollFix
		{
			private static bool Prefix(ref int __result, List<GameObject> ___m_itemList)
			{
				__result = -1;
				for (int i = 0; i < ___m_itemList.Count; i++)
				{
					if (((Component)___m_itemList[i].transform.Find("selected")).gameObject.activeSelf)
					{
						__result = i;
						break;
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Chat), "HasFocus")]
		public static class Chat_HasFocus_ImpersonateChatFocus
		{
			private static void Postfix(ref bool __result)
			{
				if ((Object)(object)playerFilter != (Object)null && (Object)(object)traderFilter != (Object)null && StoreGui.IsVisible())
				{
					__result = __result || ((TMP_InputField)playerFilter).isFocused || ((TMP_InputField)traderFilter).isFocused;
				}
			}
		}

		[HarmonyPatch(typeof(StoreGui), "SelectItem")]
		public static class StoreGui_SelectItem_FixOutOfRangeForEmptyList
		{
			private static void Prefix(StoreGui __instance, ref int index, ref bool center)
			{
				if (index >= 0)
				{
					if (__instance.m_itemList.Count == 0)
					{
						index = -1;
					}
					else
					{
						index = Mathf.Clamp(index, 0, __instance.m_itemList.Count - 1);
					}
				}
				center = center || index == 0;
				if (index >= 0)
				{
					AmountDialog.SetSellState(sellDialog: false);
					SelectItem(-1, center: false);
				}
			}
		}

		[HarmonyPatch(typeof(StoreGui), "FillList")]
		public static class StoreGui_FillList_FillSellableList
		{
			private static readonly List<TradeItem> availableItems = new List<TradeItem>();

			public static bool Prefix(StoreGui __instance)
			{
				//IL_0243: 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_0253: Unknown result type (might be due to invalid IL or missing references)
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				//IL_032a: Unknown result type (might be due to invalid IL or missing references)
				//IL_033e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0335: Unknown result type (might be due to invalid IL or missing references)
				//IL_0414: Unknown result type (might be due to invalid IL or missing references)
				//IL_0428: Unknown result type (might be due to invalid IL or missing references)
				//IL_041f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0482: Unknown result type (might be due to invalid IL or missing references)
				//IL_0488: Unknown result type (might be due to invalid IL or missing references)
				//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0507: Expected O, but got Unknown
				//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_051d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0522: Unknown result type (might be due to invalid IL or missing references)
				//IL_0528: Unknown result type (might be due to invalid IL or missing references)
				//IL_0537: Unknown result type (might be due to invalid IL or missing references)
				//IL_054e: Unknown result type (might be due to invalid IL or missing references)
				TraderCurrency.ApplyTraderCurrency(__instance);
				int selectedItemIndex = __instance.GetSelectedItemIndex();
				availableItems.Clear();
				availableItems.AddRange(__instance.m_trader.GetAvailableItems());
				foreach (GameObject item in __instance.m_itemList)
				{
					Object.Destroy((Object)(object)item);
				}
				__instance.m_itemList.Clear();
				float num = (float)availableItems.Count * __instance.m_itemSpacing;
				num = Mathf.Max(__instance.m_itemlistBaseSize, num);
				__instance.m_listRoot.SetSizeWithCurrentAnchors((Axis)1, num);
				for (int i = 0; i < availableItems.Count; i++)
				{
					TradeItem val = availableItems[i];
					bool flag = ItemToSell.IsBuyBackItem(val);
					ItemData val2 = (flag ? buybackItem.item : val.m_prefab.m_itemData);
					int num2 = (flag ? buybackItem.price : val.m_price);
					TradersExtended.TradeableItem.GetStackQualityFromStack(val.m_stack, out var stack, out var quality);
					if (flag)
					{
						if (buybackItem.itemType == ItemToSell.ItemType.Single)
						{
							stack = val2.m_stack;
							quality = val2.m_quality;
						}
						else if (buybackItem.itemType == ItemToSell.ItemType.Stack)
						{
							stack = buybackItem.stack;
							quality = buybackItem.quality;
						}
						else if (buybackItem.itemType == ItemToSell.ItemType.Combined)
						{
							stack = buybackItem.amount;
							quality = buybackItem.quality;
						}
					}
					GameObject element = Object.Instantiate<GameObject>(__instance.m_listElement, (Transform)(object)__instance.m_listRoot);
					element.SetActive(true);
					Transform transform = element.transform;
					RectTransform val3 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
					Rect rect = __instance.m_listRoot.rect;
					float width = ((Rect)(ref rect)).width;
					rect = val3.rect;
					float num3 = (width - ((Rect)(ref rect)).width) / 2f;
					val3.anchoredPosition = new Vector2(num3, (float)i * (0f - __instance.m_itemSpacing) - num3);
					ItemDrop currency = TraderCurrency.GetCurrency(val, __instance);
					int playerCurrencyAmount = TraderCurrency.GetPlayerCurrencyAmount(val, __instance);
					bool flag2 = num2 <= playerCurrencyAmount;
					Image component = ((Component)element.transform.Find("icon")).GetComponent<Image>();
					component.sprite = val2.GetIcon();
					ResolvedTraderConfig resolvedTraderConfig = TraderConfigManager.Get(__instance.m_trader);
					((Graphic)component).color = (Color)((!flag2) ? new Color(1f, 0f, 1f, 0f) : (flag ? resolvedTraderConfig.BuybackItemHighlightedColor : Color.white));
					bool visible = !val2.m_shared.m_teleportable && ((Object)(object)ZoneSystem.instance == (Object)null || !ZoneSystem.instance.GetGlobalKey((GlobalKeys)30));
					SetNonTeleportableIcon(element, visible);
					string text = Localization.instance.Localize(val2.m_shared.m_name);
					if (quality > 1)
					{
						text += $" <color=#add8e6ff>({quality})</color>";
					}
					if (stack > 1)
					{
						text = text + " x" + stack;
					}
					TMP_Text component2 = ((Component)element.transform.Find("name")).GetComponent<TMP_Text>();
					component2.text = text;
					((Graphic)component2).color = ((!flag2) ? Color.grey : (flag ? resolvedTraderConfig.BuybackItemFontColor : Color.white));
					string tooltip = ItemData.GetTooltip(val2, (quality == 0) ? val2.m_quality : quality, false, (float)val2.m_worldLevel, -1);
					element.GetComponent<UITooltip>().Set(val2.m_shared.m_name, tooltip, __instance.m_tooltipAnchor, default(Vector2));
					SetCurrencyIcon(element, currency);
					TMP_Text component3 = ((Component)Utils.FindChild(element.transform, "price", (IterativeSearchType)0)).GetComponent<TMP_Text>();
					component3.text = num2.ToString();
					if (!flag2)
					{
						((Graphic)component3).color = Color.grey;
					}
					((UnityEvent)element.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						__instance.OnSelectedItem(element);
					});
					if (flag)
					{
						ColorBlock colors = ((Selectable)element.GetComponent<Button>()).colors;
						((ColorBlock)(ref colors)).normalColor = resolvedTraderConfig.BuybackItemBackgroundColor;
						((ColorBlock)(ref colors)).highlightedColor = resolvedTraderConfig.BuybackItemHighlightedColor;
						((Selectable)element.GetComponent<Button>()).colors = colors;
					}
					__instance.m_itemList.Add(element);
				}
				FillSellableList(__instance);
				__instance.SelectItem(Mathf.Clamp(selectedItemIndex, 0, __instance.m_itemList.Count - 1), false);
				return false;
			}
		}

		[HarmonyPatch(typeof(StoreGui), "CanAfford")]
		public static class StoreGui_CanAfford_CustomCurrency
		{
			private static bool Prefix(StoreGui __instance, TradeItem item, ref bool __result)
			{
				if (item == null || TraderCurrency.UsesStoreCurrency(item, __instance))
				{
					return true;
				}
				__result = TraderCurrency.GetPlayerCurrencyAmount(item, __instance) >= item.m_price;
				return false;
			}
		}

		[HarmonyPatch(typeof(StoreGui), "BuySelectedItem")]
		public static class StoreGui_BuySelectedItem_TraderCoinsUpdate
		{
			private sealed class PurchaseState
			{
				internal ItemDrop OriginalCurrency;

				internal TradeItem TradeItem;

				internal int OriginalStack;

				internal int OriginalQuality;

				internal IDisposable BalanceTransaction;
			}

			public static bool isCalled;

			[HarmonyPriority(800)]
			private static bool Prefix(StoreGui __instance, ref PurchaseState __state)
			{
				isCalled = true;
				TradeItem selectedItem = __instance.m_selectedItem;
				if (selectedItem == null)
				{
					return true;
				}
				__state = new PurchaseState
				{
					OriginalCurrency = __instance.m_coinPrefab,
					TradeItem = selectedItem,
					OriginalStack = selectedItem.m_stack,
					OriginalQuality = (((Object)(object)selectedItem.m_prefab != (Object)null) ? selectedItem.m_prefab.m_itemData.m_quality : 0),
					BalanceTransaction = TraderCoins.BeginBalanceTransaction(TraderCoins.BalanceOperation.Spend)
				};
				ItemDrop currency = TraderCurrency.GetCurrency(selectedItem, __instance);
				if ((Object)(object)currency != (Object)null)
				{
					__instance.m_coinPrefab = currency;
				}
				if (!__instance.CanAfford(selectedItem))
				{
					return true;
				}
				if (ItemToSell.IsBuyBackItem(selectedItem))
				{
					BuyBackItem(__instance);
					return false;
				}
				if ((Object)(object)selectedItem.m_prefab != (Object)null)
				{
					TradersExtended.TradeableItem.GetStackQualityFromStack(selectedItem.m_stack, out var stack, out var quality);
					if (quality != 0)
					{
						selectedItem.m_stack = stack;
						selectedItem.m_prefab.m_itemData.m_quality = quality;
					}
				}
				return true;
			}

			private static void Restore(StoreGui storeGui, PurchaseState state)
			{
				isCalled = false;
				if (state == null)
				{
					return;
				}
				state.BalanceTransaction?.Dispose();
				state.BalanceTransaction = null;
				if ((Object)(object)storeGui != (Object)null && (Object)(object)state.OriginalCurrency != (Object)null)
				{
					storeGui.m_coinPrefab = state.OriginalCurrency;
				}
				if (state.TradeItem != null)
				{
					state.TradeItem.m_stack = state.OriginalStack;
					if ((Object)(object)state.TradeItem.m_prefab != (Object)null)
					{
						state.TradeItem.m_prefab.m_itemData.m_quality = state.OriginalQuality;
					}
				}
			}

			[HarmonyPriority(800)]
			private static void Postfix(StoreGui __instance, PurchaseState __state)
			{
				Restore(__instance, __state);
			}

			private static Exception Finalizer(StoreGui __instance, PurchaseState __state, Exception __exception)
			{
				Restore(__instance, __state);
				return __exception;
			}
		}

		[HarmonyPatch(typeof(Character), "ShowPickupMessage")]
		public static class Character_ShowPickupMessage_FixIncorrectStackMessage
		{
			private static void Prefix(ItemData item, ref int amount)
			{
				if ((Object)(object)StoreGui.instance != (Object)null && StoreGui_BuySelectedItem_TraderCoinsUpdate.isCalled && StoreGui.instance.m_selectedItem != null && item == StoreGui.instance.m_selectedItem.m_prefab?.m_itemData)
				{
					amount = StoreGui.instance.m_selectedItem.m_stack;
				}
			}
		}

		private const float positionDelta = 35f;

		private const string nonTeleportableIconName = "TradersExtended_NonTeleportable";

		private static GameObject sellPanel;

		private static Button sellButton;

		private static TMP_Text storeName;

		private static TMP_Text playerName;

		private static ScrollRectEnsureVisible itemEnsureVisible;

		private static RectTransform listRoot;

		private static GameObject listElement;

		private static RectTransform tooltipAnchor;

		private static GuiInputField traderFilter;

		private static GuiInputField playerFilter;

		internal static readonly List<GameObject> sellItemList = new List<GameObject>();

		internal static readonly List<ItemToSell> tempItems = new List<ItemToSell>();

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

		internal static ItemToSell selectedItem;

		private static int selectedItemIndex = -1;

		private static ItemToSell buybackItem;

		private static Vector3 defaultStorePosition;

		public static bool AdventureModeEnabled(Trader trader)
		{
			return (Object)(object)trader != (Object)null && TraderConfigManager.Get(trader).ShiftStoreGuiForEpicLoot && EpicLootCompat.IsAdventureModeEnabled();
		}

		public static bool IsOpen()
		{
			return (Object)(object)sellPanel != (Object)null && sellPanel.gameObject.activeInHierarchy;
		}

		public static void OnSelectedItem(GameObject button)
		{
			int index = FindSelectedRecipe(button);
			SelectItem(index, center: false);
			AmountDialog.OnSelectedTradeableItemClick(sellDialog: true);
		}

		public static int FindSelectedRecipe(GameObject button)
		{
			for (int i = 0; i < sellItemList.Count; i++)
			{
				if ((Object)(object)sellItemList[i] == (Object)(object)button)
				{
					return i;
				}
			}
			return -1;
		}

		public static int GetSelectedItemIndex()
		{
			int result = -1;
			for (int i = 0; i < tempItems.Count; i++)
			{
				if (tempItems[i] == selectedItem)
				{
					result = i;
				}
			}
			return result;
		}

		public static void SelectItem(int index, bool center)
		{
			if (sellItemList.Count == 0 || index >= sellItemList.Count)
			{
				index = -1;
			}
			center = center || index == 0;
			for (int i = 0; i < sellItemList.Count; i++)
			{
				GameObject obj = sellItemList[i];
				if (obj != null)
				{
					Transform obj2 = obj.transform.Find("selected");
					if (obj2 != null)
					{
						((Component)obj2).gameObject.SetActive(i == index);
					}
				}
			}
			if (center && index >= 0 && (Object)(object)sellItemList[index] != (Object)null)
			{
				ScrollRectEnsureVisible obj3 = itemEnsureVisible;
				if (obj3 != null)
				{
					? val = obj3;
					Transform transform = sellItemList[index].transform;
					((ScrollRectEnsureVisible)val).CenterOnItem((RectTransform)(object)((transform is RectTransform) ? transform : null));
				}
			}
			selectedItem = ((index < 0) ? null : tempItems[index]);
			if (index >= 0)
			{
				AmountDialog.SetSellState(sellDialog: true);
				StoreGui.instance.SelectItem(-1, false);
			}
		}

		public static void SellSelectedItem(StoreGui storeGui)
		{
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			if (selectedItem == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			ItemDrop val = selectedItem.currency ?? storeGui?.m_coinPrefab;
			if ((Object)(object)val == (Object)null)
			{
				TradersExtended.logger.LogWarning((object)"No currency prefab is available for the selected sell item");
				return;
			}
			selectedItemIndex = GetSelectedItemIndex();
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			int num = ((selectedItem.quality == 0) ? (-1) : selectedItem.quality);
			int num2 = ((selectedItem.itemType == ItemToSell.ItemType.Stack) ? selectedItem.stack : ((selectedItem.itemType == ItemToSell.ItemType.Combined) ? selectedItem.amount : selectedItem.item.m_stack));
			if (!((selectedItem.itemType == ItemToSell.ItemType.Single) ? inventory.ContainsItem(selectedItem.item) : (inventory.CountItems(selectedItem.item.m_shared.m_name, num, true) >= num2)))
			{
				storeGui.FillList();
				return;
			}
			ItemToSell itemToSell = (TraderConfigManager.Get(storeGui.m_trader).EnableBuybackForLastItemSold ? selectedItem.Clone() : null);
			ItemDrop coinPrefab = storeGui.m_coinPrefab;
			storeGui.m_coinPrefab = val;
			try
			{
				using (TraderCoins.BeginBalanceTransaction(TraderCoins.BalanceOperation.Receive))
				{
					if (selectedItem.itemType == ItemToSell.ItemType.Single)
					{
						if (!inventory.RemoveItem(selectedItem.item))
						{
							return;
						}
					}
					else
					{
						inventory.RemoveItem(selectedItem.item.m_shared.m_name, num2, num, true);
					}
					if (itemToSell != null)
					{
						buybackItem = itemToSell;
						BuybackManager.Set(storeGui.m_trader, itemToSell);
					}
					int num3 = inventory.CountItems(val.m_itemData.m_shared.m_name, -1, true);
					if (inventory.AddItem(((Object)((Component)val).gameObject).name, selectedItem.price, val.m_itemData.m_quality, val.m_itemData.m_variant, 0L, "", false) == null)
					{
						int num4 = selectedItem.price + num3 - inventory.CountItems(val.m_itemData.m_shared.m_name, -1, true);
						int num5 = Math.Max(val.m_itemData.m_shared.m_maxStackSize, 1);
						int num6 = Mathf.CeilToInt((float)num4 / (float)num5);
						GameObject val2 = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(((Object)((Component)val).gameObject).name) : null);
						if ((Object)(object)val2 == (Object)null)
						{
							val2 = ((Component)val).gameObject;
						}
						if ((Object)(object)val2 != (Object)null && num4 > 0)
						{
							TraderCoins.UpdateTraderCoins(-num4);
							string currencyName = TraderCurrency.GetCurrencyName(val);
							((Character)Player.m_localPlayer).Message((MessageType)1, $"$msg_dropped: {currencyName} x{num4}", 0, (Sprite)null);
							while (num4 > 0)
							{
								Vector3 val3 = Random.insideUnitSphere * ((num6 == 1) ? 0f : 0.5f);
								GameObject val4 = Object.Instantiate<GameObject>(val2, ((Component)Player.m_localPlayer).transform.position + ((Component)Player.m_localPlayer).transform.forward * 2f + Vector3.up + val3, Quaternion.identity);
								ItemDrop component = val4.GetComponent<ItemDrop>();
								component.m_itemData.m_stack = Mathf.Min(num4, num5);
								num4 -= component.m_itemData.m_stack;
							}
						}
					}
					string text = ((num2 <= 1) ? selectedItem.item.m_shared.m_name : $"{num2}x{selectedItem.item.m_shared.m_name}");
					storeGui.m_sellEffects.Create(((Component)storeGui).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
					string text2 = Localization.instance.Localize("$msg_sold", new string[2]
					{
						text,
						selectedItem.price.ToString()
					});
					if (val.m_itemData.m_shared.m_name != "$item_coins")
					{
						text2 = $"{Localization.instance.Localize(text)}: {selectedItem.price} {TraderCurrency.GetCurrencyName(val)}";
					}
					((Character)Player.m_localPlayer).Message((MessageType)1, text2, 0, selectedItem.item.GetIcon());
					storeGui.m_trader.OnSold();
					Gogan.LogEvent("Game", "SoldItem", text, 0L);
				}
			}
			finally
			{
				storeGui.m_coinPrefab = coinPrefab;
			}
			storeGui.FillList();
		}

		private static void AddItemToSellList(TradersExtended.TradeableItem item)
		{
			if (item != null && item.price > 0 && item.stack > 0 && item.RequirementsMet() && TryGetPriceKey(item, out var key))
			{
				if (!tempItemsPrice.ContainsKey(key))
				{
					tempItemsPrice[key] = new Dictionary<int, SellPrice>();
				}
				tempItemsPrice[key][item.stack] = new SellPrice
				{
					Price = item.price,
					CurrencyPrefab = item.currency
				};
			}
		}

		private static bool TryGetPriceKey(TradersExtended.TradeableItem item, out string key)
		{
			key = "";
			if (item == null || (Object)(object)ObjectDB.instance == (Object)null || string.IsNullOrWhiteSpace(item.prefab))
			{
				return false;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item.prefab);
			ItemDrop val = default(ItemDrop);
			if ((Object)(object)itemPrefab == (Object)null || !itemPrefab.TryGetComponent<ItemDrop>(ref val))
			{
				return false;
			}
			ItemData itemData = val.m_itemData;
			if (itemData.m_shared.m_maxStackSize == 1 && item.stack != 1)
			{
				return false;
			}
			key = GetPriceKey(itemData, item.quality);
			return true;
		}

		private static string GetPriceKey(ItemData itemData, int quality)
		{
			return (quality > 0) ? (itemData.m_shared.m_name + "-" + quality) : itemData.m_shared.m_name;
		}

		private static bool IgnoreItemForSell(ItemData item, Trader trader)
		{
			if (!string.IsNullOrWhiteSpace(((TMP_InputField)playerFilter).text) && Localization.instance.Localize(item.m_shared.m_name).IndexOf(((TMP_InputField)playerFilter).text, StringComparison.OrdinalIgnoreCase) < 0)
			{
				return true;
			}
			if (!TraderConfigManager.Get(trader).HideEquippedAndHotbarItems)
			{
				return false;
			}
			if (item.m_equipped)
			{
				return true;
			}
			if (item.m_gridPos.y == 0 && item.IsEquipable())
			{
				return true;
			}
			if ((from func in AzuExtendedPlayerInventory.API.GetSlots().GetItemFuncs
				where func != null
				select func(Player.m_localPlayer)).Contains(item))
			{
				return true;
			}
			if (ExtraSlots.API.GetAllExtraSlotsItems().Contains(item))
			{
				return true;
			}
			return false;
		}

		private static Dictionary<int, SellPrice> GetStackPrices(ItemData item, out int quality)
		{
			quality = item.m_quality;
			string priceKey = GetPriceKey(item, quality);
			if (tempItemsPrice.ContainsKey(priceKey))
			{
				return tempItemsPrice[priceKey];
			}
			quality = 0;
			priceKey = GetPriceKey(item, quality);
			if (tempItemsPrice.ContainsKey(priceKey))
			{
				return tempItemsPrice[priceKey];
			}
			return null;
		}

		internal static int CalculateSellPrice(int basePrice, int amount)
		{
			return CalculateSellPrice(basePrice, amount, TraderCoins.GetPriceFactor(buyPrice: false));
		}

		private static int CalculateSellPrice(int basePrice, int amount, float priceFactor)
		{
			if (basePrice <= 0 || amount <= 0)
			{
				return 0;
			}
			double num = (double)basePrice * (double)amount * (double)priceFactor;
			if (double.IsNaN(num) || num >= 2147483647.0)
			{
				return int.MaxValue;
			}
			return Math.Max((int)Math.Ceiling(num), 1);
		}

		private static void AddToSellList(ItemData item, int itemStack, int itemPrice, float priceFactor, int configuredQuality, ItemToSell.ItemType itemType, ItemDrop currency)
		{
			int effectiveQuality = ((configuredQuality > 0) ? configuredQuality : item.m_quality);
			float qualityMultiplier = TraderConfigManager.Get(StoreGui.instance?.m_trader).QualityMultiplier;
			if (itemType != ItemToSell.ItemType.Stack && qualityMultiplier != 0f && configuredQuality == 0 && item.m_quality > 1)
			{
				itemPrice += (int)(qualityMultiplier * (float)itemPrice * (float)(item.m_quality - 1));
			}
			int price = CalculateSellPrice(itemPrice, (itemType != ItemToSell.ItemType.Combined) ? 1 : itemStack, priceFactor);
			if (itemType == ItemToSell.ItemType.Single)
			{
				tempItems.Add(new ItemToSell
				{
					itemType = itemType,
					item = item,
					stack = itemStack,
					price = price,
					quality = effectiveQuality,
					currency = currency
				});
			}
			else if (itemType == ItemToSell.ItemType.Stack)
			{
				ItemToSell itemToSell = tempItems.Find((ItemToSell tmpItem) => tmpItem.itemType == itemType && tmpItem.stack == itemStack && tmpItem.item.m_shared.m_name == item.m_shared.m_name && tmpItem.quality == effectiveQuality && tmpItem.price == price && SameCurrency(tmpItem.currency, currency));
				if (itemToSell != null)
				{
					itemToSell.amount += item.m_stack;
					return;
				}
				tempItems.Add(new ItemToSell
				{
					itemType = itemType,
					item = item,
					stack = itemStack,
					price = price,
					amount = item.m_stack,
					quality = effectiveQuality,
					currency = currency
				});
			}
			else if (itemType == ItemToSell.ItemType.Combined)
			{
				ItemToSell itemToSell2 = tempItems.Find((ItemToSell tmpItem) => tmpItem.itemType == itemType && tmpItem.item.m_shared.m_name == item.m_shared.m_name && tmpItem.quality == effectiveQuality && tmpItem.stack == 1 && tmpItem.pricePerItem == itemPrice && SameCurrency(tmpItem.currency, currency));
				if (itemToSell2 != null)
				{
					itemToSell2.amount += itemStack;
					itemToSell2.price = CalculateSellPrice(itemToSell2.pricePerItem, itemToSell2.amount, priceFactor);
					return;
				}
				tempItems.Add(new ItemToSell
				{
					itemType = itemType,
					item = item,
					stack = 1,
					price = price,
					amount = itemStack,
					quality = effectiveQuality,
					pricePerItem = itemPrice,
					currency = currency
				});
			}
		}

		private static bool SameCurrency(ItemDrop first, ItemDrop second)
		{
			if (first == second)
			{
				return true;
			}
			if ((Object)(object)first == (Object)null || (Object)(object)second == (Object)null)
			{
				return false;
			}
			return string.Equals(first.m_itemData.m_shared.m_name, second.m_itemData.m_shared.m_name, StringComparison.Ordinal);
		}

		public static void FillSellableList(StoreGui __instance)
		{
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_052a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Expected O, but got Unknown
			//IL_059e: Unknown result type (might be due to invalid IL or missing references)
			foreach (GameObject sellItem in sellItemList)
			{
				Object.Destroy((Object)(object)sellItem);
			}
			sellItemList.Clear();
			tempItems.Clear();
			tempItemsPrice.Clear();
			if (TradersExtended.sellableItems.TryGetValue(TradersExtended.CommonListKey(TradersExtended.ItemsListType.Sell), out var value))
			{
				bool flag = TraderConfigManager.IsAutomaticCommonItemEnabled(__instance.m_trader);
				foreach (TradersExtended.TradeableItem item in value)
				{
					if (!item.automatic || flag)
					{
						AddItemToSellList(item);
					}
				}
			}
			if (TradersExtended.sellableItems.ContainsKey(TradersExtended.TraderListKey(__instance.m_trader, TradersExtended.ItemsListType.Sell)))
			{
				TradersExtended.sellableItems[TradersExtended.TraderListKey(__instance.m_trader, TradersExtended.ItemsListType.Sell)].ForEach(delegate(TradersExtended.TradeableItem item)
				{
					AddItemToSellList(item);
				});
			}
			float priceFactor = TraderCoins.GetPriceFactor(buyPrice: false);
			foreach (ItemData item2 in ((Humanoid)Player.m_localPlayer).GetInventory().GetAllItemsSortedByName())
			{
				if (IgnoreItemForSell(item2, __instance.m_trader))
				{
					continue;
				}
				int quality;
				Dictionary<int, SellPrice> stackPrices = GetStackPrices(item2, out quality);
				if (stackPrices == null)
				{
					continue;
				}
				foreach (int item3 in stackPrices.Keys.OrderBy((int x) => x))
				{
					SellPrice sellPrice = stackPrices[item3];
					ItemDrop currency = TraderCurrency.GetCurrency(sellPrice.CurrencyPrefab, __instance);
					if ((Object)(object)currency == (Object)null || string.Equals(item2.m_shared.m_name, currency.m_itemData.m_shared.m_name, StringComparison.Ordinal))
					{
						continue;
					}
					if (item3 == 1)
					{
						if (item2.m_shared.m_maxStackSize == 1)
						{
							AddToSellList(item2, 1, sellPrice.Price, priceFactor, quality, ItemToSell.ItemType.Single, currency);
						}
						else
						{
							AddToSellList(item2, item2.m_stack, sellPrice.Price, priceFactor, quality, ItemToSell.ItemType.Combined, currency);
						}
					}
					else
					{
						AddToSellList(item2, item3, sellPrice.Price, priceFactor, quality, ItemToSell.ItemType.Stack, currency);
					}
				}
			}
			tempItems.RemoveAll((ItemToSell x) => x.amount != 0 && x.amount < x.stack);
			float num = (float)tempItems.Count * __instance.m_itemSpacing;
			num = Mathf.Max(__instance.m_itemlistBaseSize, num);
			listRoot.SetSizeWithCurrentAnchors((Axis)1, num);
			for (int num2 = 0; num2 < tempItems.Count; num2++)
			{
				ItemToSell itemToSell = tempItems[num2];
				GameObject element = Object.Instantiate<GameObject>(listElement, (Transform)(object)listRoot);
				element.SetActive(true);
				Transform transform = element.transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				Rect rect = __instance.m_listRoot.rect;
				float width = ((Rect)(ref rect)).width;
				rect = val.rect;
				float num3 = (width - ((Rect)(ref rect)).width) / 2f;
				val.anchoredPosition = new Vector2(num3, (float)num2 * (0f - __instance.m_itemSpacing) - num3);
				bool flag2 = TraderCoins.CanSell(itemToSell.price);
				Image component = ((Component)element.transform.Find("icon")).GetComponent<Image>();
				component.sprite = itemToSell.item.GetIcon();
				((Graphic)component).color = (Color)(flag2 ? Color.white : new Color(1f, 0f, 1f, 0f));
				string text = Localization.instance.Localize(itemToSell.item.m_shared.m_name);
				if (itemToSell.quality > 1)
				{
					text += $" <color=#add8e6ff>({itemToSell.quality})</color>";
				}
				if (itemToSell.stack > 1)
				{
					text = text + " x" + itemToSell.stack;
				}
				if (itemToSell.amount > itemToSell.stack)
				{
					text += $" <color=#c0c0c0ff>({itemToSell.amount})</color>";
				}
				TMP_Text component2 = ((Component)element.transform.Find("name")).GetComponent<TMP_Text>();
				component2.SetText(text);
				element.GetComponent<UITooltip>().Set(itemToSell.item.m_shared.m_name, itemToSell.item.GetTooltip(-1), tooltipAnchor, default(Vector2));
				SetCurrencyIcon(element, itemToSell.currency ?? __instance.m_coinPrefab);
				TMP_Text component3 = ((Component)element.transform.Find("coin_bkg").Find("price")).GetComponent<TMP_Text>();
				component3.SetText(itemToSell.price.ToString());
				if (!flag2)
				{
					((Graphic)component3).color = Color.grey;
				}
				((UnityEvent)element.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					OnSelectedItem(element);
				});
				sellItemList.Add(element);
			}
			if (selectedItemIndex == -1)
			{
				selectedItemIndex = GetSelectedItemIndex();
			}
			SelectItem(Mathf.Min(tempItems.Count - 1, selectedItemIndex), center: false);
		}

		public static void UpdateSellButton()
		{
			((Selectable)sellButton).interactable = selectedItem != null && TraderCoins.CanSell(selectedItem.price);
		}

		public static bool BuyBackItem(StoreGui store)
		{
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			if (!ItemToSell.IsBuyBackItem(store.m_selectedItem))
			{
				return false;
			}
			buybackItem = BuybackManager.Get(store.m_trader);
			if (buybackItem == null)
			{
				store.m_selectedItem = null;
				store.FillList();
				return false;
			}
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			bool flag;
			if (buybackItem.itemType == ItemToSell.ItemType.Single)
			{
				if (!inventory.CanAddItem(buybackItem.item, buybackItem.item.m_stack))
				{
					return false;
				}
				flag = inventory.AddItem(buybackItem.item);
			}
			else
			{
				int variant = buybackItem.item.m_variant;
				int num = ((buybackItem.quality == 0) ? buybackItem.item.m_quality : buybackItem.quality);
				int num2 = ((buybackItem.itemType == ItemToSell.ItemType.Stack) ? buybackItem.stack : buybackItem.amount);
				if ((Object)(object)buybackItem.item.m_dropPrefab == (Object)null || !inventory.CanAddItem(buybackItem.item, num2))
				{
					return false;
				}
				flag = inventory.AddItem(((Object)buybackItem.item.m_dropPrefab).name, num2, num, variant, buybackItem.item.m_crafterID, buybackItem.item.m_crafterName, buybackItem.item.m_pickedUp) != null;
			}
			if (flag)
			{
				buybackItem = null;
				BuybackManager.Remove(store.m_trader);
				((Humanoid)Player.m_localPlayer).GetInventory().RemoveItem(StoreGui.instance.m_coinPrefab.m_itemData.m_shared.m_name, store.m_selectedItem.m_price, -1, true);
				store.m_selectedItem = null;
				StoreGui.instance.m_buyEffects.Create(((Component)StoreGui.instance).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
				StoreGui.instance.FillList();
			}
			return flag;
		}

		internal static void UpdateCurrencyVisuals(StoreGui storeGui)
		{
			if (!((Object)(object)storeGui == (Object)null) && !((Object)(object)storeGui.m_coinPrefab == (Object)null))
			{
				SetCurrencyIcon(storeGui.m_rootPanel, storeGui.m_coinPrefab);
				SetCurrencyIcon(sellPanel, storeGui.m_coinPrefab);
				AmountDialog.UpdateCurrencyIcon(storeGui.m_coinPrefab);
			}
		}

		private static void SetCurrencyIcon(GameObject root, ItemDrop currency)
		{
			if ((Object)(object)root == (Object)null || (Object)(object)currency == (Object)null)
			{
				return;
			}
			Image[] componentsInChildren = root.GetComponentsInChildren<Image>(true);
			Image[] array = componentsInChildren;
			foreach (Image val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name = ((Object)((Component)val).gameObject).name;
					if (name.IndexOf("coin", StringComparison.OrdinalIgnoreCase) >= 0 && name.IndexOf("bkg", StringComparison.OrdinalIgnoreCase) < 0)
					{
						val.sprite = currency.m_itemData.GetIcon();
					}
				}
			}
		}

		private static void InitializeNonTeleportableIcon(GameObject itemTemplate)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)itemTemplate == (Object)null || (Object)(object)itemTemplate.transform.Find("TradersExtended_NonTeleportable") != (Object)null || (Object)(object)InventoryGui.instance == (Object)null)
			{
				return;
			}
			GameObject val = InventoryGui.instance.m_playerGrid?.m_elementPrefab;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform val2 = val.transform.Find("noteleport") ?? ((IEnumerable<Transform>)val.GetComponentsInChildren<Transform>(true)).FirstOrDefault((Func<Transform, bool>)((Transform child) => (Object)(object)child != (Object)null && ((Object)child).name.IndexOf("teleport", StringComparison.OrdinalIgnoreCase) >= 0));
			if (!((Object)(object)val2 == (Object)null))
			{
				GameObject val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject, itemTemplate.transform);
				((Object)val3).name = "TradersExtended_NonTeleportable";
				val3.SetActive(true);
				RectTransform component = val3.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.anchorMin = new Vector2(0f, 1f);
					component.anchorMax = new Vector2(0f, 1f);
					component.pivot = new Vector2(0f, 1f);
					component.anchoredPosition = new Vector2(4f, -4f);
					((Transform)component).localScale = Vector3.one;
				}
				Image component2 = val3.GetComponent<Image>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Behaviour)component2).enabled = false;
					((Graphic)component2).raycastTarget = false;
				}
				else
				{
					val3.SetActive(false);
				}
			}
		}

		private static void SetNonTeleportableIcon(GameObject element, bool visible)
		{
			Transform val = (((Object)(object)element != (Object)null) ? element.transform.Find("TradersExtended_NonTeleportable") : null);
			if (!((Object)(object)val == (Object)null))
			{
				Image component = ((Component)val).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Component)val).gameObject.SetActive(true);
					((Behaviour)component).enabled = visible;
				}
				else
				{
					((Component)val).gameObject.SetActive(visible);
				}
			}
		}

		public static void SetStoreGuiPosition()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_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_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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_00ea: 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 (!((Object)(object)StoreGui.instance == (Object)null) && !((Object)(object)StoreGui.instance.m_rootPanel == (Object)null))
			{
				if (defaultStorePosition == Vector3.zero)
				{
					defaultStorePosition = StoreGui.instance.m_rootPanel.transform.localPosition;
				}
				Vector2 fixedStoreGuiPosition = TraderConfigManager.Get(StoreGui.instance.m_trader).FixedStoreGuiPosition;
				if (fixedStoreGuiPosition != Vector2.zero)
				{
					StoreGui.instance.m_rootPanel.transform.localPosition = Vector2.op_Implicit(fixedStoreGuiPosition);
				}
				else
				{
					StoreGui.instance.m_rootPanel.transform.localPosition = (AdventureModeEnabled(StoreGui.instance.m_trader) ? (defaultStorePosition - new Vector3(RepairPanel.TraderCanRepair(StoreGui.instance.m_trader) ? 146f : 100f, 0f, 0f)) : defaultStorePosition);
				}
			}
		}

		private static void AddAvailableItems(string listKey, Trader trader, List<TradeItem> result)
		{
			if (!TradersExtended.tradeableItems.TryGetValue(listKey, out var value))
			{
				return;
			}
			foreach (TradersExtended.TradeableItem item in value)
			{
				if (item.IsItemToSell(trader))
				{
					TradeItem val = item.ToTradeItem();
					if (val != null)
					{
						TraderCurrency.RegisterCurrency(val, item.currency, trader);
						result.Add(val);
					}
				}
			}
		}

		public static void UpdateNames()
		{
			Trader trader = StoreGui.instance.m_trader;
			string text = ((trader != null) ? trader.GetHoverName() : null);
			string text2 = Player.m_localPlayer.GetPlayerName();
			ResolvedTraderConfig resolvedTraderConfig = TraderConfigManager.Get(StoreGui.instance.m_trader);
			if (resolvedTraderConfig.TradersUseCoins && resolvedTraderConfig.TradersUseFlexiblePricing)
			{
				text += GetPriceFactorString(TraderCoins.GetPriceFactor(buyPrice: true), reversed: true);
				text2 += GetPriceFactorString(TraderCoins.GetPriceFactor(buyPrice: false));
			}
			storeName.SetText(text);
			playerName.SetText(text2);
			static string GetPriceFactorString(float factor, bool reversed = false)
			{
				if (factor == 1f)
				{
					return "";
				}
				return string.Format(" · <color=#{0}>{1:+0;-0}</color>%", ((reversed && factor < 1f) || (!reversed && factor > 1f)) ? "80ff80fc" : "ff6464fc", (factor - 1f) * 100f);
			}
		}
	}
	internal static class RepairPanel
	{
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		public static class ObjectDB_Awake_GetRepairEffect
		{
			[HarmonyPriority(0)]
			private static void Postfix(List<Recipe> ___m_recipes)
			{
				if (___m_recipes == null)
				{
					return;
				}
				foreach (Recipe ___m_recipe in ___m_recipes)
				{
					CraftingStation craftingStation = ___m_recipe.m_craftingStation;
					if (((craftingStation != null) ? ((Object)craftingStation).name : null) == "piece_workbench" && ___m_recipe.m_craftingStation.m_repairItemDoneEffects != null)
					{
						repairItemDoneEffects = ___m_recipe.m_craftingStation.m_repairItemDoneEffects;
						break;
					}
				}
			}
		}

		private const string s_stationEffectName = "piece_workbench";

		private static GameObject repairPanel;

		private static Button repairButton;

		private static EffectList repairItemDoneEffects;

		public static GameObject RepurposeSellButton(StoreGui storeGui)
		{
			//IL_004b: 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_00a1: Expected O, but got Unknown
			//IL_00c2: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			repairPanel = ((Component)storeGui.m_rootPanel.transform.Find("SellPanel")).gameObject;
			repairPanel.transform.localPosition = new Vector3(592f, -603f, 0f);
			repairButton = ((Component)repairPanel.transform.Find("SellButton")).GetComponent<Button>();
			((UnityEventBase)repairButton.onClick).SetPersistentListenerState(0, (UnityEventCallState)0);
			((UnityEvent)repairButton.onClick).AddListener((UnityAction)delegate
			{
				OnRepairPressed(storeGui);
			});
			ButtonImageColor component = ((Component)repairButton).GetComponent<ButtonImageColor>();
			component.m_defaultColor = new Color(0f, 0f, 0f, 0.85f);
			component.m_disabledColor = new Color(0f, 0f, 0f, 0.5f);
			Image component2 = ((Component)((Component)repairButton).transform.Find("Image")).GetComponent<Image>();
			component2.overrideSprite = ((Component)((Component)InventoryGui.instance.m_repairButton).transform.Find("Image")).GetComponent<Image>().sprite;
			((Component)component2).transform.localScale = Vector3.one * 0.85f;
			((Component)component2).transform.localPosition = new Vector3(1f, -1.5f, 0f);
			((Component)repairButton).GetComponent<UITooltip>().Set("", "$inventory_repairbutton", (RectTransform)null, default(Vector2));
			Update(storeGui);
			return repairPanel;
		}

		public static void AddButtonBlocker(GameObject blocker)
		{
			((Component)repairButton).GetComponent<UIGamePad>().m_blockingElements.Add(blocker);
		}

		public static bool TraderCanRepair(Trader trader)
		{
			ResolvedTraderConfig resolvedTraderConfig = TraderConfigManager.Get(trader);
			return resolvedTraderConfig.CanRepairWeapons || resolvedTraderConfig.CanRepairArmor;
		}

		public static void Update(StoreGui storeGui)
		{
			if (!((Object)(object)StoreGui.instance == (Object)null) && StorePanel.IsOpen() && !((Object)(object)repairPanel == (Object)null) && !((Object)(object)repairButton == (Object)null))
			{
				repairPanel.SetActive(TraderCanRepair(storeGui.m_trader));
				((Selectable)repairButton).interactable = HaveRepairableItems(storeGui);
			}
		}

		public static void OnRepairPressed(StoreGui storeGui)
		{
			RepairOneItem(storeGui);
			Update(storeGui);
		}

		public static void RepairOneItem(StoreGui storeGui)
		{
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: 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_0195: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			ItemData itemToRepair = GetItemToRepair(storeGui);
			ResolvedTraderConfig resolvedTraderConfig = TraderConfigManager.Get(storeGui.m_trader);
			int tradersRepairCost = resolvedTraderConfig.TradersRepairCost;
			int num = ((tradersRepairCost == int.MinValue) ? int.MaxValue : Math.Abs(tradersRepairCost));
			ItemDrop currency = TraderCurrency.GetCurrency(resolvedTraderConfig.RepairCurrencyPrefab, storeGui);
			int num2 = ((!((Object)(object)currency == (Object)null)) ? ((Humanoid)Player.m_localPlayer).GetInventory().CountItems(currency.m_itemData.m_shared.m_name, -1, true) : 0);
			if (itemToRepair == null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, Player.m_localPlayer.GetPlayerName() + " $msg_doesnotneedrepair", 0, (Sprite)null);
				return;
			}
			if ((Object)(object)currency == (Object)null || num2 < num)
			{
				string text = (((Object)(object)currency != (Object)null) ? currency.m_itemData.m_shared.m_name : "$item_coins");
				((Character)Player.m_localPlayer).Message((MessageType)2, "$msg_outof " + text, 0, (Sprite)null);
				return;
			}
			itemToRepair.m_durability = itemToRepair.GetMaxDurability();
			if (num != 0)
			{
				((Humanoid)Player.m_localPlayer).GetInventory().RemoveItem(currency.m_itemData.m_shared.m_name, num, -1, true);
				TraderCoins.UpdateTraderCoins(num);
			}
			EffectList obj = repairItemDoneEffects;
			if (obj != null)
			{
				obj.Create(((Component)Player.m_localPlayer).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
			}
			storeGui.m_sellEffects.Create(((Component)storeGui).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
			((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize("$msg_repaired", new string[1] { itemToRepair.m_shared.m_name }), 0, (Sprite)null);
		}

		public static bool HaveRepairableItems(StoreGui storeGui)
		{
			return GetItemToRepair(storeGui) != null;
		}

		public static ItemData GetItemToRepair(StoreGui storeGui)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)storeGui == (Object)null || (Object)(object)storeGui.m_trader == (Object)null || (Object)(object)InventoryGui.instance == (Object)null)
			{
				return null;
			}
			InventoryGui.instance.m_tempWornItems.Clear();
			((Humanoid)Player.m_localPlayer).GetInventory().GetWornItems(InventoryGui.instance.m_tempWornItems);
			foreach (ItemData tempWornItem in InventoryGui.instance.m_tempWornItems)
			{
				if (tempWornItem.m_shared.m_canBeReparied && IsCapableOfRepair(storeGui.m_trader, tempWornItem))
				{
					return tempWornItem;
				}
			}
			return null;
		}

		private static bool IsCapableOfRepair(Trader trader, ItemData item)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Invalid comparison between Unknown and I4
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Invalid comparison between Unknown and I4
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Invalid comparison between Unknown and I4
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Invalid comparison between Unknown and I4
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Invalid comparison between Unknown and I4
			ResolvedTraderConfig resolvedTraderConfig = TraderConfigManager.Get(trader);
			if ((int)item.m_shared.m_itemType == 3 || (int)item.m_shared.m_itemType == 20 || (int)item.m_shared.m_itemType == 4 || (int)item.m_shared.m_itemType == 5 || (int)item.m_shared.m_itemType == 19 || (int)item.m_shared.m_itemType == 15 || (int)item.m_shared.m_itemType == 14 || (int)item.m_shared.m_itemType == 22)
			{
				return resolvedTraderConfig.CanRepairWeapons;
			}
			if ((int)item.m_shared.m_itemType == 6 || (int)item.m_shared.m_itemType == 7 || (int)item.m_shared.m_itemType == 11 || (int)item.m_shared.m_itemType == 17 || (int)item.m_shared.m_itemType == 18 || (int)item.m_shared.m_itemType == 10)
			{
				return resolvedTraderConfig.CanRepairArmor;
			}
			return false;
		}
	}
	[BepInPlugin("shudnal.TradersExtended", "Traders Extended", "2.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("randyknapp.mods.auga")]
	public class TradersExtended : BaseUnityPlugin
	{
		[Serializable]
		public class TradeableItem
		{
			public const int qualityStackMultiplier = 1000000;

			[NonSerialized]
			[YamlIgnore]
			[JsonIgnore]
			public ItemDrop itemDrop;

			[NonSerialized]
			[JsonIgnore]
			[YamlIgnore]
			public bool automatic;

			public string prefab { get; set; }

			public int stack { get; set; } = 1;

			public int price { get; set; } = 1;

			public int quality { get; set; }

			public string currency { get; set; } = string.Empty;

			public string requiredGlobalKey { get; set; } = string.Empty;

			public string notRequiredGlobalKey { get; set; } = string.Empty;

			public string requiredPlayerKey { get; set; } = string.Empty;

			public string notRequiredPlayerKey { get; set; } = string.Empty;

			public bool RequirementsMet()
			{
				if ((Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return false;
				}
				if (!string.IsNullOrEmpty(requiredGlobalKey) && (from value in requiredGlobalKey.Split(new char[1] { ',' })
					select value.Trim() into value
					where !Utility.IsNullOrWhiteSpace(value)
					select value).Any((string value) => !ZoneSystem.instance.GetGlobalKey(value)))
				{
					return false;
				}
				if (!string.IsNullOrEmpty(notRequiredGlobalKey) && (from value in notRequiredGlobalKey.Split(new char[1] { ',' })
					select value.Trim() into value
					where !Utility.IsNullOrWhiteSpace(value)
					select value).Any((string value) => ZoneSystem.instance.GetGlobalKey(value)))
				{
					return false;
				}
				if (!string.IsNullOrEmpty(requiredPlayerKey) && (from value in requiredPlayerKey.Split(new char[1] { ',' })
					select value.Trim() into value
					where !Utility.IsNullOrWhiteSpace(value)
					select value).Any((string value) => !((Humanoid)Player.m_localPlayer).HaveUniqueKey(value)))
				{
					return false;
				}
				if (!string.IsNullOrEmpty(notRequiredPlayerKey) && (from value in notRequiredPlayerKey.Split(new char[1] { ',' })
					select value.Trim() into value
					where !Utility.IsNullOrWhiteSpace(value)
					select value).Any((string value) => ((Humanoid)Player.m_localPlayer).HaveUniqueKey(value)))
				{
					return false;
				}
				return true;
			}

			public bool IsItemToSell(Trader trader)
			{
				if ((Object)(object)ObjectDB.instance == (Object)null || !RequirementsMet() || string.IsNullOrWhiteSpace(prefab) || stack <= 0 || price <= 0)
				{
					return false;
				}
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefab);
				if ((Object)(object)itemPrefab == (Object)null || !itemPrefab.TryGetComponent<ItemDrop>(ref itemDrop))
				{
					return false;
				}
				ResolvedTraderConfig resolvedTraderConfig = TraderConfigManager.Get(trader);
				return !resolvedTraderConfig.SellOnlyDiscoveredItems || TraderConfigManager.IgnoreItemDiscovery(trader, prefab) || Player.m_localPlayer.IsMaterialKnown(itemDrop.m_itemData.m_shared.m_name);
			}

			public TradeItem ToTradeItem()
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Expected O, but got Unknown
				if ((Object)(object)itemDrop == (Object)null && (Object)(object)ObjectDB.instance != (Object)null && !string.IsNullOrWhiteSpace(prefab))
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefab);
					if ((Object)(object)itemPrefab != (Object)null)
					{
						itemDrop = itemPrefab.GetComponent<ItemDrop>();
					}
				}
				if ((Object)(object)itemDrop == (Object)null)
				{
					return null;
				}
				return new TradeItem
				{
					m_prefab = itemDrop,
					m_price = price,
					m_stack = GetStackFromStackQuality(stack, quality),
					m_requiredGlobalKey = requiredGlobalKey
				};
			}

			public static void NormalizeStack(TradeItem item)
			{
				if (item != null && !((Object)(object)item.m_prefab == (Object)null))
				{
					GetStackQualityFromStack(item.m_stack, out var num, out var num2);
					item.m_stack = GetStackFromStackQuality(Mathf.Clamp(num, 1, item.m_prefab.m_itemData.m_shared.m_maxStackSize), num2);
				}
			}

			public static void GetStackQualityFromStack(int encodedStack, out int stack, out int quality)
			{
				stack = encodedStack % 1000000;
				quality = encodedStack / 1000000;
			}

			public static int GetStackFromStackQuality(int stack, int quality)
			{
				return stack + 1000000 * quality;
			}

			public static int GetStackFromStack(int encodedStack)
			{
				return encodedStack % 1000000;
			}
		}

		public enum ItemsListType
		{
			Buy,
			Sell
		}

		private sealed class ObjectDbExportItem
		{
			public string prefab { get; set; }

			public int price { get; set; }
		}

		private sealed class PersonalTraderConfigSource
		{
			internal string FileName;

			internal string Content;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static EventHandler <>9__81_0;

			public static EventHandler <>9__81_1;

			public static EventHandler <>9__81_2;

			public static ConsoleEvent <>9__86_0;

			public static ConsoleOptionsFetcher <>9__86_1;

			public static ConsoleEventFailable <>9__86_2;

			public static ConsoleOptionsFetcher <>9__86_3;

			public static Func<ObjectDbExportItem, string> <>9__88_0;

			public static Func<ObjectDbExportItem, string> <>9__88_1;

			public static Func<Humanoid, bool> <>9__90_0;

			public static Func<string[], string> <>9__90_1;

			public static Func<string[], string> <>9__90_2;

			public static Func<string[], string> <>9__90_3;

			public static Func<string, string> <>9__91_0;

			public static Func<string, bool> <>9__91_1;

			public static Func<string, string> <>9__91_2;

			public static Func<string, bool> <>9__91_3;

			public static Func<string, string> <>9__91_4;

			public static Func<string, bool> <>9__91_5;

			public static Func<KeyValuePair<string, PersonalTraderConfigSource>, string> <>9__99_0;

			public static Func<KeyValuePair<string, PersonalTraderConfigSource>, string> <>9__99_1;

			public static Func<FileInfo, bool> <>9__100_0;

			public static Func<FileInfo, string> <>9__100_2;

			public static Func<FileInfo, string> <>9__100_3;

			public static Func<FileInfo, bool> <>9__100_4;

			public static Func<FileInfo, <>f__AnonymousType0<FileInfo, bool, string>> <>9__100_5;

			public static Func<<>f__AnonymousType0<FileInfo, bool, string>, bool> <>9__100_6;

			public static Func<<>f__AnonymousType0<FileInfo, bool, string>, string> <>9__100_7;

			public static Func<<>f__AnonymousType0<FileInfo, bool, string>, FileInfo> <>9__100_8;

			public static Func<FileInfo, string> <>9__100_9;

			public static Func<FileInfo, string> <>9__100_10;

			public static Func<string, bool> <>9__102_0;

			public static Func<string, string> <>9__102_1;

			public static Func<string, <>f__AnonymousType1<string, string, bool, string>> <>9__102_2;

			public static Func<<>f__AnonymousType1<string, string, bool, string>, bool> <>9__102_3;

			public static Func<<>f__AnonymousType1<string, string, bool, string>, string> <>9__102_4;

			public static Func<<>f__AnonymousType1<string, string, bool, string>, string> <>9__102_5;

			public static Func<<>f__AnonymousType1<string, string, bool, string>, string> <>9__102_6;

			public static Func<KeyValuePair<string, string>, int> <>9__121_0;

			public static Func<KeyValuePair<string, string>, int> <>9__121_1;

			public static Func<KeyValuePair<string, string>, string> <>9__121_2;

			public static Func<TradeableItem, bool> <>9__121_3;

			public static Func<string, int, string> <>9__126_0;

			public static Func<string, bool> <>9__126_2;

			public static Func<bool> <>9__129_0;

			public static Func<TradeableItem, bool> <>9__129_1;

			public static Func<TradeableItem, string> <>9__129_2;

			internal void <ConfigInit>b__81_0(object <p0>, EventArgs <p1>)
			{
				FillConfigLists();
			}

			internal void <ConfigInit>b__81_1(object <p0>, EventArgs <p1>)
			{
				FillConfigLists();
			}

			internal void <ConfigInit>b__81_2(object <p0>, EventArgs <p1>)
			{
				FillConfigLists();
			}

			internal void <InitCommands>b__86_0(ConsoleEventArgs args)
			{
				if (args.Length >= 2)
				{
					string a = args[1];
					if (string.Equals(a, "editor", StringComparison.OrdinalIgnoreCase))
					{
						configEditor?.Toggle();
					}
					else if (string.Equals(a, "save", StringComparison.OrdinalIgnoreCase))
					{
						SaveFromObjectDB(args.Context, (args.Length >= 3) ? args[2] : "json");
					}
					else if (string.Equals(a, "itemlist", StringComparison.OrdinalIgnoreCase))
					{
						ExportItemListFromObjectDB(args.Context);
					}
					else
					{
						args.Context.AddString("Actions: editor - Open the configuration editor, save [json|yml|csv] - Save the full item list as JSON by default, itemlist - Save the filtered item list as CSV");
					}
				}
				else
				{
					args.Context.AddString("Actions: editor - Open the configuration editor, save [json|yml|csv] - Save the full item list as JSON by default, itemlist - Save the filtered item list as CSV");
				}
			}

			internal List<string> <InitCommands>b__86_1()
			{
				return new List<string> { "editor", "save", "itemlist" };
			}

			internal object <InitCommands>b__86_2(ConsoleEventArgs args)
			{
				if (args.Length <= 1)
				{
					return false;
				}
				TraderCoins.SetTraderCoins(args[1], args.TryParameterInt(2, TraderConfigManager.Get(args[1]).CoinsAfterReplenishmentMinimum));
				return true;
			}

			internal List<string> <InitCommands>b__86_3()
			{
				return TraderCoins.GetTraderPrefabs();
			}

			internal string <SaveFromObjectDB>b__88_0(ObjectDbExportItem item)
			{
				return item.prefab;
			}

			internal string <SaveFromObjectDB>b__88_1(ObjectDbExportItem item)
			{
				return CsvField(item.prefab) + "," + item.price.ToString(CultureInfo.InvariantCulture);
			}

			internal bool <ExportItemListFromObjectDB>b__90_0(Humanoid humanoid)
			{
				BaseAI val = default(BaseAI);
				return (Object)(object)humanoid != (Object)null && ((Component)humanoid).TryGetComponent<BaseAI>(ref val);
			}

			internal string <ExportItemListFromObjectDB>b__90_1(string[] item)
			{
				return item[5];
			}

			internal string <ExportItemListFromObjectDB>b__90_2(string[] item)
			{
				return item[0];
			}

			internal string <ExportItemListFromObjectDB>b__90_3(string[] item)
			{
				return string.Join(",", item.Select(CsvField));
			}

			internal string <FillConfigLists>b__91_0(string value)
			{
				return value.Trim();
			}

			internal bool <FillConfigLists>b__91_1(string value)
			{
				return !string.IsNullOrWhiteSpace(value);
			}

			internal string <FillConfigLists>b__91_2(string value)
			{
				return TraderName(value.Trim());
			}

			internal bool <FillConfigLists>b__91_3(string value)
			{
				return !string.IsNullOrWhiteSpace(value);
			}

			internal string <FillConfigLists>b__91_4(string value)
			{
				return TraderName(value.Trim());
			}

			internal bool <FillConfigLists>b__91_5(string value)
			{
				return !string.IsNullOrWhiteSpace(value);
			}

			internal string <ReadConfigs>b__99_0(KeyValuePair<string, PersonalTraderConfigSource> pair)
			{
				return BuildSyncedTraderConfigKey(pair.Key, pair.Value.FileName);
			}

			internal string <ReadConfigs>b__99_1(KeyValuePair<string, PersonalTraderConfigSource> pair)
			{
				return pair.Value.Content;
			}

			internal bool <AddDirectoryConfigs>b__100_0(FileInfo file)
			{
				return IsSupportedConfigExtension(file.Extension);
			}

			internal string <AddDirectoryConfigs>b__100_2(FileInfo file)
			{
				return file.Name;
			}

			internal string <AddDirectoryConfigs>b__100_3(FileInfo file)
			{
				return file.FullName;
			}

			internal bool <AddDirectoryConfigs>b__100_4(FileInfo file)
			{
				string trader;
				ItemsListType listType;
				return TryParseConfigFileName(file.Name, out trader, out listType);
			}

			internal <>f__AnonymousType0<FileInfo, bool, string> <AddDirectoryConfigs>b__100_5(FileInfo file)
			{
				string trader;
				return new
				{
					File = file,
					Parsed = TryParseTraderConfigFileName(file.Name, out trader),
					Trader = trader
				};
			}

			internal bool <AddDirectoryConfigs>b__100_6(<>f__AnonymousType0<FileInfo, bool, string> entry)
			{
				return entry.Parsed;
			}

			internal string <AddDirectoryConfigs>b__100_7(<>f__AnonymousType0<FileInfo, bool, string> entry)
			{
				return TraderName(entry.Trader);
			}

			internal FileInfo <AddDirectoryConfigs>b__100_8(<>f__AnonymousType0<FileInfo, bool, string> entry)
			{
				return entry.File;
			}

			internal string <AddDirectoryConfigs>b__100_9(FileInfo file)
			{
				return file.Extension;
			}

			internal string <AddDirectoryConfigs>b__100_10(FileInfo file)
			{
				return file.FullName;
			}

			internal bool <AddEmbeddedConfigs>b__102_0(string resource)
			{
				return resource.StartsWith("TradersExtended.Configs.", StringComparison.Ordinal) && IsSupportedConfigExtension(Path.GetExtension(resource));
			}

			internal string <AddEmbeddedConfigs>b__102_1(string resource)
			{
				return resource;
			}

			internal <>f__AnonymousType1<string, string, bool, string> <AddEmbeddedConfigs>b__102_2(string resource)
			{
				string text = resource.Substring("TradersExtended.Configs.".Length);
				string trader;
				bool parsed = TryParseTraderConfigFileName(text, out trader) || TryParseTraderConfigFileName("shudnal.TradersExtended." + text, out trader) || TryParseEmbeddedTraderConfigName(text, out trader);
				return new
				{
					Resource = resource,
					FileName = text,
					Parsed = parsed,
					Trader = trader
				};
			}

			internal bool <AddEmbeddedConfigs>b__102_3(<>f__AnonymousType1<string, string, bool, string> entry)
			{
				return entry.Parsed;
			}

			internal string <AddEmbeddedConfigs>b__102_4(<>f__AnonymousType1<string, string, bool, string> entry)
			{
				return TraderName(entry.Trader);
			}

			internal string <AddEmbeddedConfigs>b__102_5(<>f__AnonymousType1<string, string, bool, string> entry)
			{
				return Path.GetExtension(entry.FileName);
			}

			internal string <AddEmbeddedConfigs>b__102_6(<>f__AnonymousType1<string, string, bool, string> entry)
			{
				return entry.Resource;
			}

			internal int <LoadConfigs>b__121_0(KeyValuePair<string, string> pair)
			{
				return ConfigSourcePriority(pair.Key);
			}

			internal int <LoadConfigs>b__121_1(KeyValuePair<string, string> pair)
			{
				return ConfigSourceOrder(pair.Key);
			}

			internal string <LoadConfigs>b__121_2(KeyValuePair<string, string> pair)
			{
				return pair.Key;
			}

			internal bool <LoadConfigs>b__121_3(TradeableItem item)
			{
				return item != null;
			}

			internal string <DeserializeCsvItems>b__126_0(string header, int index)
			{
				return (index == 0) ? (header ?? string.Empty).TrimStart(new char[1] { '\ufeff' }).Trim() : (header ?? string.Empty).Trim();
			}

			internal bool <DeserializeCsvItems>b__126_2(string header)
			{
				return string.Equals(header, "prefab", StringComparison.OrdinalIgnoreCase);
			}

			internal bool <AddCommonValuableItems>b__129_0()
			{
				return (Object)(object)ObjectDB.instance != (Object)null;
			}

			internal bool <AddCommonValuableItems>b__129_1(TradeableItem item)
			{
				return item != null && !string.IsNullOrWhiteSpace(item.prefab);
			}

			internal string <AddCommonValuableItems>b__129_2(TradeableItem item)
			{
				return item.prefab;
			}
		}

		public const string pluginID = "shudnal.TradersExtended";

		public const string pluginName = "Traders Extended";

		public const string pluginVersion = "2.0.0";

		internal const string DefaultEditorGlobalKeys = "defeated_bonemass,defeated_gdking,defeated_goblinking,defeated_dragon,defeated_eikthyr,defeated_queen,defeated_fader,defeated_serpent,KilledTroll,killed_surtling,KilledBat,Hildir1,Hildir2,Hildir3";

		internal const string DefaultEditorPlayerKeys = "GP_Eikthyr,GP_TheElder,GP_Bonemass,GP_Moder,GP_Yagluth,GP_Queen,GP_Fader";

		internal const string DefaultEditorVisibleItemColumns = "Prefab,Name,Stack,Price,Quality,Currency,RequiredGlobalKey,BlockedGlobalKey,RequiredPlayerKey,BlockedPlayerKey";

		private readonly Harmony harmony = new Harmony("shudnal.TradersExtended");

		internal static readonly ConfigSync configSync = new ConfigSync("shudnal.TradersExtended")
		{
			DisplayName = "Traders Extended",
			CurrentVersion = "2.0.0",
			MinimumRequiredVersion = "2.0.0",
			ModRequired = true
		};

		public static ManualLogSource logger;

		internal static TradersExtended instance;

		internal static ConfigEditor configEditor;

		private static ConfigEntry<bool> loggingEnabled;

		private static ConfigEntry<bool> configLocked;

		internal static ConfigEntry<KeyboardShortcut> configEditorShortcut;

		internal static ConfigEntry<Vector2> configEditorWindowPosition;

		internal static ConfigEntry<Vector2> configEditorWindowSize;

		internal static ConfigEntry<bool> configEditorBlockGameInput;

		internal static ConfigEntry<bool> configEditorUseValheimGuiScale;

		internal static ConfigEntry<float> configEditorUiScale;

		internal static ConfigEntry<int> configEditorFontSize;

		internal static ConfigEntry<float> configEditorFileListWidth;

		internal static ConfigEntry<bool> configEditorShowAllItems;

		internal static ConfigEntry<string> configEditorGlobalKeys;

		internal static ConfigEntry<string> configEditorPlayerKeys;

		internal static ConfigEntry<string> configEditorVisibleItemColumns;

		public static ConfigEntry<bool> checkForDiscovery;

		internal static ConfigEntry<string> checkForDiscoveryIgnoreItems;

		public static ConfigEntry<bool> traderRepair;

		public static ConfigEntry<int> traderRepairCost;

		public static ConfigEntry<string> traderRepairCurrency;

		internal static ConfigEntry<string> tradersToRepairWeapons;

		internal static ConfigEntry<string> tradersToRepairArmor;

		public static ConfigEntry<bool> traderUseCoins;

		public static ConfigEntry<bool> traderUseFlexiblePricing;

		public static ConfigEntry<int> traderCoinsMinimumAmount;

		public static ConfigEntry<int> traderCoinsIncreaseAmount;

		public static ConfigEntry<int> traderCoinsDecreaseAmount;

		public static ConfigEntry<int> traderCoinsMaximumAmount;

		public static ConfigEntry<float> traderDiscount;

		public static ConfigEntry<float> traderMarkup;

		public static ConfigEntry<int> traderCoinsReplenishmentRate;

		public static ConfigEntry<bool> traderCoinsSendReplenishmentMessage;

		public static ConfigEntry<string> traderCurrencyOverrides;

		public static ConfigEntry<bool> coinsPatch;

		public static ConfigEntry<float> coinsWeight;

		public static ConfigEntry<int> coinsStackSize;

		public static ConfigEntry<string> tradersCustomPrefabs;

		public static ConfigEntry<bool> disableVanillaItems;

		public static ConfigEntry<bool> disableOtherModsItems;

		public static ConfigEntry<float> qualityMultiplier;

		public static ConfigEntry<bool> hideEquippedAndHotbarItems;

		public static ConfigEntry<bool> addCommonValuableItemsToSellList;

		public static ConfigEntry<Vector2> fixedStoreGuiPosition;

		public static ConfigEntry<bool> enableBuyBack;

		public static ConfigEntry<int> buybackLifetime;

		public static ConfigEntry<Color> colorBuybackNormal;

		public static ConfigEntry<Color> colorBuybackHighlighted;

		public static ConfigEntry<Color> colorBuybackText;

		public static ConfigEntry<string> epicLootShiftedTraders;

		public static readonly Dictionary<string, List<TradeableItem>> tradeableItems = new Dictionary<string, List<TradeableItem>>(StringComparer.OrdinalIgnoreCase);

		public static readonly Dictionary<string, List<TradeableItem>> sellableItems = new Dictionary<string, List<TradeableItem>>(StringComparer.OrdinalIgnoreCase);

		private static readonly CustomSyncedValue<Dictionary<string, string>> itemConfigs = new CustomSyncedValue<Dictionary<string, string>>((ConditionalConfigSync)(object)configSync, "Item configs", new Dictionary<string, string>(), 0, (IEqualityComparer<Dictionary<string, string>>)null);

		internal static readonly CustomSyncedValue<Dictionary<string, string>> traderConfigFiles = new CustomSyncedValue<Dictionary<string, string>>((ConditionalConfigSync)(object)configSync, "Personal trader configs", new Dictionary<string, string>(), 0, (IEqualityComparer<Dictionary<string, string>>)null);

		internal static readonly IDeserializer yamlDeserializer = new DeserializerBuilder().IgnoreUnmatchedProperties().Build();

		internal static DirectoryInfo configDirectory;

		private static readonly List<FileSystemWatcher> configWatchers = new List<FileSystemWatcher>();

		private static Coroutine configReloadCoroutine;

		private static Coroutine configLoadCoroutine;

		public static HashSet<string> _ignoreItemDiscovery = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public static HashSet<string> _tradersToRepairWeapons = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public static HashSet<string> _tradersToRepairArmor = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private void Awake()
		{
			instance = this;
			logger = ((BaseUnityPlugin)this).Logger;
			configDirectory = new DirectoryInfo(Paths.ConfigPath);
			ConfigInit();
			configEditor = new ConfigEditor();
			((ConditionalConfigSync)configSync).AddLockingConfigEntry<bool>(configLocked);
			((CustomSyncedValueBase)itemConfigs).ValueChanged += StartConfigLoad;
			((CustomSyncedValueBase)traderConfigFiles).ValueChanged += TraderConfigManager.LoadSyncedConfigs;
			EpicLootCompat.CheckForCompatibility();
			harmony.PatchAll();
			Game.isModded = true;
		}

		private void Start()
		{
			configEditor?.MarkGameWindowReady();
			FillConfigLists();
			TraderCurrency.RebuildOverrides();
			SetupConfigWatcher();
		}

		private void Update()
		{
			if (!((Object)(object)instance != (Object)null) || !((Object)(object)instance != (Object)(object)this))
			{
				configEditor?.Update();
				AmountDialog.Update();
			}
		}

		private void LateUpdate()
		{
			if (!((Object)(object)instance != (Object)null) || !((Object)(object)instance != (Object)(object)this))
			{
				configEditor?.LateUpdate();
			}
		}

		private void OnGUI()
		{
			if (!((Object)(object)instance != (Object)null) || !((Object)(object)instance != (Object)(object)this))
			{
				configEditor?.OnGUI();
			}
		}

		private void OnDestroy()
		{
			if (!((Object)(object)instance != (Object)null) || !((Object)(object)instance != (Object)(object)this))
			{
				DisposeConfigWatchers();
				if (configReloadCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(configReloadCoroutine);
				}
				if (configLoadCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(configLoadCoroutine);
				}
				((CustomSyncedValueBase)itemConfigs).ValueChanged -= StartConfigLoad;
				((CustomSyncedValueBase)traderConfigFiles).ValueChanged -= TraderConfigManager.LoadSyncedConfigs;
				BuybackManager.ResetCache();
				configEditor?.Dispose();
				configEditor = null;
				((BaseUnityPlugin)this).Config.Save();
				harmony.UnpatchSelf();
				instance = null;
			}
		}

		public static void LogInfo(object data)
		{
			if (loggingEnabled != null && loggingEnabled.Value && logger != null)
			{
				logger.LogInfo(data);
			}
		}

		public static void LogWarning(object data)
		{
			if (logger != null)
			{
				logger.LogWarning(data);
			}
		}

		private void ConfigInit()
		{
			//IL_0053: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_0661: Unknown result type (might be due to invalid IL or missing references)
			//IL_0690: Unknown result type (might be due to invalid IL or missing references)
			configLocked = serverConfig("General", "Lock Configuration", defaultValue: true, "Configuration is locked and can be changed by server administrators only.");
			loggingEnabled = config("General", "Logging enabled", defaultValue: false, "Enable diagnostic logging. [Not synchronized with server]", synchronizedSetting: false);
			configEditorShortcut = config<KeyboardShortcut>("Configuration editor", "Configuration editor shortcut", new KeyboardShortcut((KeyCode)112, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Open or close the in-game Traders Extended configuration editor. [Not synchronized with server]", synchronizedSetting: false);
			configEditorWindowPosition = config<Vector2>("Configuration editor", "Configuration editor position", new Vector2(-1f, -1f), "Saved position of the configuration editor window. [Not synchronized with server]", synchronizedSetting: false);
			configEditorWindowSize = config<Vector2>("Configuration editor", "Configuration editor size", new Vector2(1500f, 850f), "Saved logical size of the configuration editor window. [Not synchronized with server]", synchronizedSetting: false);
			configEditorBlockGameInput = config("Configuration editor", "Block game input", defaultValue: true, "Block all Valheim gameplay input while the configuration editor is open. IMGUI input and the editor shortcut remain available. [Not synchronized with server]", synchronizedSetting: false);
			configEditorUseValheimGuiScale = config("Configuration editor", "Use Valheim GUI scaling", defaultValue: true, "Multiply the editor scale by Valheim's Accessibility - Scale GUI setting. [Not synchronized with server]", synchronizedSetting: false);
			configEditorUiScale = config("Configuration editor", "Scale", 1f, new ConfigDescription("Additional configuration editor UI scale. [Not synchronized with server]", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.6f, 2f), Array.Empty<object>()), synchronizedSetting: false);
			configEditorFontSize = config("Configuration editor", "Font size", 13, new ConfigDescription("Base configuration editor IMGUI font size. [Not synchronized with server]", (AcceptableValueBase)(object)new AcceptableValueRange<int>(9, 28), Array.Empty<object>()), synchronizedSetting: false);
			configEditorFileListWidth = config("Configuration editor", "File list width", 382f, new ConfigDescription("Logical width of the configuration file column. It can also be changed by dragging the column separator. [Not synchronized with server]", (AcceptableValueBase)(object)new AcceptableValueRange<float>(240f, 800f), Array.Empty<object>()), synchronizedSetting: false);
			configEditorShowAllItems = config("Configuration editor", "Show all items", defaultValue: false, "Show every ObjectDB item in item pickers. When disabled, hide AI equipment and invalid or non-user-facing items. [Not synchronized with server]", synchronizedSetting: false);
			configEditorVisibleItemColumns = config("Configuration editor", "Visible item columns", "Prefab,Name,Stack,Price,Quality,Currency,RequiredGlobalKey,BlockedGlobalKey,RequiredPlayerKey,BlockedPlayerKey", "Comma-separated item editor columns to display: Prefab, Name, Stack, Price, Quality, Currency, RequiredGlobalKey, BlockedGlobalKey, RequiredPlayerKey and BlockedPlayerKey. [Not synchronized with server]", synchronizedSetting: false);
			configEditorGlobalKeys = config("Configuration editor", "Global keys", "defeated_bonemass,defeated_gdking,defeated_goblinking,defeated_dragon,defeated_eikthyr,defeated_queen,defeated_fader,defeated_serpent,KilledTroll,killed_surtling,KilledBat,Hildir1,Hildir2,Hildir3", "Comma-separated global keys available in the configuration editor. Custom keys can be added or removed in the picker; built-in keys remain protected. [Not synchronized with server]", synchronizedSetting: false);
			configEditorPlayerKeys = config("Configuration editor", "Player keys", "GP_Eikthyr,GP_TheElder,GP_Bonemass,GP_Moder,GP_Yagluth,GP_Queen,GP_Fader", "Comma-separated player keys available in the configuration editor. Custom keys can be added or removed in the picker; built-in keys remain protected. [Not synchronized with server]", synchronizedSetting: false);
			checkForDiscovery = config("Item discovery", "Sell only discovered items", defaultValue: true, "A trader will not sell items that the buyer has not discovered.");
			checkForDiscoveryIgnoreItems = config("Item discovery", "Undiscovered items list to sell", "", "Comma-separated prefab names that bypass the discovery check. Vanilla trader items are included by default.");
			checkForDiscoveryIgnoreItems.SettingChanged += delegate
			{
				FillConfigLists();
			};
			coinsPatch = config("Item coins", "Change values", defaultValue: false, "Change properties of the Coins item.");
			coinsWeight = config("Item coins", "Coins weight", 0f, "Weight of one coin.");
			coinsStackSize = config("Item coins", "Coins stack size", 2000, "Maximum coin stack size.");
			traderRepair = config("Trader repair", "Traders can repair items", defaultValue: true, "Allow configured traders to repair items.");
			tradersToRepairWeapons = config("Trader repair", "Traders capable to repair weapons", "Haldor", "Comma-separated trader prefab names that can repair weapons.");
			tradersToRepairArmor = config("Trader repair", "Traders capable to repair armor", "Hildir", "Comma-separated trader prefab names that can repair armor.");
			traderRepairCost = config("Trader repair", "Traders repair cost", 2, "Repair cost.");
			traderRepairCurrency = config("Trader repair", "Repair currency", "Coins", "Item prefab used to pay for repairs.");
			tradersToRepairWeapons.SettingChanged += delegate
			{
				FillConfigLists();
			};
			tradersToRepairArmor.SettingChanged += delegate
			{
				FillConfigLists();
			};
			traderUseCoins = config("Trader coins", "Traders use coins", defaultValue: true, "Traders have a limited daily replenished balance.");
			traderUseFlexiblePricing = config("Trader coins", "Traders use flexible pricing", defaultValue: true, "Adjust buy and sell prices according to the trader's current balance.");
			traderCurrencyOverrides = config("Trader currency", "Trader currency overrides", "", "Comma-separated TraderPrefab:CurrencyPrefab pairs. The configured item becomes the default currency for all transactions with that trader. An item config entry's currency field overrides it for that buy or sell entry only.");
			traderCoinsMinimumAmount = config("Trader coins pricing", "Amount of coins after replenishment minimum", 2000, "Minimum balance after replenishment.");
			traderCoinsIncreaseAmount = config("Trader coins pricing", "Amount of coins replenished daily", 1000, "Amount added to the current balance until the maximum is reached.");
			traderCoinsDecreaseAmount = config("Trader coins pricing", "Amount of coins removed daily", 0, "Amount removed from balances above the maximum.");
			traderCoinsMaximumAmount = config("Trader coins pricing", "Amount of coins after replenishment maximum", 6000, "Maximum replenished balance.");
			traderDiscount = config("Trader coins pricing", "Trader discount", 0.7f, "Buy-price factor at the maximum trader balance.");
			traderMarkup = config("Trader coins pricing", "Trader markup", 1.5f, "Buy-price factor at zero trader balance.");
			traderCoinsReplenishmentRate = config("Trader coins pricing", "Trader coins replenishment rate in days", 1, "Number of days between balance updates.");
			traderCoinsSendReplenishmentMessage = config("Trader coins pricing", "Send replenishment message in the morning", defaultValue: true, "Show a message when trader balances are updated.");
			tradersCustomPrefabs = config("Misc", "Custom traders prefab names", "", "Comma-separated, case-sensitive custom trader prefab names whose balances should be managed.");
			disableVanillaItems = config("Misc", "Disable vanilla items", defaultValue: false, "Remove vanilla items from trader buy lists. Compatibility depends on the custom trader implementation.");
			qualityMultiplier = config("Misc", "Quality multiplier", 0f, "Additional price factor applied for each item quality level above one.");
			hideEquippedAndHotbarItems = config("Misc", "Hide equipped and hotbar items", defaultValue: true, "Hide equipped items and equippable items in the first inventory row from the sell list.");
			addCommonValuableItemsToSellList = config("Misc", "Add common valuable items to sell list", defaultValue: true, "Add ObjectDB items with a positive vanilla value to the common sell list.");
			fixedStoreGuiPosition = config<Vector2>("Misc", "Fixed position for Store GUI", Vector2.zero, "Use an absolute Store GUI position when this value is not zero.");
			disableOtherModsItems = config("Misc", "Disable other mods items", defaultValue: false, "Remove all buy-list items added by other mods before Traders Extended adds its own lists.");
			enableBuyBack = config("Trader buyback", "Enable buyback for last item sold", defaultValue: true, "Add the last item sold to this trader to the beginning of the buy list.");
			buybackLifetime = config("Trader buyback", "Buyback lifetime in world seconds", 1800, "How long a saved buyback remains available in world-time seconds. Set to 0 to disable expiration.");
			colorBuybackNormal = config<Color>("Trader buyback", "Item background color", new Color(0f, 0.42f, 0.42f), "Buyback item background color.");
			colorBuybackHighlighted = config<Color>("Trader buyback", "Item highlighted color", new Color(0.25f, 0.62f, 0.62f), "Buyback item highlighted color.");
			colorBuybackText = config<Color>("Trader buyback", "Item font color", new Color(1f, 0.81f, 0f), "Buyback item name color.");
			epicLootShiftedTraders = config("EpicLoot compatibility", "Traders with shifted Store GUI position", "Haldor", "Comma-separated trader prefab names whose Store GUI should be shifted when EpicLoot Adventure Mode is active.");
			InitCommands();
		}

		private ConfigEntry<T> config<T>(string group, string name, T defaultValue, ConfigDescription description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> sourceConfig = ((ConditionalConfigSync)configSync).AddConfigEntry<T>(((BaseUnityPlugin)this).Config, group, name, defaultValue, description, (ConfigSyncMode)1, synchronizedSetting).SourceConfig;
			if (!string.Equals(group, "General", StringComparison.OrdinalIgnoreCase) && !string.Equals(group, "Item coins", StringComparison.OrdinalIgnoreCase) && !string.Equals(group, "Configuration editor", StringComparison.OrdinalIgnoreCase))
			{
				sourceConfig.SettingChanged += delegate
				{
					TraderConfigManager.InvalidateAndRefresh();
				};
			}
			return sourceConfig;
		}

		private ConfigEntry<T> serverConfig<T>(string group, string name, T defaultValue, ConfigDescription description)
		{
			return ((ConditionalConfigSync)configSync).AddConfigEntry<T>(((BaseUnityPlugin)this).Config, group, name, defaultValue, description, (ConfigSyncMode)0, true).SourceConfig;
		}

		private ConfigEntry<T> config<T>(string group, string name, T defaultValue, string description, bool synchronizedSetting = true)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			return config(group, name, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		private ConfigEntry<T> serverConfig<T>(string group, string name, T defaultValue, string description)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			return serverConfig(group, name, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}

		public static void InitCommands()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0051: 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_004e: Expected O, but got Unknown
			//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_0080: Expected O, but got Unknown
			//IL_00a7: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			object obj = <>c.<>9__86_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					if (args.Length >= 2)
					{
						string a = args[1];
						if (string.Equals(a, "editor", StringComparison.OrdinalIgnoreCase))
						{
							configEditor?.Toggle();
						}
						else if (string.Equals(a, "save", StringComparison.OrdinalIgnoreCase))
						{
							SaveFromObjectDB(args.Context, (args.Length >= 3) ? args[2] : "json");
						}
						else if (string.Equals(a, "itemlist", StringComparison.OrdinalIgnoreCase))
						{
							ExportItemListFromObjectDB(args.Context);
						}
						else
						{
							args.Context.AddString("Actions: editor - Open the configuration editor, save [json|yml|csv] - Save the full item list as JSON by default, itemlist - Save the filtered item list as CSV");
						}
					}
					else
					{
						args.Context.AddString("Actions: editor - Open the configuration editor, save [json|yml|csv] - Save the full item list as JSON by default, itemlist - Save the filtered item list as CSV");
					}
				};
				<>c.<>9__86_0 = val;
				obj = (object)val;
			}
			object obj2 = <>c.<>9__86_1;
			if (obj2 == null)
			{
				ConsoleOptionsFetcher val2 = () => new List<string> { "editor", "save", "itemlist" };
				<>c.<>9__86_1 = val2;
				obj2 = (object)val2;
			}
			new ConsoleCommand("tradersextended", "editor - Open the configuration editor, save [json|yml|csv] - Save the full item list as JSON by default, itemlist - Save the filtered item list as CSV", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)obj2, true, false, false);
			object obj3 = <>c.<>9__86_2;
			if (obj3 == null)
			{
				ConsoleEventFailable val3 = delegate(ConsoleEventArgs args)
				{
					if (args.Length <= 1)
					{
						return false;
					}
					TraderCoins.SetTraderCoins(args[1], args.TryParameterInt(2, TraderConfigManager.Get(args[1]).CoinsAfterReplenishmentMinimum));
					return true;
				};
				<>c.<>9__86_2 = val3;
				obj3 = (object)val3;
			}
			object obj4 = <>c.<>9__86_3;
			if (obj4 == null)
			{
				ConsoleOptionsFetcher val4 = () => TraderCoins.GetTraderPrefabs();
				<>c.<>9__86_3 = val4;
				obj4 = (object)val4;
			}
			new ConsoleCommand("settradercoins", "[trader] [amount]", (ConsoleEventFailable)obj3, true, false, true, false, false, (ConsoleOptionsFetcher)obj4, true, false, true);
		}

		public static void SaveFromObjectDB(Terminal context, string requestedFormat = "json")
		{
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				context.AddString("ObjectDB is not initialized.");
				return;
			}
			string text = (requestedFormat ?? "json").Trim().ToLowerInvariant();
			if (text == "yaml")
			{
				text = "yml";
			}
			if (text != "json" && text != "yml" && text != "csv")
			{
				context.AddString("Usage: tradersextended save [json|yml|csv]");
				return;
			}
			List<ObjectDbExportItem> list = new List<ObjectDbExportItem>();
			ItemDrop val = default(ItemDrop);
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if (!((Object)(object)item == (Object)null) && item.TryGetComponent<ItemDrop>(ref val))
				{
					list.Add(new ObjectDbExportItem
					{
						prefab = ((Object)item).name,
						price = Math.Max(val.m_itemData.m_shared.m_value, 1)
					});
				}
			}
			list = list.OrderBy<ObjectDbExportItem, string>((ObjectDbExportItem item) => item.prefab, StringComparer.Ordinal).ToList();
			string text2 = Path.Combine(configDirectory.FullName, "shudnal.TradersExtended");
			Directory.CreateDirectory(text2);
			string path = Path.Combine(text2, "ObjectDB.list." + text);
			if (text == "json")
			{
				string contents = JsonConvert.SerializeObject((object)list, (Formatting)1);
				File.WriteAllText(path, contents, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
			}
			else if (text == "yml")
			{
				ISerializer val2 = new SerializerBuilder().DisableAliases().Build();
				File.WriteAllText(path, val2.Serialize((object)list), new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
			}
			else
			{
				IEnumerable<string> contents2 = new string[1] { "prefab,price" }.Concat(list.Select((ObjectDbExportItem item) => CsvField(item.prefab) + "," + item.price.ToString(CultureInfo.InvariantCulture)));
				File.WriteAllLines(path, contents2, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
			}
			context.AddString(string.Format("Saved {0} items to \"\\config\\{1}\\ObjectDB.list.{2}\"", list.Count, "shudnal.TradersExtended", text));
		}

		private static string CsvField(string value)
		{
			value = value ?? string.Empty;
			if (value.IndexOfAny(new char[4] { ',', '"', '\r', '\n' }) < 0)
			{
				return value;
			}
			return "\"" + value.Replace("\"", "\"\"") + "\"";
		}

		public static void ExportItemListFromObjectDB(Terminal context)
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Invalid comparison between Unknown and I4
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Invalid comparison between Unknown and I4
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				context.AddString("ObjectDB is not initialized.");
				return;
			}
			List<string[]> list = new List<string[]>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			Trader[] array = Resources.FindObjectsOfTypeAll<Trader>();
			Trader[] array2 = array;
			foreach (Trader val in array2)
			{
				if ((Object)(object)val == (Object)null || val.m_items == null)
				{
					continue;
				}
				foreach (TradeItem item in val.m_items)
				{
					if (item != null && !((Object)(object)item.m_prefab == (Object)null) && hashSet.Add(((Object)item.m_prefab).name) && !Utility.IsNullOrWhiteSpace(item.m_prefab.m_itemData.m_shared.m_name) && item.m_prefab.m_itemData.m_shared.m_description != null && (int)item.m_prefab.m_itemData.m_shared.m_itemType != 0 && (int)item.m_prefab.m_itemData.m_shared.m_itemType != 10)
					{
						list.Add(new string[6]
						{
							((Object)item.m_prefab).name,
							Localization.instance.Localize(item.m_prefab.m_itemData.m_shared.m_name),
							Math.Max(item.m_prefab.m_itemData.m_shared.m_value, 0).ToString(CultureInfo.InvariantCulture),
							item.m_price.ToString(CultureInfo.InvariantCulture),
							item.m_stack.ToString(CultureInfo.InvariantCulture),
							Utils.GetPrefabName(((Object)val).name)
						});
					}
				}
			}
			BaseAI val5 = default(BaseAI);
			IEnumerable<Humanoid> enumerable = from humanoid in Resources.FindObjectsOfTypeAll<Humanoid>()
				where (Object)(object)humanoid != (Object)null && ((Component)humanoid).TryGetComponent<BaseAI>(ref val5)
				select humanoid;
			ItemDrop val3 = default(ItemDrop);
			foreach (Humanoid item2 in enumerable)
			{
				GameObject[] defaultItems = item2.m_defaultItems;
				foreach (GameObject val2 in defaultItems)
				{
					if ((Object)(object)val2 != (Object)null && val2.TryGetComponent<ItemDrop>(ref val3))
					{
						hashSet.Add(((Object)val2).name);
					}
				}
			}
			ItemDrop val4 = default(ItemDrop);
			foreach (GameObject item3 in ObjectDB.instance.m_items)
			{
				if (!((Object)(object)item3 == (Object)null) && item3.TryGetComponent<ItemDrop>(ref val4) && hashSet.Add(((Object)item3).name) && val4.m_itemData.m_shared.m_name.StartsWith("$", StringComparison.Ordinal) && val4.m_itemData.m_shared.m_description != null && (int)val4.m_itemData.m_shared.m_itemType != 0 && (int)val4.m_itemData.m_shared.m_itemType != 10)
				{
					list.Add(new string[6]
					{
						((Object)val4).name,
						Localization.instance.Localize(val4.m_itemData.m_shared.m_name),
						Math.Max(val4.m_itemData.m_shared.m_value, 0).ToString(CultureInfo.InvariantCulture),
						string.Empty,
						string.Empty,
						string.Empty
					});
				}
			}
			IEnumerable<string> contents = new string[1] { "prefab,name,sellPrice,buyPrice,stack,trader" }.Concat(from item in list.OrderByDescending<string[], string>((string[] item) => item[5], StringComparer.Ordinal).ThenBy<string[], string>((string[] item) => item[0], StringComparer.Ordinal)
				select string.Join(",", item.Select(CsvField)));
			string text = Path.Combine(configDirectory.FullName, "shudnal.TradersExtended");
			Directory.CreateDirectory(text);
			string path = Path.Combine(text, "ItemList.csv");
			File.WriteAllLines(path, contents, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
			context.AddString(string.Format("Saved {0} items to \"\\config\\{1}\\ItemList.csv\"", list.Count, "shudnal.TradersExtended"));
		}

		public static void FillConfigLists()
		{
			_ignoreItemDiscovery = new HashSet<string>(from value in (checkForDiscoveryIgnoreItems?.Value ?? string.Empty).Split(new char[1] { ',' })
				select value.Trim() into value
				where !string.IsNullOrWhiteSpace(value)
				select value, StringComparer.OrdinalIgnoreCase);
			_tradersToRepairWeapons = new HashSet<string>(from value in (tradersToRepairWeapons?.Value ?? string.Empty).Split(new char[1] { ',' })
				select TraderName(value.Trim()) into value
				where !string.IsNullOrWhiteSpace(value)
				select value, StringComparer.OrdinalIgnoreCase);
			_tradersToRepairArmor = new HashSet<string>(from value in (tradersToRepairArmor?.Value ?? string.Empty).Split(new char[1] { ',' })
				select TraderName(value.Trim()) into value
				where !string.IsNullOrWhiteSpace(value)
				select value, StringComparer.OrdinalIgnoreCase);
		}

		public static bool IgnoreItemDiscovery(string prefabName)
		{
			return !string.IsNullOrWhiteSpace(prefabName) && _ignoreItemDiscovery.Contains(prefabName);
		}

		public static void SetupConfigWatcher()
		{
			DisposeConfigWatchers();
			AddConfigWatcher(configDirectory);
			ReadConfigs();
		}

		private static void AddConfigWatcher(DirectoryInfo directory)
		{
			if (directory != null && directory.Exists)
			{
				FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(directory.FullName, "shudnal.TradersExtended.*")
				{
					IncludeSubdirectories = true,
					NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite),
					SynchronizingObject = ThreadingHelper.SynchronizingObject,
					EnableRaisingEvents = true
				};
				fileSystemWatcher.Changed += OnConfigFileChanged;
				fileSystemWatcher.Created += OnConfigFileChanged;
				fileSystemWatcher.Deleted += OnConfigFileChanged;
				fileSystemWatcher.Renamed += OnConfigFileChanged;
				configWatchers.Add(fileSystemWatcher);
			}
		}

		private static void DisposeConfigWatchers()
		{
			foreach (FileSystemWatcher configWatcher in configWatchers)
			{
				configWatcher.EnableRaisingEvents = false;
				configWatcher.Changed -= OnConfigFileChanged;
				configWatcher.Created -= OnConfigFileChanged;
				configWatcher.Deleted -= OnConfigFileChanged;
				configWatcher.Renamed -= OnConfigFileChanged;
				configWatcher.Dispose();
			}
			configWatchers.Clear();
		}

		private static void OnConfigFileChanged(object sender, FileSystemEventArgs args)
		{
			if (args == null || (Object)(object)instance == (Object)null)
			{
				return;
			}
			bool flag = IsSupportedConfigExtension(Path.GetExtension(args.FullPath));
			if (!flag && args is RenamedEventArgs e)
			{
				flag = IsSupportedConfigExtension(Path.GetExtension(e.OldFullPath));
			}
			if (flag)
			{
				if (configReloadCoroutine != null)
				{
					((MonoBehaviour)instance).StopCoroutine(configReloadCoroutine);
				}
				configReloadCoroutine = ((MonoBehaviour)instance).StartCoroutine(ReloadConfigsAfterFileWrite());
			}
		}

		private static IEnumerator ReloadConfigsAfterFileWrite()
		{
			yield return (object)new WaitForSecondsRealtime(0.25f);
			configReloadCoroutine = null;
			ReadConfigs();
		}

		internal static void ReadConfigs()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			Dictionary<string, PersonalTraderConfigSource> dictionary2 = new Dictionary<string, PersonalTraderConfigSource>(StringComparer.OrdinalIgnoreCase);
			int index = 0;
			index = AddEmbeddedConfigs(dictionary, dictionary2, index);
			AddDirectoryConfigs(dictionary, dictionary2, configDirectory, "config", index);
			Dictionary<string, string> dictionary3 = dictionary2.ToDictionary<KeyValuePair<string, PersonalTraderConfigSource>, string, string>((KeyValuePair<string, PersonalTraderConfigSource> pair) => BuildSyncedTraderConfigKey(pair.Key, pair.Value.FileName), (KeyValuePair<string, PersonalTraderConfigSource> pair) => pair.Value.Content, StringComparer.Ordinal);
			traderConfigFiles.AssignLocalValueAndNotify(dictionary3);
			itemConfigs.AssignLocalValueAndNotify(dictionary);
		}

		private static int AddDirectoryConfigs(Dictionary<string, string> itemTarget, Dictionary<string, PersonalTraderConfigSource> traderTarget, DirectoryInfo directory, string source, int index)
		{
			if (directory == null || !directory.Exists)
			{
				return index;
			}
			FileInfo[] source2;
			try
			{
				string editorDirectory = Path.GetFullPath(Path.Combine(Paths.ConfigPath, "shudnal.TradersExtended"));
				source2 = (from file in directory.GetFiles("*", SearchOption.AllDirectories)
					where IsSupportedConfigExtension(file.Extension)
					select file).Where(delegate(FileInfo file)
				{
					bool flag = file.Name.StartsWith("shudnal.TradersExtended.", StringComparison.OrdinalIgnoreCase);
					string fullPath = Path.GetFullPath(file.FullName);
					string text = editorDirectory;
					char directorySeparatorChar = Path.DirectorySeparatorChar;
					bool flag2 = fullPath.StartsWith(text + directorySeparatorChar, StringComparison.OrdinalIgnoreCase);
					return flag || flag2;
				}).OrderBy<FileInfo, string>((FileInfo file) => file.Name, StringComparer.OrdinalIgnoreCase).ThenBy<FileInfo, string>((FileInfo file) => file.FullName, StringComparer.OrdinalIgnoreCase)
					.ToArray();
			}
			catch (Exception ex)
			{
				LogWarning("Could not enumerate config files in '" + directory.FullName + "': " + ex.Message);
				return index;
			}
			ItemsListType listType;
			string trader;
			foreach (FileInfo item in source2.Where((FileInfo file) => TryParseConfigFileName(file.Name, out trader, out listType)))
			{
				try
				{
					string value = ReadFileContent(item);
					string key = BuildSyncedConfigKey(source, index++, item.Name);
					itemTarget[key] = value;
					LogInfo("Found item config " + item.FullName);
				}
				catch (Exception ex2)
				{
					LogWarning("Error reading item config '" + item.FullName + "': " + ex2.Message);
				}
			}
			foreach (IGrouping<string, FileInfo> item2 in (from file in source2
				select new
				{
					File = file,
					Parsed = TryParseTraderConfigFileName(file.Name, out trader),
					Trader = trader
				} into entry
				where entry.Parsed
				select entry).GroupBy(entry => TraderName(entry.Trader), entry => entry.File, StringComparer.OrdinalIgnoreCase))
			{
				FileInfo fileInfo = SelectPersonalTraderConfig(item2.Key, item2.ToArray(), (FileInfo file) => file.Extension, (FileInfo file) => file.FullName);
				if (fileInfo != null)
				{
					try
					{
						traderTarget[item2.Key] = new PersonalTraderConfigSource
						{
							FileName = fileInfo.Name,
							Content = ReadFileContent(fileInfo)
						};
						LogInfo("Found personal trader config " + fileInfo.FullName);
					}
					catch (Exception ex3)
					{
						LogWarning("Error reading personal trader config '" + fileInfo.FullName + "': " + ex3.Message);
					}
				}
			}
			return index;
		}

		private static string ReadFileContent(FileInfo file)
		{
			using FileStream stream = new FileStream(file.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
			using StreamReader streamReader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true);
			return streamReader.ReadToEnd();
		}

		private static int AddEmbeddedConfigs(Dictionary<string, string> itemTarget, Dictionary<string, PersonalTraderConfigSource> traderTarget, int index)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string[] array = (from resource in executingAssembly.GetManifestResourceNames()
				where resource.StartsWith("TradersExtended.Configs.", StringComparison.Ordinal) && IsSupportedConfigExtension(Path.GetExtension(resource))
				select resource).OrderBy<string, string>((string resource) => resource, StringComparer.Ordinal).ToArray();
			string[] array2 = array;
			foreach (string text in array2)
			{
				string text2 = text.Substring("TradersExtended.Configs.".Length);
				if (!TryParseConfigFileName(text2, out var trader, out var listType) && !TryParseConfigFileName("shudnal.TradersExtended." + text2, out trader, out listType) && !TryParseEmbeddedConfigName(text2, out trader, out listType))
				{
					continue;
				}
				try
				{
					using Stream stream = executingAssembly.GetManifestResourceStream(text);
					using StreamReader streamReader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true);
					string key = BuildSyncedConfigKey("internal", index++, text2);
					itemTarget[key] = streamReader.ReadToEnd();
					LogInfo("Found embedded item config " + text);
				}
				catch (Exception ex)
				{
					LogWarning("Error reading embedded item config '" + text + "': " + ex.Message);
				}
			}
			var enumerable = (from entry in array.Select(delegate(string resource)
				{
					string text3 = resource.Substring("TradersExtended.Configs.".Length);
					string trader2;
					bool parsed = TryParseTraderConfigFileName(text3, out trader2) || TryParseTraderConfigFileName("shudnal.TradersExtended." + text3, out trader2) || TryParseEmbeddedTraderConfigName(text3, out trader2);
					return new
					{
						Resource = resource,
						FileName = text3,
						Parsed = parsed,
						Trader = trader2
					};
				})
				where entry.Parsed
				select entry).GroupBy(entry => TraderName(entry.Trader), StringComparer.OrdinalIgnoreCase);
			foreach (var item in enumerable)
			{
				var anon = SelectPersonalTraderConfig(item.Key, item.ToArray(), entry => Path.GetExtension(entry.FileName), entry => entry.Resource);
				if (anon == null)
				{
					continue;
				}
				try
				{
					using Stream stream2 = executingAssembly.GetManifestResourceStream(anon.Resource);
					using StreamReader streamReader2 = new StreamReader(stream2, Encoding.UTF8, detectEncodingFromByteOrderMarks: true);
					traderTarget[item.Key] = new PersonalTraderConfigSource
					{
						FileName = anon.FileName,
						Content = streamReader2.ReadToEnd()
					};
					LogInfo("Found embedded personal trader config " + anon.Resource);
				}
				catch (Exception ex2)
				{
					LogWarning("Error reading embedded personal trader config '" + anon.Resource + "': " + ex2.Message);
				}
			}
			return index;
		}

		private static T SelectPersonalTraderConfig<T>(string trader, T[] candidates, Func<T, string> extensionSelector, Func<T, string> nameSelector) where T : class
		{
			if (candidates == null || candidates.Length == 0)
			{
				return null;
			}
			T selected = candidates.OrderBy((T candidate) => PersonalTraderConfigExtensionPriority(extensionSelector(candidate))).ThenBy<T, string>(nameSelector, StringComparer.OrdinalIgnoreCase).First();
			if (candidates.Length > 1)
			{
				string text = string.Join(", ", candidates.Where((T candidate) => candidate != selected).Select(nameSelector));
				LogWarning("Multiple personal config files were found for trader '" + trader + "'. Using '" + nameSelector(selected) + "' and ignoring: " + text);
			}
			return selected;
		}

		private static int PersonalTraderConfigExtensionPriority(string extension)
		{
			if (string.Equals(extension, ".json", StringComparison.OrdinalIgnoreCase))
			{
				return 0;
			}
			if (string.Equals(extension, ".yaml", StringComparison.OrdinalIgnoreCase))
			{
				return 1;
			}
			return 2;
		}

		private static bool TryParseEmbeddedConfigName(string fileName, out string trader, out ItemsListType listType)
		{
			trader = string.Empty;
			listType = ItemsListType.Buy;
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
			string text = "shudnal.TradersExtended.";
			string configName = (fileNameWithoutExtension.StartsWith(text, StringComparison.OrdinalIgnoreCase) ? fileNameWithoutExtension.Substring(text.Length) : fileNameWithoutExtension);
			return TryParseConfigName(configName, out trader, out listType);
		}

		internal static bool TryParseConfigFileName(string fileName, out string trader, out ItemsListType listType)
		{
			string identifier;
			return TryParseConfigFileName(fileName, out trader, out listType, out identifier);
		}

		internal static bool TryParseConfigFileName(string fileName, out string trader, out ItemsListType listType, out string identifier)
		{
			trader = string.Empty;
			listType = ItemsListType.Buy;
			identifier = string.Empty;
			string extension = Path.GetExtension(fileName);
			if (!IsSupportedItemConfigExtension(extension))
			{
				return false;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
			string text = "shudnal.TradersExtended.";
			string configName = (fileNameWithoutExtension.StartsWith(text, StringComparison.OrdinalIgnoreCase) ? fileNameWithoutExtension.Substring(text.Length) : fileNameWithoutExtension);
			return TryParseConfigName(configName, out trader, out listType, out identifier);
		}

		private static bool TryParseConfigName(string configName, out string trader, out ItemsListType listType)
		{
			string identifier;
			return TryParseConfigName(configName, out trader, out listType, out identifier);
		}

		private static bool TryParseConfigName(string configName, out string trader, out ItemsListType listType, out string identifier)
		{
			trader = string.Empty;
			listType = ItemsListType.Buy;
			identifier = string.Empty;
			if (string.IsNullOrWhiteSpace(configName))
			{
				return false;
			}
			string[] array = configName.Split(new char[1] { '.' });
			int num = 1;
			while (num < array.Length)
			{
				ItemsListType itemsListType;
				if (string.Equals(array[num], "Buy", StringComparison.OrdinalIgnoreCase))
				{
					itemsListType = ItemsListType.Buy;
				}
				else
				{
					if (!string.Equals(array[num], "Sell", StringComparison.OrdinalIgnoreCase))
					{
						num++;
						continue;
					}
					itemsListType = ItemsListType.Sell;
				}
				trader = string.Join(".", array.Take(num));
				if (string.IsNullOrWhiteSpace(trader))
				{
					return false;
				}
				identifier = string.Join(".", array.Skip(num + 1));
				listType = itemsListType;
				return true;
			}
			return false;
		}

		internal static bool TryParseTraderConfigFileName(string fileName, out string trader)
		{
			trader = string.Empty;
			if (!IsSupportedTraderConfigExtension(Path.GetExtension(fileName)))
			{
				return false;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
			string text = "shudnal.TradersExtended.";
			string configName = (fileNameWithoutExtension.StartsWith(text, StringComparison.OrdinalIgnoreCase) ? fileNameWithoutExtension.Substring(text.Length) : fileNameWithoutExtension);
			return TryParseTraderConfigName(configName, out trader);
		}

		private static bool TryParseEmbeddedTraderConfigName(string fileName, out string trader)
		{
			trader = string.Empty;
			if (!IsSupportedTraderConfigExtension(Path.GetExtension(fileName)))
			{
				return false;
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
			string text = "shudnal.TradersExtended.";
			string configName = (fileNameWithoutExtension.StartsWith(text, StringComparison.OrdinalIgnoreCase) ? fileNameWithoutExtension.Substring(text.Length) : fileNameWithoutExtension);
			return TryParseTraderConfigName(configName, out trader);
		}

		private static bool TryParseTraderConfigName(string configName, out string trader)
		{
			trader = string.Empty;
			if (string.IsNullOrWhiteSpace(configName) || !configName.EndsWith(".config", StringComparison.OrdinalIgnoreCase) || configName.Length <= ".config".Length)
			{
				return false;
			}
			trader = configName.Substring(0, configName.Length - ".config".Length);
			return !string.IsNullOrWhiteSpace(trader);
		}

		internal static bool IsSupportedConfigExtension(string extension)
		{
			return IsSupportedItemConfigExtension(extension) || IsSupportedTraderConfigExtension(extension);
		}

		internal static bool IsSupportedItemConfigExtension(string extension)
		{
			return string.Equals(extension, ".json", StringComparison.OrdinalIgnoreCase) || string.Equals(extension, ".yaml", StringComparison.OrdinalIgnoreCase) || string.Equals(extension, ".yml", StringComparison.OrdinalIgnoreCase) || string.Equals(extension, ".csv", StringComparison.OrdinalIgnoreCase);
		}

		internal static bool IsSupportedTraderConfigExtension(string extension)
		{
			return string.Equals(extension, ".json", StringComparison.OrdinalIgnoreCase) || string.Equals(extension, ".yaml", StringComparison.OrdinalIgnoreCase) || string.Equals(extension, ".yml", StringComparison.OrdinalIgnoreCase);
		}

		private static string BuildSyncedTraderConfigKey(string trader, string fileName)
		{
			return TraderName(trader) + "/" + fileName;
		}

		internal static bool TryParseSyncedTraderConfigKey(string key, out string trader, out string fileName)
		{
			trader = string.Empty;
			fileName = string.Empty;
			if (string.IsNullOrWhiteSpace(key))
			{
				return false;
			}
			int num = key.IndexOf('/');
			if (num <= 0 || num >= key.Length - 1)
			{
				return false;
			}
			trader = key.Substring(0, num);
			fileName = key.Substring(num + 1);
			if (!TryParseTraderConfigFileName(fileName, out var trader2) && !TryParseEmbeddedTraderConfigName(fileName, out trader2))
			{
				return false;
			}
			return string.Equals(TraderName(trader), TraderName(trader2), StringComparison.OrdinalIgnoreCase);
		}

		private static string BuildSyncedConfigKey(string source, int index, string fileName)
		{
			return source + "/" + index.ToString("D6") + "/" + fileName;
		}

		private static bool TryGetSyncedConfigMetadata(string key, out string source, out int index, out string fileName)
		{
			source = string.Empty;
			index = -1;
			fileName = string.Empty;
			if (string.IsNullOrWhiteSpace(key))
			{
				return false;
			}
			int num = key.IndexOf('/');
			if (num <= 0)
			{
				return false;
			}
			int num2 = key.IndexOf('/', num + 1);
			if (num2 <= num + 1 || num2 >= key.Length - 1)
			{
				return false;
			}
			source = key.Substring(0, num);
			if (!int.TryParse(key.Substring(num + 1, num2 - num - 1), out index))
			{
				return false;
			}
			fileName = key.Substring(num2 + 1);
			return !string.IsNullOrWhiteSpace(fileName);
		}

		private static void StartConfigLoad()
		{
			if (!((Object)(object)instance == (Object)null))
			{
				if (configLoadCoroutine != null)
				{
					((MonoBehaviour)instance).StopCoroutine(configLoadCoroutine);
				}
				configLoadCoroutine = ((MonoBehaviour)instance).StartCoroutine(LoadConfigs());
			}
		}

		private static IEnumerator LoadConfigs()
		{
			yield return null;
			tradeableItems.Clear();
			sellableItems.Clear();
			Dictionary<string, string> synchronizedConfigs = itemConfigs.Value ?? new Dictionary<string, string>();
			foreach (KeyValuePair<string, string> itemConfig in (from pair in synchronizedConfigs
				orderby ConfigSourcePriority(pair.Key), ConfigSourceOrder(pair.Key)
				select pair).ThenBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> pair) => pair.Key, StringComparer.Ordinal))
			{
				if (!TryParseSyncedConfigKey(itemConfig.Key, out var trader, out var listType, out var fileName))
				{
					continue;
				}
				List<TradeableItem> items = DeserializeItems(itemConfig.Value, fileName);
				if (items != null)
				{
					string listKey = TraderListKey(trader, listType);
					Dictionary<string, List<TradeableItem>> destination = ((listType == ItemsListType.Buy) ? tradeableItems : sellableItems);
					if (!destination.TryGetValue(listKey, out var currentItems))
					{
						currentItems = new List<TradeableItem>();
						destination.Add(listKey, currentItems);
					}
					currentItems.AddRange(items.Where((TradeableItem item) => item != null));
					LogInfo($"Loaded {items.Count} {listType.ToString().ToLowerInvariant()} item entries from {fileName}");
					trader = null;
					fileName = null;
					currentItems = null;
				}
			}
			yield return AddCommonValuableItems();
			TooltipPrices.Rebuild();
			configLoadCoroutine = null;
			if ((Object)(object)StoreGui.instance != (Object)null && (Object)(object)StoreGui.instance.m_trader != (Object)null && StoreGui.IsVisible())
			{
				StoreGui.instance.FillList();
			}
		}

		private static bool TryParseSyncedConfigKey(string key, out string trader, out ItemsListType listType, out string fileName)
		{
			trader = string.Empty;
			listType = ItemsListType.Buy;
			fileName = key ?? string.Empty;
			if (TryGetSyncedConfigMetadata(key, out var _, out var _, out var fileName2))
			{
				fileName = fileName2;
				return TryParseConfigFileName(fileName, out trader, out listType) || TryParseEmbeddedConfigName(fileName, out trader, out listType);
			}
			if (string.IsNullOrWhiteSpace(key))
			{
				return false;
			}
			foreach (ItemsListType value2 in Enum.GetValues(typeof(ItemsListType)))
			{
				string value = "." + value2.ToString() + ".";
				int num = key.LastIndexOf(value, StringComparison.OrdinalIgnoreCase);
				if (num <= 0)
				{
					continue;
				}
				trader = key.Substring(0, num);
				listType = value2;
				return true;
			}
			return false;
		}

		private static int ConfigSourcePriority(string key)
		{
			if (TryGetSyncedConfigMetadata(key, out var source, out var _, out var _))
			{
				if (string.Equals(source, "internal", StringComparison.OrdinalIgnoreCase))
				{
					return 0;
				}
				if (string.Equals(source, "plugin", StringComparison.OrdinalIgnoreCase))
				{
					return 1;
				}
				return 2;
			}
			if (key.IndexOf(".internal.", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return 0;
			}
			if (key.IndexOf(".plugin.", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return 1;
			}
			return 2;
		}

		private static int ConfigSourceOrder(string key)
		{
			string source;
			int index;
			string fileName;
			return TryGetSyncedConfigMetadata(key, out source, out index, out fileName) ? index : int.MaxValue;
		}

		internal static List<TradeableItem> DeserializeItems(string content, string source)
		{
			if (string.IsNullOrWhiteSpace(content))
			{
				return new List<TradeableItem>();
			}
			try
			{
				string extension = Path.GetExtension(source);
				if (string.Equals(extension, ".json", StringComparison.OrdinalIgnoreCase))
				{
					return JsonConvert.DeserializeObject<List<TradeableItem>>(content) ?? new List<TradeableItem>();
				}
				if (string.Equals(extension, ".yaml", StringComparison.OrdinalIgnoreCase) || string.Equals(extension, ".yml", StringComparison.OrdinalIgnoreCase))
				{
					return yamlDeserializer.Deserialize<List<TradeableItem>>(content) ?? new List<TradeableItem>();
				}
				if (string.Equals(extension, ".csv", StringComparison.OrdinalIgnoreCase))
				{
					return DeserializeCsvItems(content, source);
				}
				string text = content.TrimStart(Array.Empty<char>());
				return (text.StartsWith("[", StringComparison.Ordinal) || text.StartsWith("{", StringComparison.Ordinal)) ? (JsonConvert.DeserializeObject<List<TradeableItem>>(content) ?? new List<TradeableItem>()) : (yamlDeserializer.Deserialize<List<TradeableItem>>(content) ?? new List<TradeableItem>());
			}
			catch (Exception ex)
			{
				LogWarning("Error parsing item config '" + source + "': " + ex.Message);
				return null;
			}
		}

		private static List<TradeableItem> DeserializeCsvItems(string content, string source)
		{
			List<List<string>> list = ParseCsv(content);
			if (list.Count == 0)
			{
				return new List<TradeableItem>();
			}
			string[] array = list[0].Select((string header, int index) => (index == 0) ? (header ?? string.Empty).TrimStart(new char[1] { '\ufeff' }).Trim() : (header ?? string.Empty).Trim()).ToArray();
			HashSet<string> supportedHeaders = new HashSet<string>(new string[9] { "prefab", "stack", "price", "quality", "currency", "requiredGlobalKey", "notRequiredGlobalKey", "requiredPlayerKey", "notRequiredPlayerKey" }, StringComparer.OrdinalIgnoreCase);
			if (!array.Any((string header) => string.Equals(header, "prefab", StringComparison.OrdinalIgnoreCase)))
			{
				throw new FormatException("CSV item configs must contain the 'prefab' header.");
			}
			string[] array2 = array.Where((string header) => !string.IsNullOrWhiteSpace(header) && !supportedHeaders.Contains(header)).ToArray();
			if (array2.Length != 0)
			{
				LogWarning("Ignored unknown CSV headers in '" + source + "': " + string.Join(", ", array2));
			}
			List<TradeableItem> list2 = new List<TradeableItem>();
			for (int num = 1; num < list.Count; num++)
			{
				List<string> list3 = list[num];
				if (list3.All(string.IsNullOrWhiteSpace))
				{
					continue;
				}
				TradeableItem tradeableItem = new TradeableItem();
				for (int num2 = 0; num2 < array.Length; num2++)
				{
					string text = array[num2];
					if (string.IsNullOrWhiteSpace(text) || !supportedHeaders.Contains(text))
					{
						continue;
					}
					string text2 = ((num2 < list3.Count) ? (list3[num2] ?? string.Empty) : string.Empty);
					if (!string.IsNullOrEmpty(text2))
					{
						if (string.Equals(text, "prefab", StringComparison.OrdinalIgnoreCase))
						{
							tradeableItem.prefab = text2.Trim();
						}
						else if (string.Equals(text, "stack", StringComparison.OrdinalIgnoreCase))
						{
							tradeableItem.stack = ParseCsvInt(text2, source, num + 1, text);
						}
						else if (string.Equals(text, "price", StringComparison.OrdinalIgnoreCase))
						{
							tradeableItem.price = ParseCsvInt(text2, source, num + 1, text);
						}
						else if (string.Equals(text, "quality", StringComparison.OrdinalIgnoreCase))
						{
							tradeableItem.quality = ParseCsvInt(text2, source, num + 1, text);
						}
						else if (string.Equals(text, "currency", StringComparison.OrdinalIgnoreCase))
						{
							tradeableItem.currency = text2.Trim();
						}
						else if (string.Equals(text, "requiredGlobalKey", StringComparison.OrdinalIgnoreCase))
						{
							tradeableItem.requiredGlobalKey = text2.Trim();
						}
						else if (string.Equals(text, "notRequiredGlobalKey", StringComparison.OrdinalIgnoreCase))
						{
							tradeableItem.notRequiredGlobalKey = text2.Trim();
						}
						else if (string.Equals(text, "requiredPlayerKey", StringComparison.OrdinalIgnoreCase))
						{
							tradeableItem.requiredPlayerKey = text2.Trim();
						}
						else if (string.Equals(text, "notRequiredPlayerKey", StringComparison.OrdinalIgnoreCase))
						{
							tradeableItem.notRequiredPlayerKey = text2.Trim();
						}
					}
				}
				if (string.IsNullOrWhiteSpace(tradeableItem.prefab))
				{
					LogWarning($"Ignored CSV row {num + 1} in '{source}' because prefab is empty.");
				}
				else
				{
					list2.Add(tradeableItem);
				}
			}
			return list2;
		}

		private static int ParseCsvInt(string value, string source, int row, string header)
		{
			if (int.TryParse(value.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			throw new FormatException($"Invalid integer '{value}' in row {row}, column '{header}' of '{source}'.");
		}

		private static List<List<string>> ParseCsv(string content)
		{
			List<List<string>> list = new List<List<string>>();
			List<string> list2 = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = false;
			for (int i = 0; i < content.Length; i++)
			{
				char c = content[i];
				if (flag)
				{
					if (c == '"')
					{
						if (i + 1 < content.Length && content[i + 1] == '"')
						{
							stringBuilder.Append('"');
							i++;
						}
						else
						{
							flag = false;
						}
					}
					else
					{
						stringBuilder.Append(c);
					}
					continue;
				}
				if (c == '"' && stringBuilder.Length == 0)
				{
					flag = true;
					continue;
				}
				switch (c)
				{
				case ',':
					list2.Add(stringBuilder.ToString());
					stringBuilder.Clear();
					break;
				default:
					if (c != '\n')
					{
						stringBuilder.Append(c);
						break;
					}
					goto case '\r';
				case '\r':
					if (c == '\r' && i + 1 < content.Length && content[i + 1] == '\n')
					{
						i++;
					}
					list2.Add(stringBuilder.ToString());
					stringBuilder.Clear();
					list.Add(list2);
					list2 = new List<string>();
					break;
				}
			}
			if (flag)
			{
				throw new FormatException("CSV contains an unterminated quoted field.");
			}
			if (stringBuilder.Length > 0 || list2.Count > 0)
			{
				list2.Add(stringBuilder.ToString());
				list.Add(list2);
			}
			return list;
		}

		private static IEnumerator AddCommonValuableItems()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)ObjectDB.instance != (Object)null));
			string listKey = CommonListKey(ItemsListType.Sell);
			if (!sellableItems.TryGetValue(listKey, out var commonItems))
			{
				commonItems = new List<TradeableItem>();
				sellableItems[listKey] = commonItems;
			}
			HashSet<string> existingPrefabs = new HashSet<string>(from item in commonItems
				where item != null && !string.IsNullOrWhiteSpace(item.prefab)
				select item.prefab, StringComparer.OrdinalIgnoreCase);
			int initialCount = commonItems.Count;
			ItemDrop itemDrop = default(ItemDrop);
			foreach (GameObject prefab in ObjectDB.instance.m_items)
			{
				if (!((Object)(object)prefab == (Object)null) && !string.Equals(((Object)prefab).name, "Coins", StringComparison.OrdinalIgnoreCase) && prefab.TryGetComponent<ItemDrop>(ref itemDrop) && itemDrop.m_itemData.m_shared.m_value > 0 && existingPrefabs.Add(((Object)prefab).name))
				{
					commonItems.Add(new TradeableItem
					{
						prefab = ((Object)prefab).name,
						price = itemDrop.m_itemData.m_shared.m_value,
						automatic = true
					});
					itemDrop = null;
				}
			}
			LogInfo($"Loaded {commonItems.Count - initialCount} common valuable items from ObjectDB");
		}

		internal static string TraderName(Trader trader)
		{
			return ((Object)(object)trader == (Object)null) ? string.Empty : TraderName(Utils.GetPrefabName(((Component)trader).gameObject));
		}

		internal static string TraderName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return string.Empty;
			}
			return name.Trim().ToLowerInvariant().Replace("$npc_", string.Empty)
				.Replace("npc_", string.Empty);
		}

		public static string TraderListKey(Trader trader, ItemsListType type)
		{
			return TraderListKey(TraderName(trader), type);
		}

		public static string TraderListKey(string name, ItemsListType type)
		{
			return TraderName(name) + "." + type;
		}

		public static string CommonListKey(ItemsListType type)
		{
			return TraderListKey("common", type);
		}
	}
	internal static class TraderCoins
	{
		internal enum BalanceOperation
		{
			Spend,
			Receive
		}

		private sealed class BalanceTransaction : IDisposable
		{
			private readonly BalanceOperation operation;

			private bool disposed;

			internal BalanceTransaction(BalanceOperation operation)
			{
				this.operation = operation;
				if (operation == BalanceOperation.Spend)
				{
					spendTransactionDepth++;
				}
				else
				{
					receiveTransactionDepth++;
				}
			}

			public void Dispose()
			{
				if (!disposed)
				{
					disposed = true;
					if (operation == BalanceOperation.Spend)
					{
						spendTransactionDepth = Math.Max(spendTransactionDepth - 1, 0);
					}
					else
					{
						receiveTransactionDepth = Math.Max(receiveTransactionDepth - 1, 0);
					}
				}
			}
		}

		[HarmonyPatch(typeof(EnvMan), "UpdateTriggers")]
		public static class EnvMan_UpdateTriggers_TraderCoinsUpdate
		{
			private static bool IsMorning(float oldDayFraction, float newDayFraction)
			{
				return oldDayFraction > 0.2f && oldDayFraction < 0.25f && newDayFraction >= 0.25f && newDayFraction < 0.3f;
			}

			private static void Postfix(float oldDayFraction, float newDayFraction)
			{
				if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && IsMorning(oldDayFraction, newDayFraction) && UpdateTradersCoinsDaily())
				{
					MessageHud instance = MessageHud.instance;
					if (instance != null)
					{
						instance.MessageAll((MessageType)1, "$store_topic: $msg_added");
					}
				}
			}
		}

		[HarmonyPatch(typeof(StoreGui), "Update")]
		public static class StoreGui_Update_PlayerTraderCoinsUpdate
		{
			private static void Postfix(StoreGui __instance)
			{
				if (!StorePanel.IsOpen())
				{
					return;
				}
				TMP_Text playerCoins = TraderCoins.playerCoins;
				if (playerCoins != null)
				{
					playerCoins.SetText(__instance.GetPlayerCoins().ToString());
				}
				if (GetCurrentConfig().TradersUseCoins)
				{
					TMP_Text traderCoins = TraderCoins.traderCoins;
					if (traderCoins != null)
					{
						traderCoins.SetText(GetTraderCoins().ToString());
					}
				}
				if (ZInput.GamepadActive)
				{
					StorePanel.UpdateNames();
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "RemoveItem", new Type[]
		{
			typeof(string),
			typeof(int),
			typeof(int),
			typeof(bool)
		})]
		public static class Inventory_RemoveItem_TraderCoinsUpdate
		{
			private static void Prefix(Inventory __instance, string name, ref int __state)
			{
				__state = ((spendTransactionDepth > 0 && IsActiveCurrencySharedName(name) && IsLocalPlayerInventory(__instance)) ? __instance.CountItems(name, -1, true) : (-1));
			}

			private static void Postfix(Inventory __instance, string name, int __state)
			{
				if (__state >= 0)
				{
					int num = __state - __instance.CountItems(name, -1, true);
					if (num > 0)
					{
						UpdateTraderCoins(num);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(string),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(long),
			typeof(string),
			typeof(bool)
		})]
		public static class Inventory_AddItem_String_TraderCoinsUpdate
		{
			private static void Prefix(Inventory __instance, string name, ref int __state)
			{
				ItemDrop activeCurrency = GetActiveCurrency();
				__state = ((receiveTransactionDepth > 0 && (Object)(object)activeCurrency != (Object)null && IsActiveCurrencyPrefabName(name) && IsLocalPlayerInventory(__instance)) ? __instance.CountItems(activeCurrency.m_itemData.m_shared.m_name, -1, true) : (-1));
			}

			private static void Postfix(Inventory __instance, int __state)
			{
				if (__state < 0)
				{
					return;
				}
				ItemDrop activeCurrency = GetActiveCurrency();
				if (!((Object)(object)activeCurrency == (Object)null))
				{
					int num = __instance.CountItems(activeCurrency.m_itemData.m_shared.m_name, -1, true) - __state;
					if (num > 0)
					{
						UpdateTraderCoins(-num);
					}
				}
			}
		}

		private static Trader currentTrader;

		private static ZNetView traderNetView;

		private static int spendTransactionDepth;

		private static int receiveTransactionDepth;

		public static TMP_Text playerCoins;

		public static TMP_Text traderCoins;

		public static GameObject traderCoinsPanel;

		private static readonly int s_traderCoins = StringExtensionMethods.GetStableHashCode("traderCoins");

		private static readonly int s_traderCoinsReplenished = StringExtensionMethods.GetStableHashCode("traderCoinsReplenished");

		internal static IDisposable BeginBalanceTransaction(BalanceOperation operation)
		{
			return new BalanceTransaction(operation);
		}

		public static List<string> GetTraderPrefabs()
		{
			HashSet<string> hashSet = new HashSet<string>(new string[3] { "Haldor", "Hildir", "BogWitch" }, StringComparer.OrdinalIgnoreCase);
			hashSet.UnionWith(from value in (TradersExtended.tradersCustomPrefabs?.Value ?? string.Empty).Split(new char[4] { ',', ';', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)
				select value.Trim() into value
				where !string.IsNullOrWhiteSpace(value)
				select value);
			hashSet.UnionWith(TraderConfigManager.GetKnownTraderNames());
			return hashSet.OrderBy<string, string>((string value) => value, StringComparer.OrdinalIgnoreCase).ToList();
		}

		public static void ResetCurrentTrader(Trader trader)
		{
			currentTrader = trader;
			traderNetView = (((Object)(object)trader != (Object)null) ? ((Component)trader).GetComponent<ZNetView>() : null);
		}

		public static void SetTraderCoins(string traderName, int newAmount)
		{
			if (!Object.op_Implicit((Object)(object)EnvMan.instance) || !Object.op_Implicit((Object)(object)ZNetScene.instance) || ZDOMan.instance == null || string.IsNullOrWhiteSpace(traderName))
			{
				return;
			}
			string b = TradersExtended.TraderName(traderName);
			foreach (ZDO item in ZDOMan.instance.m_objectsByID.Values.Where((ZDO zdo) => zdo != null))
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(item.GetPrefab());
				string text = ((prefab != null) ? ((Object)prefab).name : null);
				if (string.Equals(TradersExtended.TraderName(text), b, StringComparison.OrdinalIgnoreCase))
				{
					SetTraderCoins(item, text, newAmount);
				}
			}
		}

		public static void SetTraderCoins(int prefab, int newAmount)
		{
			if (!Object.op_Implicit((Object)(object)EnvMan.instance) || !Object.op_Implicit((Object)(object)ZNetScene.instance) || ZDOMan.instance == null)
			{
				return;
			}
			foreach (ZDO item in ZDOMan.instance.m_objectsByID.Values.Where((ZDO zdo) => zdo != null && prefab == zdo.GetPrefab()))
			{
				GameObject prefab2 = ZNetScene.instance.GetPrefab(item.GetPrefab());
				SetTraderCoins(item, (prefab2 != null) ? ((Object)prefab2).name : null, newAmount);
			}
		}

		private static void SetTraderCoins(ZDO zdo, string prefabName, int newAmount)
		{
			int num = zdo.GetInt(s_traderCoins, 0);
			int num2 = Math.Max(newAmount, 0);
			zdo.Set(s_traderCoins, num2, false);
			zdo.Set(s_traderCoinsReplenished, EnvMan.instance.GetCurrentDay(), false);
			TradersExtended.LogInfo($"{prefabName} balance updated {num} -> {num2}");
		}

		public static bool UpdateTradersCoinsDaily()
		{
			if (!Object.op_Implicit((Object)(object)EnvMan.instance) || !Object.op_Implicit((Object)(object)ZNetScene.instance) || ZDOMan.instance == null)
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(TraderConfigManager.GetKnownTraderNames(), StringComparer.OrdinalIgnoreCase);
			bool flag = false;
			foreach (ZDO item in ZDOMan.instance.m_objectsByID.Values.Where((ZDO zdo) => zdo != null))
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(item.GetPrefab());
				string text = ((prefab != null) ? ((Object)prefab).name : null);
				if (string.IsNullOrWhiteSpace(text) || !hashSet.Contains(TradersExtended.TraderName(text)))
				{
					continue;
				}
				ResolvedTraderConfig resolvedTraderConfig = TraderConfigManager.Get(text);
				if (!resolvedTraderConfig.TradersUseCoins)
				{
					continue;
				}
				int num = item.GetInt(s_traderCoinsReplenished, 0);
				if (EnvMan.instance.GetCurrentDay() - num >= Math.Max(resolvedTraderConfig.TraderCoinsReplenishmentRateInDays, 1))
				{
					int num2 = Math.Max(resolvedTraderConfig.CoinsAfterReplenishmentMinimum, 0);
					int num3 = Math.Max(resolvedTraderConfig.CoinsAfterReplenishmentMaximum, num2);
					int num4 = item.GetInt(s_traderCoins, num2);
					if (num4 < num3 || resolvedTraderConfig.CoinsRemovedDaily > 0)
					{
						int num5 = ((num4 >= num3) ? Math.Max(num3, num4 - Math.Max(resolvedTraderConfig.CoinsRemovedDaily, 0)) : Mathf.Clamp(num4 + resolvedTraderConfig.CoinsReplenishedDaily, num2, num3));
						item.Set(s_traderCoins, num5, false);
						item.Set(s_traderCoinsReplenished, EnvMan.instance.GetCurrentDay(), false);
						flag |= resolvedTraderConfig.SendReplenishmentMessageInTheMorning;
						TradersExtended.LogInfo($"{text} balance updated {num4} -> {num5}");
					}
				}
			}
			return flag;
		}

		private static bool IsLocalPlayerInventory(Inventory inventory)
		{
			return StorePanel.IsOpen() && (Object)(object)Player.m_localPlayer != (Object)null && ((Humanoid)Player.m_localPlayer).GetInventory() == inventory;
		}

		private static ItemDrop GetActiveCurrency()
		{
			return ((Object)(object)StoreGui.instance != (Object)null) ? StoreGui.instance.m_coinPrefab : null;
		}

		private static bool IsActiveCurrencySharedName(string name)
		{
			ItemDrop activeCurrency = GetActiveCurrency();
			return (Object)(object)activeCurrency != (Object)null && string.Equals(name, activeCurrency.m_itemData.m_shared.m_name, StringComparison.Ordinal);
		}

		private static bool IsActiveCurrencyPrefabName(string name)
		{
			ItemDrop activeCurrency = GetActiveCurrency();
			return (Object)(object)activeCurrency != (Object)null && string.Equals(name, Utils.GetPrefabName(((Component)activeCurrency).gameObject), StringComparison.Ordinal);
		}

		public static bool CanSell(int price)
		{
			return !GetCurrentConfig().TradersUseCoins || price <= GetTraderCoins();
		}

		public static void UpdateTraderCoins(int amountToAdd = 0)
		{
			if (!GetCurrentConfig().TradersUseCoins)
			{
				return;
			}
			ZNetView val = GetTraderNetView();
			if (!((Object)(object)val == (Object)null) && val.IsValid())
			{
				val.GetZDO().Set(s_traderCoins, Math.Max(GetTraderCoins() + amountToAdd, 0), false);
				if (StorePanel.IsOpen())
				{
					StorePanel.UpdateNames();
				}
			}
		}

		public static float GetPriceFactor(bool buyPrice)
		{
			int coins = GetTraderCoins();
			return buyPrice ? GetTraderBuyPriceFactor(coins) : GetTraderSellPriceFactor(coins);
		}

		public static void UpdateTraderCoinsVisibility()
		{
			GameObject obj = traderCoinsPanel;
			if (obj != null)
			{
				obj.SetActive(GetCurrentConfig().TradersUseCoins);
			}
		}

		public static int GetTraderCoins()
		{
			ZNetView val = GetTraderNetView();
			int num = Math.Max(GetCurrentConfig().CoinsAfterReplenishmentMinimum, 0);
			if ((Object)(object)val == (Object)null || !val.IsValid())
			{
				return num;
			}
			return val.GetZDO().GetInt(s_traderCoins, num);
		}

		private static ZNetView GetTraderNetView()
		{
			Trader val = (((Object)(object)currentTrader != (Object)null) ? currentTrader : StoreGui.instance?.m_trader);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if ((Object)(object)traderNetView == (Object)null || (Object)(object)((Component)traderNetView).gameObject != (Object)(object)((Component)val).gameObject)
			{
				currentTrader = val;
				traderNetView = ((Component)val).GetComponent<ZNetView>();
			}
			return traderNetView;
		}

		private static float GetTraderBuyPriceFactor(int coins)
		{
			ResolvedTraderConfig currentConfig = GetCurrentConfig();
			if (!currentConfig.TradersUseFlexiblePricing)
			{
				return 1f;
			}
			GetPriceRange(currentConfig, out var minimum, out var maximum);
			if (coins < minimum)
			{
				float num = ((minimum > 0) ? Mathf.Clamp01((float)coins / (float)minimum) : 1f);
				return RoundFactorToPercent(Mathf.Lerp(currentConfig.TraderMarkup, 1f, num));
			}
			float num2 = Mathf.Clamp01((float)(coins - minimum) / (float)Math.Max(maximum - minimum, 1));
			return RoundFactorToPercent(Mathf.Lerp(1f, currentConfig.TraderDiscount, num2));
		}

		private static float GetTraderSellPriceFactor(int coins)
		{
			ResolvedTraderConfig currentConfig = GetCurrentConfig();
			if (!currentConfig.TradersUseFlexiblePricing)
			{
				return 1f;
			}
			GetPriceRange(currentConfig, out var minimum, out var maximum);
			if (coins < minimum)
			{
				float num = ((minimum > 0) ? Mathf.Clamp01((float)coins / (float)minimum) : 1f);
				return RoundFactorToPercent(Mathf.Lerp(currentConfig.TraderDiscount, 1f, num));
			}
			float num2 = Mathf.Clamp01((float)(coins - minimum) / (float)Math.Max(maximum - minimum, 1));
			return RoundFactorToPercent(Mathf.Lerp(1f, currentConfig.TraderMarkup, num2));
		}

		private static void GetPriceRange(ResolvedTraderConfig config, out int minimum, out int maximum)
		{
			minimum = Math.Max(config.CoinsAfterReplenishmentMinimum, 0);
			maximum = Math.Max(config.CoinsAfterReplenishmentMaximum, minimum + 1);
		}

		private static ResolvedTraderConfig GetCurrentConfig()
		{
			Trader trader = (((Object)(object)currentTrader != (Object)null) ? currentTrader : StoreGui.instance?.m_trader);
			return TraderConfigManager.Get(trader);
		}

		private static float RoundFactorToPercent(float factor)
		{
			return Mathf.Round(factor * 100f) / 100f;
		}
	}
	internal static class TraderCurrency
	{
		private sealed class CurrencyReference
		{
			internal readonly string PrefabName;

			internal CurrencyReference(string prefabName)
			{
				PrefabName = prefabName;
			}
		}

		private static readonly ConditionalWeakTable<TradeItem, CurrencyReference> itemCurrencies = new ConditionalWeakTable<TradeItem, CurrencyReference>();

		private static readonly HashSet<string> invalidCurrenciesLogged = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static ItemDrop vanillaCurrencyPrefab;

		internal static void CaptureVanillaCurrency(StoreGui storeGui)
		{
			if ((Object)(object)vanillaCurrencyPrefab == (Object)null && (Object)(object)storeGui != (Object)null && (Object)(object)storeGui.m_coinPrefab != (Object)null)
			{
				vanillaCurrencyPrefab = storeGui.m_coinPrefab;
			}
		}

		internal static void RebuildOverrides()
		{
			if ((Object)(object)StoreGui.instance != (Object)null)
			{
				ApplyTraderCurrency(StoreGui.instance);
				if (StoreGui.IsVisible() && (Object)(object)StoreGui.instance.m_trader != (Object)null)
				{
					StoreGui.instance.FillList();
				}
			}
			TooltipPrices.Rebuild();
		}

		internal static void ApplyTraderCurrency(StoreGui storeGui, Trader trader = null)
		{
			if (!((Object)(object)storeGui == (Object)null))
			{
				CaptureVanillaCurrency(storeGui);
				ItemDrop val = vanillaCurrencyPrefab;
				string traderCurrencyPrefabName = GetTraderCurrencyPrefabName(trader ?? storeGui.m_trader);
				if (!string.IsNullOrEmpty(traderCurrencyPrefabName))
				{
					val = ResolveCurrency(traderCurrencyPrefabName) ?? vanillaCurrencyPrefab;
				}
				if ((Object)(object)val != (Object)null)
				{
					storeGui.m_coinPrefab = val;
				}
				StorePanel.UpdateCurrencyVisuals(storeGui);
			}
		}

		internal static string GetTraderCurrencyPrefabName(Trader trader)
		{
			return ((Object)(object)trader == (Object)null) ? string.Empty : TraderConfigManager.Get(trader).TraderCurrencyPrefab;
		}

		internal static string GetTraderCurrencyPrefabName(string traderName)
		{
			return TraderConfigManager.Get(traderName).TraderCurrencyPrefab;
		}

		internal static void RegisterCurrency(TradeItem tradeItem, string currencyPrefab, Trader trader)
		{
			if (tradeItem != null)
			{
				string text = (string.IsNullOrWhiteSpace(currencyPrefab) ? GetTraderCurrencyPrefabName(trader) : currencyPrefab.Trim());
				itemCurrencies.Remove(tradeItem);
				if (!string.IsNullOrEmpty(text))
				{
					itemCurrencies.Add(tradeItem, new CurrencyReference(text));
				}
			}
		}

		internal static void RegisterCurrency(TradeItem tradeItem, ItemDrop currency, Trader trader)
		{
			RegisterCurrency(tradeItem, ((Object)(object)currency != (Object)null) ? Utils.GetPrefabName(((Component)currency).gameObject) : string.Empty, trader);
		}

		internal static void CopyCurrency(TradeItem source, TradeItem destination)
		{
			if (source != null && destination != null && itemCurrencies.TryGetValue(source, out var value))
			{
				itemCurrencies.Remove(destination);
				itemCurrencies.Add(destination, value);
			}
		}

		internal static ItemDrop GetCurrency(string currencyPrefab, StoreGui storeGui)
		{
			if (!string.IsNullOrWhiteSpace(currencyPrefab))
			{
				ItemDrop val = ResolveCurrency(currencyPrefab.Trim());
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return ((Object)(object)storeGui != (Object)null) ? storeGui.m_coinPrefab : vanillaCurrencyPrefab;
		}

		internal static ItemDrop GetCurrency(TradeItem tradeItem, StoreGui storeGui)
		{
			if (tradeItem != null && itemCurrencies.TryGetValue(tradeItem, out var value))
			{
				ItemDrop val = ResolveCurrency(value.PrefabName);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return ((Object)(object)storeGui != (Object)null) ? storeGui.m_coinPrefab : vanillaCurrencyPrefab;
		}

		internal static int GetPlayerCurrencyAmount(TradeItem tradeItem, StoreGui storeGui)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return 0;
			}
			ItemDrop currency = GetCurrency(tradeItem, storeGui);
			return (!((Object)(object)currency == (Object)null)) ? ((Humanoid)Player.m_localPlayer).GetInventory().CountItems(currency.m_itemData.m_shared.m_name, -1, true) : 0;
		}

		internal static bool UsesStoreCurrency(TradeItem tradeItem, StoreGui storeGui)
		{
			ItemDrop currency = GetCurrency(tradeItem, storeGui);
			return (Object)(object)currency == (Object)null || (Object)(object)storeGui == (Object)null || (Object)(object)storeGui.m_coinPrefab == (Object)null || currency.m_itemData.m_shared.m_name == storeGui.m_coinPrefab.m_itemData.m_shared.m_name;
		}

		internal static string GetCurrencyName(ItemDrop currency)
		{
			if ((Object)(object)currency == (Object)null)
			{
				return string.Empty;
			}
			return (Localization.instance != null) ? Localization.instance.Localize(currency.m_itemData.m_shared.m_name) : currency.m_itemData.m_shared.m_name;
		}

		internal static string GetCurrencyName(TradeItem tradeItem, StoreGui storeGui)
		{
			return GetCurrencyName(GetCurrency(tradeItem, storeGui));
		}

		internal static string GetCurrencyName(string currencyPrefab)
		{
			return GetCurrencyName(ResolveCurrency(currencyPrefab));
		}

		internal static string GetConfiguredCurrencyName(string traderName)
		{
			string traderCurrencyPrefabName = GetTraderCurrencyPrefabName(traderName);
			ItemDrop currency = (string.IsNullOrEmpty(traderCurrencyPrefabName) ? vanillaCurrencyPrefab : (ResolveCurrency(traderCurrencyPrefabName) ?? vanillaCurrencyPrefab));
			return GetCurrencyName(currency);
		}

		internal static ItemDrop GetVanillaCurrency()
		{
			return vanillaCurrencyPrefab;
		}

		private static ItemDrop ResolveCurrency(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName) || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefabName.Trim());
			ItemDrop result = default(ItemDrop);
			if ((Object)(object)itemPrefab != (Object)null && itemPrefab.TryGetComponent<ItemDrop>(ref result))
			{
				return result;
			}
			if (invalidCurrenciesLogged.Add(prefabName))
			{
				TradersExtended.LogWarning("Currency item prefab '" + prefabName + "' was not found. The trader's default currency will be used.");
			}
			return null;
		}
	}
	internal static class TooltipPrices
	{
		private sealed class PriceInfo
		{
			internal string Trader;

			internal int Price;

			internal int Stack;

			internal int Quality;

			internal string CurrencyPrefab;

			internal bool Automatic;

			internal TradersExtended.TradeableItem Source;
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		private static class ObjectDB_Awake_RebuildTooltipPrices
		{
			[HarmonyPriority(0)]
			private static void Postfix()
			{
				Rebuild();
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		private static class ObjectDB_CopyOtherDB_RebuildTooltipPrices
		{
			[HarmonyPriority(0)]
			private static void Postfix()
			{
				Rebuild();
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(bool),
			typeof(float),
			typeof(int)
		})]
		private static class ItemData_GetTooltip_AddTraderPrices
		{
			private static void Postfix(ItemData __0, int __1, ref string __result)
			{
				string tooltip = GetTooltip(__0, __1);
				if (!string.IsNullOrEmpty(tooltip))
				{
					__result += tooltip;
				}
			}
		}

		private static readonly Dictionary<string, List<PriceInfo>> pricesByItemName = new Dictionary<string, List<PriceInfo>>(StringComparer.Ordinal);

		internal static void Rebuild()
		{
			pricesByItemName.Clear();
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return;
			}
			foreach (KeyValuePair<string, List<TradersExtended.TradeableItem>> sellableItem in TradersExtended.sellableItems)
			{
				string text = "." + TradersExtended.ItemsListType.Sell;
				if (!sellableItem.Key.EndsWith(text, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				string trader = sellableItem.Key.Substring(0, sellableItem.Key.Length - text.Length);
				foreach (TradersExtended.TradeableItem item in sellableItem.Value)
				{
					if (item == null || string.IsNullOrWhiteSpace(item.prefab) || item.price <= 0 || item.stack <= 0)
					{
						continue;
					}
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item.prefab);
					ItemDrop val = (((Object)(object)itemPrefab != (Object)null) ? itemPrefab.GetComponent<ItemDrop>() : null);
					if (!((Object)(object)val == (Object)null))
					{
						string name = val.m_itemData.m_shared.m_name;
						if (!pricesByItemName.TryGetValue(name, out var value))
						{
							value = new List<PriceInfo>();
							pricesByItemName.Add(name, value);
						}
						value.Add(new PriceInfo
						{
							Trader = trader,
							Price = item.price,
							Stack = item.stack,
							Quality = item.quality,
							CurrencyPrefab = item.currency,
							Automatic = item.automatic,
							Source = item
						});
					}
				}
			}
		}

		private static string GetTooltip(ItemData itemData, int quality)
		{
			if (itemData == null || !pricesByItemName.TryGetValue(itemData.m_shared.m_name, out var value))
			{
				return string.Empty;
			}
			List<PriceInfo> list = value.Where((PriceInfo price) => string.Equals(price.Trader, "common", StringComparison.OrdinalIgnoreCase) && !price.Automatic).ToList();
			List<PriceInfo> second = value.Where((PriceInfo price) => string.Equals(price.Trader, "common", StringComparison.OrdinalIgnoreCase) && price.Automatic).ToList();
			Dictionary<string, List<PriceInfo>> dictionary = value.Where((PriceInfo price) => !string.Equals(price.Trader, "common", StringComparison.OrdinalIgnoreCase)).GroupBy<PriceInfo, string>((PriceInfo price) => TradersExtended.TraderName(price.Trader), StringComparer.OrdinalIgnoreCase).ToDictionary<IGrouping<string, PriceInfo>, string, List<PriceInfo>>((IGrouping<string, PriceInfo> group) => group.Key, (IGrouping<string, PriceInfo> group) => group.ToList(), StringComparer.OrdinalIgnoreCase);
			HashSet<string> hashSet = new HashSet<string>(TraderConfigManager.GetKnownTraderNames(), StringComparer.OrdinalIgnoreCase);
			hashSet.UnionWith(dictionary.Keys);
			IEnumerable<PriceInfo> enumerable2;
			if (hashSet.Count <= 0 || !hashSet.All((string name) => TraderConfigManager.Get(name).AddCommonValuableItemsToSellList))
			{
				IEnumerable<PriceInfo> enumerable = list;
				enumerable2 = enumerable;
			}
			else
			{
				enumerable2 = list.Concat(second);
			}
			IEnumerable<PriceInfo> prices = enumerable2;
			List<PriceInfo> commonPrices = GetEffectivePrices(prices, quality);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("\n\n<color=#ffcc66>Trader value</color>");
			bool flag = commonPrices.Count > 0;
			AppendPriceLine(stringBuilder, "Common", commonPrices, string.Empty);
			foreach (string traderName in hashSet.OrderBy<string, string>((string name) => name, StringComparer.OrdinalIgnoreCase))
			{
				dictionary.TryGetValue(traderName, out var value2);
				IEnumerable<PriceInfo> enumerable3 = list;
				if (TraderConfigManager.Get(traderName).AddCommonValuableItemsToSellList)
				{
					enumerable3 = enumerable3.Concat(second);
				}
				if (value2 != null)
				{
					enumerable3 = enumerable3.Concat(value2);
				}
				List<PriceInfo> list2 = (from price in GetEffectivePrices(enumerable3, quality)
					where !commonPrices.Any((PriceInfo common) => SamePrice(common, price, traderName))
					select price).ToList();
				if (list2.Count != 0)
				{
					flag = true;
					string label = LocalizeTraderName(traderName);
					string configuredCurrencyName = TraderCurrency.GetConfiguredCurrencyName(traderName);
					AppendPriceLine(stringBuilder, label, list2, configuredCurrencyName);
				}
			}
			return flag ? stringBuilder.ToString() : string.Empty;
		}

		private static bool SamePrice(PriceInfo left, PriceInfo right, string trader)
		{
			if (left.Price != right.Price || left.Stack != right.Stack)
			{
				return false;
			}
			string traderCurrencyPrefabName = TraderCurrency.GetTraderCurrencyPrefabName(trader);
			string a = (string.IsNullOrWhiteSpace(left.CurrencyPrefab) ? traderCurrencyPrefabName : left.CurrencyPrefab.Trim());
			string b = (string.IsNullOrWhiteSpace(right.CurrencyPrefab) ? traderCurrencyPrefabName : right.CurrencyPrefab.Trim());
			return string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
		}

		private static List<PriceInfo> GetEffectivePrices(IEnumerable<PriceInfo> prices, int quality)
		{
			List<PriceInfo> list = prices.Where((PriceInfo price) => price.Source == null || price.Source.RequirementsMet()).ToList();
			bool flag = list.Any((PriceInfo price) => price.Quality > 0 && price.Quality == quality);
			Dictionary<int, PriceInfo> dictionary = new Dictionary<int, PriceInfo>();
			foreach (PriceInfo item in list)
			{
				if (!(flag ? (item.Quality != quality) : (item.Quality > 0)))
				{
					dictionary[item.Stack] = item;
				}
			}
			return (from price in dictionary.Values
				orderby price.Stack, price.Price
				select price).ToList();
		}

		private static void AppendPriceLine(StringBuilder result, string label, List<PriceInfo> prices, string currency)
		{
			if (prices == null || prices.Count == 0)
			{
				return;
			}
			result.Append('\n').Append(label).Append(": ");
			for (int i = 0; i < prices.Count; i++)
			{
				if (i > 0)
				{
					result.Append(", ");
				}
				PriceInfo priceInfo = prices[i];
				result.Append(priceInfo.Price);
				string value = currency;
				if (!string.IsNullOrWhiteSpace(priceInfo.CurrencyPrefab))
				{
					string currencyName = TraderCurrency.GetCurrencyName(priceInfo.CurrencyPrefab);
					if (!string.IsNullOrEmpty(currencyName))
					{
						value = currencyName;
					}
				}
				if (!string.IsNullOrEmpty(value))
				{
					result.Append(' ').Append(value);
				}
				if (priceInfo.Stack > 1)
				{
					result.Append(" / x").Append(priceInfo.Stack);
				}
				if (priceInfo.Quality > 0)
				{
					result.Append(" (quality ").Append(priceInfo.Quality).Append(')');
				}
			}
		}

		private static string LocalizeTraderName(string trader)
		{
			if (Localization.instance == null)
			{
				return trader;
			}
			string text = Localization.instance.Localize("$npc_" + trader);
			return (text == "$npc_" + trader) ? trader : text;
		}
	}
	internal sealed class ResolvedTraderConfig
	{
		internal string TraderName;

		internal bool SellOnlyDiscoveredItems;

		internal HashSet<string> UndiscoveredItemsListToSell;

		internal bool CanRepairWeapons;

		internal bool CanRepairArmor;

		internal int TradersRepairCost;

		internal string RepairCurrencyPrefab;

		internal bool TradersUseCoins;

		internal bool TradersUseFlexiblePricing;

		internal string TraderCurrencyPrefab;

		internal int CoinsAfterReplenishmentMinimum;

		internal int CoinsReplenishedDaily;

		internal int CoinsRemovedDaily;

		internal int CoinsAfterReplenishmentMaximum;

		internal float TraderDiscount;

		internal float TraderMarkup;

		internal int TraderCoinsReplenishmentRateInDays;

		internal bool SendReplenishmentMessageInTheMorning;

		internal string CustomTradersPrefabNames;

		internal bool DisableVanillaItems;

		internal bool DisableOtherModsItems;

		internal float QualityMultiplier;

		internal bool HideEquippedAndHotbarItems;

		internal bool AddCommonValuableItemsToSellList;

		internal Vector2 FixedStoreGuiPosition;

		internal bool EnableBuybackForLastItemSold;

		internal int BuybackLifetimeInWorldSeconds;

		internal Color BuybackItemBackgroundColor;

		internal Color BuybackItemHighlightedColor;

		internal Color BuybackItemFontColor;

		internal bool ShiftStoreGuiForEpicLoot;
	}
	internal static class TraderConfigManager
	{
		private static readonly Dictionary<string, JObject> traderOverrides = new Dictionary<string, JObject>(StringComparer.OrdinalIgnoreCase);

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

		private static readonly HashSet<string> invalidValuesLogged = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static void LoadSyncedConfigs()
		{
			traderOverrides.Clear();
			resolvedConfigs.Clear();
			invalidValuesLogged.Clear();
			Dictionary<string, string> source = TradersExtended.traderConfigFiles.Value ?? new Dictionary<string, string>();
			foreach (KeyValuePair<string, string> item in source.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> pair) => pair.Key, StringComparer.OrdinalIgnoreCase))
			{
				if (TradersExtended.TryParseSyncedTraderConfigKey(item.Key, out var trader, out var fileName))
				{
					JObject val = DeserializeTraderConfig(item.Value, fileName);
					if (val != null)
					{
						string text = TradersExtended.TraderName(trader);
						traderOverrides[text] = val;
						LogLoadedOverrides(text, fileName, val);
					}
				}
			}
			RefreshRuntime();
		}

		private static void LogLoadedOverrides(string traderName, string fileName, JObject root)
		{
			List<string> list = new List<string>();
			AddLoggedOverride<bool>(root, list, "Item discovery", "Sell only discovered items");
			AddLoggedOverride<string>(root, list, "Item discovery", "Undiscovered items list to sell");
			AddLoggedOverride<bool>(root, list, "Trader repair", "Weapons");
			AddLoggedOverride<bool>(root, list, "Trader repair", "Armor");
			AddLoggedOverride<int>(root, list, "Trader repair", "Repair cost");
			AddLoggedOverride<string>(root, list, "Trader repair", "Repair currency");
			AddLoggedOverride<bool>(root, list, "Trader coins", "Use currency");
			AddLoggedOverride<bool>(root, list, "Trader coins", "Use flexible pricing");
			AddLoggedOverride<int>(root, list, "Trader pricing", "Amount of currency after replenishment minimum");
			AddLoggedOverride<int>(root, list, "Trader pricing", "Amount of currency replenished daily");
			AddLoggedOverride<int>(root, list, "Trader pricing", "Amount of currency removed daily");
			AddLoggedOverride<int>(root, list, "Trader pricing", "Amount of currency after replenishment maximum");
			AddLoggedOverride<float>(root, list, "Trader pricing", "Trader discount");
			AddLoggedOverride<float>(root, list, "Trader pricing", "Trader markup");
			AddLoggedOverride<int>(root, list, "Trader pricing", "Currency replenishment rate in days");
			AddLoggedOverride<bool>(root, list, "Trader pricing", "Send replenishment message in the morning");
			AddLoggedOverride<string>(root, list, "Trader currency", "Override");
			AddLoggedOverride<bool>(root, list, "Trader buyback", "Enable buyback for last item sold");
			AddLoggedOverride<int>(root, list, "Trader buyback", "Buyback lifetime in world seconds");
			AddLoggedOverride<bool>(root, list, "Misc", "Disable vanilla items");
			AddLoggedOverride<bool>(root, list, "Misc", "Disable other mods items");
			AddLoggedOverride<bool>(root, list, "Misc", "Add common valuable items to sell list");
			AddLoggedOverride<Vector2>(root, list, "Misc", "Fixed position for Store GUI");
			AddLoggedOverride<bool>(root, list, "Misc", "Store GUI EpicLoot compatibility");
			TradersExtended.LogInfo($"Loaded personal trader config '{fileName}' for trader '{traderName}' with {list.Count} valid override(s).");
			foreach (string item in list)
			{
				TradersExtended.LogInfo("  " + item);
			}
		}

		private static void AddLoggedOverride<T>(JObject root, List<string> overrides, string sectionName, string settingName)
		{
			if (TryGetValue<T>(root, sectionName, settingName, out var value))
			{
				overrides.Add("[" + sectionName + "] " + settingName + " = " + FormatOverrideValue(value));
			}
		}

		private static string FormatOverrideValue<T>(T value)
		{
			//IL_0065: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			object obj = value;
			if (1 == 0)
			{
			}
			string result = ((obj == null) ? "null" : ((obj is string text) ? ("\"" + text.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"") : ((obj is bool) ? (((bool)obj) ? "true" : "false") : ((obj is float num) ? num.ToString("0.###", CultureInfo.InvariantCulture) : ((obj is double num2) ? num2.ToString("0.###", CultureInfo.InvariantCulture) : ((obj is Vector2 val) ? ("(" + val.x.ToString("0.###", CultureInfo.InvariantCulture) + ", " + val.y.ToString("0.###", CultureInfo.InvariantCulture) + ")") : ((obj is Color val2) ? ("RGBA(" + val2.r.ToString("0.###", CultureInfo.InvariantCulture) + ", " + val2.g.ToString("0.###", CultureInfo.InvariantCulture) + ", " + val2.b.ToString("0.###", CultureInfo.InvariantCulture) + ", " + val2.a.ToString("0.###", CultureInfo.InvariantCulture) + ")") : ((!(obj is IFormattable formattable)) ? obj.ToString() : formattable.ToString(null, CultureInfo.InvariantCulture)))))))));
			if (1 == 0)
			{
			}
			return result;
		}

		internal static void Invalidate()
		{
			resolvedConfigs.Clear();
			invalidValuesLogged.Clear();
		}

		internal static void InvalidateAndRefresh()
		{
			Invalidate();
			RefreshRuntime();
		}

		private static void RefreshRuntime()
		{
			TooltipPrices.Rebuild();
			if (!((Object)(object)StoreGui.instance == (Object)null) && !((Object)(object)StoreGui.instance.m_trader == (Object)null) && StoreGui.IsVisible())
			{
				TraderCurrency.ApplyTraderCurrency(StoreGui.instance);
				StorePanel.SetStoreGuiPosition();
				RepairPanel.Update(StoreGui.instance);
				TraderCoins.UpdateTraderCoinsVisibility();
				StoreGui.instance.FillList();
				StorePanel.UpdateNames();
			}
		}

		internal static ResolvedTraderConfig Get(Trader trader)
		{
			return Get(TradersExtended.TraderName(trader));
		}

		internal static ResolvedTraderConfig Get(string traderName)
		{
			traderName = TradersExtended.TraderName(traderName);
			if (!resolvedConfigs.TryGetValue(traderName, out var value))
			{
				value = Build(traderName);
				resolvedConfigs[traderName] = value;
			}
			return value;
		}

		internal static IEnumerable<string> GetKnownTraderNames()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
			{
				TradersExtended.TraderName("Haldor"),
				TradersExtended.TraderName("Hildir"),
				TradersExtended.TraderName("BogWitch")
			};
			hashSet.UnionWith(traderOverrides.Keys);
			foreach (string item in TradersExtended.tradeableItems.Keys.Concat(TradersExtended.sellableItems.Keys))
			{
				int num = item.LastIndexOf('.');
				string text = ((num > 0) ? item.Substring(0, num) : item);
				if (!string.Equals(text, "common", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(text))
				{
					hashSet.Add(TradersExtended.TraderName(text));
				}
			}
			string value = TradersExtended.tradersCustomPrefabs?.Value ?? string.Empty;
			foreach (string item2 in SplitList(value))
			{
				hashSet.Add(TradersExtended.TraderName(item2));
			}
			return hashSet.Where((string name) => !string.IsNullOrWhiteSpace(name));
		}

		internal static bool IsAutomaticCommonItemEnabled(Trader trader)
		{
			return Get(trader).AddCommonValuableItemsToSellList;
		}

		internal static bool IgnoreItemDiscovery(Trader trader, string prefabName)
		{
			return !string.IsNullOrWhiteSpace(prefabName) && Get(trader).UndiscoveredItemsListToSell.Contains(prefabName);
		}

		private static ResolvedTraderConfig Build(string traderName)
		{
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			traderOverrides.TryGetValue(traderName, out var value);
			bool fallback = TradersExtended.traderRepair.Value && ListContainsTrader(TradersExtended.tradersToRepairWeapons.Value, traderName);
			bool fallback2 = TradersExtended.traderRepair.Value && ListContainsTrader(TradersExtended.tradersToRepairArmor.Value, traderName);
			string value2;
			string traderCurrencyPrefab = (TryGetValue<string>(value, "Trader currency", "Override", out value2) ? (value2 ?? string.Empty).Trim() : ResolveCurrencyForTrader(TradersExtended.traderCurrencyOverrides.Value, traderName));
			return new ResolvedTraderConfig
			{
				TraderName = traderName,
				SellOnlyDiscoveredItems = GetValue(value, "Item discovery", "Sell only discovered items", TradersExtended.checkForDiscovery.Value),
				UndiscoveredItemsListToSell = ToSet(GetValue(value, "Item discovery", "Undiscovered items list to sell", TradersExtended.checkForDiscoveryIgnoreItems.Value)),
				CanRepairWeapons = GetValue(value, "Trader repair", "Weapons", fallback),
				CanRepairArmor = GetValue(value, "Trader repair", "Armor", fallback2),
				TradersRepairCost = GetValue(value, "Trader repair", "Repair cost", TradersExtended.traderRepairCost.Value),
				RepairCurrencyPrefab = (GetValue(value, "Trader repair", "Repair currency", TradersExtended.traderRepairCurrency.Value) ?? string.Empty).Trim(),
				TradersUseCoins = GetValue(value, "Trader coins", "Use currency", TradersExtended.traderUseCoins.Value),
				TradersUseFlexiblePricing = GetValue(value, "Trader coins", "Use flexible pricing", TradersExtended.traderUseFlexiblePricing.Value),
				TraderCurrencyPrefab = traderCurrencyPrefab,
				CoinsAfterReplenishmentMinimum = GetValue(value, "Trader pricing", "Amount of currency after replenishment minimum", TradersExtended.traderCoinsMinimumAmount.Value),
				CoinsReplenishedDaily = GetValue(value, "Trader pricing", "Amount of currency replenished daily", TradersExtended.traderCoinsIncreaseAmount.Value),
				CoinsRemovedDaily = GetValue(value, "Trader pricing", "Amount of currency removed daily", TradersExtended.traderCoinsDecreaseAmount.Value),
				CoinsAfterReplenishmentMaximum = GetValue(value, "Trader pricing", "Amount of currency after replenishment maximum", TradersExtended.traderCoinsMaximumAmount.Value),
				TraderDiscount = GetValue(value, "Trader pricing", "Trader discount", TradersExtended.traderDiscount.Value),
				TraderMarkup = GetValue(value, "Trader pricing", "Trader markup", TradersExtended.traderMarkup.Value),
				TraderCoinsReplenishmentRateInDays = GetValue(value, "Trader pricing", "Currency replenishment rate in days", TradersExtended.traderCoinsReplenishmentRate.Value),
				SendReplenishmentMessageInTheMorning = GetValue(value, "Trader pricing", "Send replenishment message in the morning", TradersExtended.traderCoinsSendReplenishmentMessage.Value),
				CustomTradersPrefabNames = TradersExtended.tradersCustomPrefabs.Value,
				DisableVanillaItems = GetValue(value, "Misc", "Disable vanilla items", TradersExtended.disableVanillaItems.Value),
				DisableOtherModsItems = GetValue(value, "Misc", "Disable other mods items", TradersExtended.disableOtherModsItems.Value),
				QualityMultiplier = TradersExtended.qualityMultiplier.Value,
				HideEquippedAndHotbarItems = TradersExtended.hideEquippedAndHotbarItems.Value,
				AddCommonValuableItemsToSellList = GetValue(value, "Misc", "Add common valuable items to sell list", TradersExtended.addCommonValuableItemsToSellList.Value),
				FixedStoreGuiPosition = GetValue<Vector2>(value, "Misc", "Fixed position for Store GUI", TradersExtended.fixedStoreGuiPosition.Value),
				EnableBuybackForLastItemSold = GetValue(value, "Trader buyback", "Enable buyback for last item sold", TradersExtended.enableBuyBack.Value),
				BuybackLifetimeInWorldSeconds = GetValue(value, "Trader buyback", "Buyback lifetime in world seconds", TradersExtended.buybackLifetime.Value),
				BuybackItemBackgroundColor = TradersExtended.colorBuybackNormal.Value,
				BuybackItemHighlightedColor = TradersExtended.colorBuybackHighlighted.Value,
				BuybackItemFontColor = TradersExtended.colorBuybackText.Value,
				ShiftStoreGuiForEpicLoot = GetValue(value, "Misc", "Store GUI EpicLoot compatibility", ListContainsTrader(TradersExtended.epicLootShiftedTraders.Value, traderName))
			};
		}

		internal static string ResolveCurrencyForTrader(string value, string traderName)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return string.Empty;
			}
			string text = value.Trim();
			if (text.IndexOf(':') < 0 && text.IndexOf('=') < 0 && text.IndexOf(',') < 0 && text.IndexOf(';') < 0 && text.IndexOf('\n') < 0 && text.IndexOf('\r') < 0)
			{
				if (invalidValuesLogged.Add("Trader currency overrides/" + text))
				{
					TradersExtended.LogWarning("Ignored invalid trader currency override '" + text + "'. Expected TraderPrefab:CurrencyPrefab.");
				}
				return string.Empty;
			}
			string[] array = text.Split(new char[4] { ',', ';', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text2 in array)
			{
				string text3 = text2.Trim();
				int num = text3.IndexOf(':');
				if (num < 0)
				{
					num = text3.IndexOf('=');
				}
				if (num > 0 && num < text3.Length - 1 && string.Equals(TradersExtended.TraderName(text3.Substring(0, num)), traderName, StringComparison.OrdinalIgnoreCase))
				{
					return text3.Substring(num + 1).Trim();
				}
			}
			return string.Empty;
		}

		private static bool ListContainsTrader(string value, string traderName)
		{
			return SplitList(value).Any((string entry) => string.Equals(TradersExtended.TraderName(entry), traderName, StringComparison.OrdinalIgnoreCase));
		}

		private static HashSet<string> ToSet(string value)
		{
			return new HashSet<string>(SplitList(value), StringComparer.OrdinalIgnoreCase);
		}

		private static HashSet<string> ToTraderSet(string value)
		{
			return new HashSet<string>(SplitList(value).Select(TradersExtended.TraderName), StringComparer.OrdinalIgnoreCase);
		}

		private static IEnumerable<string> SplitList(string value)
		{
			return from entry in (value ?? string.Empty).Split(new char[4] { ',', ';', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)
				select entry.Trim() into entry
				where !string.IsNullOrWhiteSpace(entry)
				select entry;
		}

		private static T GetValue<T>(JObject root, string sectionName, string settingName, T fallback)
		{
			T value;
			return TryGetValue<T>(root, sectionName, settingName, out value) ? value : fallback;
		}

		private static bool TryGetValue<T>(JObject root, string sectionName, string settingName, out T value)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Invalid comparison between Unknown and I4
			value = default(T);
			if (root != null)
			{
				JToken value2 = root.GetValue(sectionName, StringComparison.OrdinalIgnoreCase);
				JObject val = (JObject)(object)((value2 is JObject) ? value2 : null);
				if (val != null)
				{
					JToken value3 = val.GetValue(settingName, StringComparison.OrdinalIgnoreCase);
					if (value3 != null && (int)value3.Type != 10)
					{
						try
						{
							if (typeof(T) == typeof(Vector2))
							{
								value = (T)(object)ParseVector2(value3);
							}
							else if (typeof(T) == typeof(string))
							{
								JArray val2 = (JArray)(object)((value3 is JArray) ? value3 : null);
								if (val2 != null)
								{
									value = (T)(object)string.Join(",", ((IEnumerable<JToken>)val2).Select((JToken val4) => ((int)val4.Type == 8) ? Extensions.Value<string>((IEnumerable<JToken>)val4) : val4.ToString((Formatting)0, Array.Empty<JsonConverter>())));
								}
								else
								{
									JObject val3 = (JObject)(object)((value3 is JObject) ? value3 : null);
									if (val3 != null)
									{
										value = (T)(object)string.Join(",", from property in val3.Properties()
											select property.Name + ":" + (((int)property.Value.Type == 8) ? Extensions.Value<string>((IEnumerable<JToken>)property.Value) : property.Value.ToString((Formatting)0, Array.Empty<JsonConverter>())));
									}
									else
									{
										value = (T)(object)(((int)value3.Type == 8) ? Extensions.Value<string>((IEnumerable<JToken>)value3) : value3.ToString((Formatting)0, Array.Empty<JsonConverter>()));
									}
								}
							}
							else
							{
								value = value3.ToObject<T>();
							}
							return true;
						}
						catch (Exception ex)
						{
							string item = sectionName + "/" + settingName + "/" + (object)value3;
							if (invalidValuesLogged.Add(item))
							{
								TradersExtended.LogWarning("Invalid personal trader setting '" + sectionName + "." + settingName + "': " + ex.Message + ". The BepInEx value will be used.");
							}
							return false;
						}
					}
				}
			}
			return false;
		}

		private static Vector2 ParseVector2(JToken token)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_0091: 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: Invalid comparison between Unknown and I4
			JObject val = (JObject)(object)((token is JObject) ? token : null);
			if (val == null)
			{
				throw new FormatException("Expected an object with numeric 'x' and 'y' fields.");
			}
			JToken value = val.GetValue("x", StringComparison.OrdinalIgnoreCase);
			JToken value2 = val.GetValue("y", StringComparison.OrdinalIgnoreCase);
			if (value == null || value2 == null || ((int)value.Type != 6 && (int)value.Type != 7) || ((int)value2.Type != 6 && (int)value2.Type != 7))
			{
				throw new FormatException("Expected an object with numeric 'x' and 'y' fields.");
			}
			return new Vector2(Extensions.Value<float>((IEnumerable<JToken>)value), Extensions.Value<float>((IEnumerable<JToken>)value2));
		}

		internal static JObject DeserializeTraderConfig(string content, string source)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			if (string.IsNullOrWhiteSpace(content))
			{
				return new JObject();
			}
			try
			{
				string extension = Path.GetExtension(source);
				if (string.Equals(extension, ".json", StringComparison.OrdinalIgnoreCase))
				{
					return JObject.Parse(content);
				}
				object obj = TradersExtended.yamlDeserializer.Deserialize<object>(content);
				return JObject.Parse(JsonConvert.SerializeObject(obj));
			}
			catch (Exception ex)
			{
				TradersExtended.LogWarning("Error parsing personal trader config '" + source + "': " + ex.Message);
				return null;
			}
		}
	}
}
namespace TradersExtended.Compatibility
{
	internal static class EpicLootCompat
	{
		internal const string GUID = "randyknapp.mods.epicloot";

		internal static PluginInfo plugin;

		internal static Assembly assembly;

		internal static bool isEnabled;

		private static MethodInfo isAdventureModeEnabledMethod;

		private static bool invocationErrorLogged;

		internal static void CheckForCompatibility()
		{
			if (isEnabled = Chainloader.PluginInfos.TryGetValue("randyknapp.mods.epicloot", out plugin))
			{
				if ((object)assembly == null)
				{
					assembly = Assembly.GetAssembly(((object)plugin.Instance).GetType());
				}
				if ((object)isAdventureModeEnabledMethod == null)
				{
					isAdventureModeEnabledMethod = AccessTools.Method(((object)plugin.Instance).GetType(), "IsAdventureModeEnabled", (Type[])null, (Type[])null);
				}
			}
		}

		internal static bool IsAdventureModeEnabled()
		{
			if (!isEnabled || isAdventureModeEnabledMethod == null)
			{
				return false;
			}
			try
			{
				object obj = (isAdventureModeEnabledMethod.IsStatic ? null : plugin.Instance);
				object obj2 = isAdventureModeEnabledMethod.Invoke(obj, null);
				bool flag = default(bool);
				int num;
				if (obj2 is bool)
				{
					flag = (bool)obj2;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch (Exception ex)
			{
				if (!invocationErrorLogged)
				{
					invocationErrorLogged = true;
					TradersExtended.LogWarning("Could not read EpicLoot adventure mode state: " + ex.Message);
				}
				return false;
			}
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	[CompilerGenerated]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	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]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[Embedded]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace AzuExtendedPlayerInventory
{
	[PublicAPI]
	internal class API
	{
		public delegate void SlotAddedHandler(string slotName);

		public delegate void SlotRemovedHandler(string slotName);

		public static event Action<Hud>? OnHudAwake;

		public static event Action<Hud>? OnHudAwakeComplete;

		public static event Action<Hud>? OnHudUpdate;

		public static event Action<Hud>? OnHudUpdateComplete;

		public static event SlotAddedHandler? SlotAdded;

		public static event SlotRemovedHandler? SlotRemoved;

		public static bool IsLoaded()
		{
			return false;
		}

		public static bool AddSlot(string slotName, Func<Player, ItemData?> getItem, Func<ItemData, bool> isValid, int index = -1)
		{
			return false;
		}

		public static bool RemoveSlot(string slotName)
		{
			return false;
		}

		public static SlotInfo GetSlots()
		{
			return new SlotInfo();
		}

		public static SlotInfo GetQuickSlots()
		{
			return new SlotInfo();
		}

		public static List<ItemData> GetQuickSlotsItems()
		{
			return new List<ItemData>();
		}

		public static int GetAddedRows(int width)
		{
			return 0;
		}
	}
	[PublicAPI]
	internal class SlotInfo
	{
		public string[] SlotNames { get; set; } = new string[0];

		public Vector2[] SlotPositions { get; set; } = (Vector2[])(object)new Vector2[0];

		public Func<Player, ItemData?>?[] GetItemFuncs { get; set; } = new Func<Player, ItemData>[0];

		public Func<ItemData, bool>?[] IsValidFuncs { get; set; } = new Func<ItemData, bool>[0];
	}
}
namespace ExtraSlots
{
	[PublicAPI]
	internal class API
	{
		public static bool IsLoaded()
		{
			return false;
		}

		public static List<ExtraSlot> GetExtraSlots()
		{
			return new List<ExtraSlot>();
		}

		public static List<ExtraSlot> GetEquipmentSlots()
		{
			return new List<ExtraSlot>();
		}

		public static List<ExtraSlot> GetQuickSlots()
		{
			return new List<ExtraSlot>();
		}

		public static List<ExtraSlot> GetFoodSlots()
		{
			return new List<ExtraSlot>();
		}

		public static List<ExtraSlot> GetAmmoSlots()
		{
			return new List<ExtraSlot>();
		}

		public static List<ExtraSlot> GetMiscSlots()
		{
			return new List<ExtraSlot>();
		}

		public static ExtraSlot FindSlot(string slotID)
		{
			return null;
		}

		public static List<ItemData> GetAllExtraSlotsItems()
		{
			return new List<ItemData>();
		}

		public static List<ItemData> GetEquipmentSlotsItems()
		{
			return new List<ItemData>();
		}

		public static List<ItemData> GetQuickSlotsItems()
		{
			return new List<ItemData>();
		}

		public static List<ItemData> GetFoodSlotsItems()
		{
			return new List<ItemData>();
		}

		public static List<ItemData> GetAmmoSlotsItems()
		{
			return new List<ItemData>();
		}

		public static List<ItemData> GetMiscSlotsItems()
		{
			return new List<ItemData>();
		}

		public static int GetExtraRows()
		{
			return 0;
		}

		public static int GetInventoryHeight()
		{
			return 0;
		}

		public static bool IsGridPositionASlot(Vector2i gridPos)
		{
			return false;
		}

		public static bool IsItemInSlot(ItemData item)
		{
			return false;
		}

		public static bool IsItemInEquipmentSlot(ItemData item)
		{
			return false;
		}

		public static bool AddSlot(string slotID, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive)
		{
			return false;
		}

		public static bool AddSlotWithIndex(string slotID, int slotIndex, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive)
		{
			return false;
		}

		public static bool AddSlotBefore(string slotID, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive, params string[] slotIDs)
		{
			return false;
		}

		public static bool AddSlotAfter(string slotID, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive, params string[] slotIDs)
		{
			return false;
		}

		public static bool RemoveSlot(string slotID)
		{
			return false;
		}

		public static void UpdateSlots()
		{
		}
	}
	[PublicAPI]
	internal class ExtraSlot
	{
		internal Func<string> _id;

		internal Func<string> _name;

		internal Func<Vector2i> _gridPosition;

		internal Func<ItemData> _item;

		internal Func<ItemData, bool> _itemFits;

		internal Func<bool> _isActive;

		internal Func<bool> _isFree;

		internal Func<bool> _isHotkeySlot;

		internal Func<bool> _isEquipmentSlot;

		internal Func<bool> _isQuickSlot;

		internal Func<bool> _isMiscSlot;

		internal Func<bool> _isAmmoSlot;

		internal Func<bool> _isFoodSlot;

		internal Func<bool> _isCustomSlot;

		internal Func<bool> _isEmptySlot;

		public static readonly Vector2i emptyPosition = new Vector2i(-1, -1);

		public string ID
		{
			get
			{
				if (_id != null)
				{
					return _id();
				}
				return "";
			}
		}

		public string Name
		{
			get
			{
				if (_name != null)
				{
					return _name();
				}
				return "";
			}
		}

		public Vector2i GridPosition
		{
			get
			{
				//IL_0014: 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)
				if (_gridPosition != null)
				{
					return _gridPosition();
				}
				return emptyPosition;
			}
		}

		public ItemData Item
		{
			get
			{
				if (_item != null)
				{
					return _item();
				}
				return null;
			}
		}

		public bool IsActive
		{
			get
			{
				if (_isActive != null)
				{
					return _isActive();
				}
				return false;
			}
		}

		public bool IsFree
		{
			get
			{
				if (_isFree != null)
				{
					return _isFree();
				}
				return false;
			}
		}

		public bool IsHotkeySlot
		{
			get
			{
				if (_isHotkeySlot != null)
				{
					return _isHotkeySlot();
				}
				return false;
			}
		}

		public bool IsEquipmentSlot
		{
			get
			{
				if (_isEquipmentSlot != null)
				{
					return _isEquipmentSlot();
				}
				return false;
			}
		}

		public bool IsQuickSlot
		{
			get
			{
				if (_isQuickSlot != null)
				{
					return _isQuickSlot();
				}
				return false;
			}
		}

		public bool IsMiscSlot
		{
			get
			{
				if (_isMiscSlot != null)
				{
					return _isMiscSlot();
				}
				return false;
			}
		}

		public bool IsAmmoSlot
		{
			get
			{
				if (_isAmmoSlot != null)
				{
					return _isAmmoSlot();
				}
				return false;
			}
		}

		public bool IsFoodSlot
		{
			get
			{
				if (_isFoodSlot != null)
				{
					return _isFoodSlot();
				}
				return false;
			}
		}

		public bool IsCustomSlot
		{
			get
			{
				if (_isCustomSlot != null)
				{
					return _isCustomSlot();
				}
				return false;
			}
		}

		public bool IsEmptySlot
		{
			get
			{
				if (_isEmptySlot != null)
				{
					return _isEmptySlot();
				}
				return false;
			}
		}

		public bool ItemFits(ItemData item)
		{
			if (_itemFits != null)
			{
				return _itemFits(item);
			}
			return false;
		}
	}
}