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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Traders Extended")]
[assembly: AssemblyDescription("")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyProduct("Traders Extended")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("6d6f243e-c80e-4a33-b2d0-a2657d3b9f7f")]
[assembly: AssemblyFileVersion("1.3.13")]
[assembly: AssemblyCompany("")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.13.0")]
[module: UnverifiableCode]
namespace TradersExtended
{
	internal static class AmountDialog
	{
		[HarmonyPatch(typeof(StoreGui), "OnSelectedItem")]
		public static class StoreGui_OnSelectedItem_SelectItem
		{
			private static void Postfix()
			{
				OnSelectedTradeableItemClick(sellDialog: false);
			}
		}

		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 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_0137: 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_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: 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_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: 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_0366: Expected O, but got Unknown
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: 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);
			Image component = ((Component)val3.transform.Find("Icon")).GetComponent<Image>();
			component.sprite = storeGui.m_coinPrefab.m_itemData.GetIcon();
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.anchorMax += new Vector2(0.15f, 0f);
			component2.anchorMin += new Vector2(0.15f, 0f);
			RectTransform component3 = ((Component)val2).GetComponent<RectTransform>();
			component3.anchorMax -= new Vector2(0.15f, 0f);
			component3.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 component4 = ((Component)sliderAmountText).GetComponent<RectTransform>();
			component4.anchorMax -= new Vector2(0.15f, 0f);
			component4.anchorMin -= new Vector2(0.15f, 0f);
			RectTransform component5 = val4.GetComponent<RectTransform>();
			component5.anchorMax += new Vector2(0.15f, 0f);
			component5.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 component6 = val5.GetComponent<RectTransform>();
			component6.anchorMin -= new Vector2(0f, 0.5f);
			val5.GetComponent<TMP_Text>().SetText("=");
			((UnityEvent<float>)(object)sliderDialog.onValueChanged).AddListener((UnityAction<float>)OnSplitSliderChanged);
			((UnityEvent)((Component)val.Find("Button_ok")).GetComponent<Button>().onClick).AddListener(new UnityAction(OnOkClick));
			((UnityEvent)((Component)val.Find("Button_cancel")).GetComponent<Button>().onClick).AddListener(new UnityAction(Close));
			return amountDialog;
		}

		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 = selectedItem.amount;
				if (TradersExtended.traderUseCoins.Value)
				{
					int traderCoins = TraderCoins.GetTraderCoins();
					if (traderCoins < selectedItem.pricePerItem)
					{
						return;
					}
					num = Mathf.Min(traderCoins / selectedItem.pricePerItem, num);
				}
				SetDialogAndOpen(selectedItem.item, num);
			}
			else
			{
				if (!((Humanoid)Player.m_localPlayer).GetInventory().HaveEmptySlot())
				{
					return;
				}
				TradeItem selectedItem2 = storeGui.m_selectedItem;
				if (selectedItem2 != null && !StorePanel.ItemToSell.IsBuyBackItem(selectedItem2))
				{
					int playerCoins = storeGui.GetPlayerCoins();
					if (TradersExtended.TradeableItem.GetStackFromStack(selectedItem2.m_stack) == 1 && selectedItem2.m_prefab.m_itemData.m_shared.m_maxStackSize != 1 && playerCoins >= selectedItem2.m_price)
					{
						SetDialogAndOpen(selectedItem2.m_prefab.m_itemData, Mathf.CeilToInt((float)(playerCoins / selectedItem2.m_price)));
					}
				}
			}
		}

		private static void SetDialogAndOpen(ItemData item, int maxValue)
		{
			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();
			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())
				{
					StorePanel.selectedItem.amount = Mathf.CeilToInt(sliderDialog.value);
					StorePanel.selectedItem.price = GetPrice();
					StorePanel.SellSelectedItem(storeGui);
				}
			}
			else if (CanAffordSelectedItem())
			{
				TradersExtended.TradeableItem.GetStackQualityFromStack(storeGui.m_selectedItem.m_stack, out var stack, out var quality);
				stack = Mathf.Min(Mathf.CeilToInt(sliderDialog.value), storeGui.m_selectedItem.m_prefab.m_itemData.m_shared.m_maxStackSize);
				storeGui.m_selectedItem.m_stack = TradersExtended.TradeableItem.GetStackFromStackQuality(stack, quality);
				TradeItem selectedItem = storeGui.m_selectedItem;
				selectedItem.m_price *= stack;
				storeGui.BuySelectedItem();
			}
			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 playerCoins = storeGui.GetPlayerCoins();
			return GetPrice() <= playerCoins && ((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 Mathf.CeilToInt((float)((int)sliderDialog.value * GetPricePerItem()) * (isSellDialog ? TraderCoins.GetPriceFactor(buyPrice: false) : 1f));
		}
	}
	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.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.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 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 = TradersExtended.coinsStackSize.Value;
			}
		}

		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 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 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;
			}
		}

		[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_0052: 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_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_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0339: Unknown result type (might be due to invalid IL or missing references)
				//IL_034d: 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_0370: Unknown result type (might be due to invalid IL or missing references)
				//IL_0384: Unknown result type (might be due to invalid IL or missing references)
				//IL_0389: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_03cc: Expected O, but got Unknown
				//IL_044b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0450: Unknown result type (might be due to invalid IL or missing references)
				//IL_0495: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c8: 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)
				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;
				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);
				if ((Object)(object)TradersExtended.epicLootPlugin != (Object)null)
				{
					MethodInfo IsAdventureModeEnabledMethod = AccessTools.Method(((object)TradersExtended.epicLootPlugin).GetType(), "IsAdventureModeEnabled", (Type[])null, (Type[])null);
					if (IsAdventureModeEnabledMethod != null)
					{
						_adventureModeEnabled = () => (bool)IsAdventureModeEnabledMethod.Invoke(null, null);
					}
				}
				RectTransform tooltipAnchor = __instance.m_tooltipAnchor;
				tooltipAnchor.anchorMax += new Vector2(1f, 0f);
				TradersExtended.LogInfo("StoreGui panel patched");
				TradersExtended.SetupConfigWatcher();
				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;
				}
			}

			[HarmonyFinalizer]
			[HarmonyPriority(0)]
			public static Exception Finalizer(Exception __exception, Trader __instance, ref List<TradeItem> __result)
			{
				//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_00d7: 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_00f3: 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>();
				}
				if (TradersExtended.disableOtherModsItems.Value)
				{
					__result.Clear();
					if (!TradersExtended.disableVanillaItems.Value)
					{
						AddVanillaAvailableItems(__instance, __result);
					}
				}
				else if (TradersExtended.disableVanillaItems.Value)
				{
					RemoveVanillaItems(__instance, __result);
				}
				AddAvailableItems(TradersExtended.CommonListKey(TradersExtended.ItemsListType.Buy), __result);
				AddAvailableItems(TradersExtended.TraderListKey(__instance, TradersExtended.ItemsListType.Buy), __result);
				ApplyFilterAndFlexiblePrices(__result);
				if (TradersExtended.enableBuyBack.Value && buybackItem != null)
				{
					__result.Insert(0, ItemToSell.SetBuyBackItem(new TradeItem
					{
						m_prefab = null,
						m_stack = 0,
						m_price = buybackItem.price
					}));
				}
				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(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 (TradersExtended.traderUseFlexiblePricing.Value)
					{
						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
				return new TradeItem
				{
					m_prefab = item.m_prefab,
					m_stack = item.m_stack,
					m_price = item.m_price,
					m_requiredGlobalKey = item.m_requiredGlobalKey
				};
			}
		}

		[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 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_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				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();
				}
			}
		}

		[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_02e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0393: Unknown result type (might be due to invalid IL or missing references)
				//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_039e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0404: Unknown result type (might be due to invalid IL or missing references)
				//IL_040a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0470: Unknown result type (might be due to invalid IL or missing references)
				//IL_047a: Expected O, but got Unknown
				//IL_044c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0490: Unknown result type (might be due to invalid IL or missing references)
				//IL_0495: Unknown result type (might be due to invalid IL or missing references)
				//IL_049e: 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_04c7: Unknown result type (might be due to invalid IL or missing references)
				int playerCoins = __instance.GetPlayerCoins();
				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);
					bool flag2 = num2 <= playerCoins;
					Image component = ((Component)element.transform.Find("icon")).GetComponent<Image>();
					component.sprite = val2.GetIcon();
					((Graphic)component).color = (Color)((!flag2) ? new Color(1f, 0f, 1f, 0f) : (flag ? TradersExtended.colorBuybackHighlighted.Value : Color.white));
					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 ? TradersExtended.colorBuybackText.Value : 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));
					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 = TradersExtended.colorBuybackNormal.Value;
						((ColorBlock)(ref colors)).highlightedColor = TradersExtended.colorBuybackHighlighted.Value;
						((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), "BuySelectedItem")]
		public static class StoreGui_BuySelectedItem_TraderCoinsUpdate
		{
			public static bool isCalled;

			[HarmonyPriority(800)]
			public static bool Prefix(StoreGui __instance, ref Tuple<int, int> __state)
			{
				isCalled = true;
				if (__instance.m_selectedItem != null && __instance.CanAfford(__instance.m_selectedItem))
				{
					if (BuyBackItem(__instance))
					{
						return false;
					}
					TradersExtended.TradeableItem.GetStackQualityFromStack(__instance.m_selectedItem.m_stack, out var stack, out var quality);
					if (quality != 0)
					{
						__state = Tuple.Create(__instance.m_selectedItem.m_stack, __instance.m_selectedItem.m_prefab.m_itemData.m_quality);
						__instance.m_selectedItem.m_stack = stack;
						__instance.m_selectedItem.m_prefab.m_itemData.m_quality = quality;
					}
				}
				return true;
			}

			[HarmonyPriority(800)]
			public static void Postfix(StoreGui __instance, Tuple<int, int> __state)
			{
				isCalled = false;
				if (__state != null && __instance.m_selectedItem?.m_prefab?.m_itemData != null)
				{
					__instance.m_selectedItem.m_stack = __state.Item1;
					__instance.m_selectedItem.m_prefab.m_itemData.m_quality = __state.Item2;
				}
			}
		}

		[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 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>();

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

		internal static ItemToSell selectedItem;

		private static int selectedItemIndex = -1;

		private static ItemToSell buybackItem;

		private static Func<bool> _adventureModeEnabled;

		private static Vector3 defaultStorePosition;

		public static bool AdventureModeEnabled(Trader trader)
		{
			return _adventureModeEnabled != null && Utils.GetPrefabName(((Component)trader).gameObject) == "Haldor" && _adventureModeEnabled();
		}

		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 __instance)
		{
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: 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_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			ItemDrop coinPrefab = __instance.m_coinPrefab;
			if ((Object)(object)coinPrefab == (Object)null)
			{
				TradersExtended.logger.LogWarning((object)"No m_coinPrefab set in StoreGui");
			}
			else
			{
				if (selectedItem == null)
				{
					return;
				}
				selectedItemIndex = GetSelectedItemIndex();
				if (TradersExtended.enableBuyBack.Value)
				{
					buybackItem = selectedItem.Clone();
				}
				if (selectedItem.itemType == ItemToSell.ItemType.Single)
				{
					((Humanoid)Player.m_localPlayer).GetInventory().RemoveItem(selectedItem.item);
				}
				else if (selectedItem.itemType == ItemToSell.ItemType.Stack)
				{
					((Humanoid)Player.m_localPlayer).GetInventory().RemoveItem(selectedItem.item.m_shared.m_name, selectedItem.stack, (selectedItem.quality == 0) ? (-1) : selectedItem.quality, true);
				}
				else if (selectedItem.itemType == ItemToSell.ItemType.Combined)
				{
					((Humanoid)Player.m_localPlayer).GetInventory().RemoveItem(selectedItem.item.m_shared.m_name, selectedItem.amount, (selectedItem.quality == 0) ? (-1) : selectedItem.quality, true);
				}
				int num = ((Humanoid)Player.m_localPlayer).GetInventory().CountItems(coinPrefab.m_itemData.m_shared.m_name, -1, true);
				if (((Humanoid)Player.m_localPlayer).GetInventory().AddItem(((Object)((Component)coinPrefab).gameObject).name, selectedItem.price, coinPrefab.m_itemData.m_quality, coinPrefab.m_itemData.m_variant, 0L, "", false) == null)
				{
					int num2 = selectedItem.price + num - ((Humanoid)Player.m_localPlayer).GetInventory().CountItems(coinPrefab.m_itemData.m_shared.m_name, -1, true);
					int num3 = num2 / coinPrefab.m_itemData.m_shared.m_maxStackSize;
					GameObject prefab = ZNetScene.instance.GetPrefab(((Object)((Component)coinPrefab).gameObject).name);
					if (Object.op_Implicit((Object)(object)prefab))
					{
						((Character)Player.m_localPlayer).Message((MessageType)1, "$msg_dropped: $item_coins x" + num2, 0, (Sprite)null);
						while (num2 > 0)
						{
							Vector3 val = Random.insideUnitSphere * ((num3 == 1) ? 0f : 0.5f);
							GameObject val2 = Object.Instantiate<GameObject>(prefab, ((Component)Player.m_localPlayer).transform.position + ((Component)Player.m_localPlayer).transform.forward * 2f + Vector3.up + val, Quaternion.identity);
							ItemDrop component = val2.GetComponent<ItemDrop>();
							component.m_itemData.m_stack = Mathf.Min(num2, component.m_itemData.m_shared.m_maxStackSize);
							num2 -= component.m_itemData.m_stack;
						}
					}
				}
				string text = ((selectedItem.stack <= 1) ? selectedItem.item.m_shared.m_name : $"{selectedItem.stack}x{selectedItem.item.m_shared.m_name}");
				__instance.m_sellEffects.Create(((Component)__instance).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
				((Character)Player.m_localPlayer).Message((MessageType)1, Localization.instance.Localize("$msg_sold", new string[2]
				{
					text,
					selectedItem.price.ToString()
				}), 0, selectedItem.item.GetIcon());
				__instance.m_trader.OnSold();
				Gogan.LogEvent("Game", "SoldItem", text, 0L);
				__instance.FillList();
			}
		}

		private static void AddItemToSellList(TradersExtended.TradeableItem item)
		{
			if (item.price != 0 && item.stack != 0 && (string.IsNullOrEmpty(item.requiredGlobalKey) || !(from s in item.requiredGlobalKey.Split(new char[1] { ',' })
				select s.Trim() into s
				where !Utility.IsNullOrWhiteSpace(s)
				select s).Any((string s) => !ZoneSystem.instance.GetGlobalKey(s))) && (string.IsNullOrEmpty(item.notRequiredGlobalKey) || !(from s in item.notRequiredGlobalKey.Split(new char[1] { ',' })
				select s.Trim() into s
				where !Utility.IsNullOrWhiteSpace(s)
				select s).Any((string s) => ZoneSystem.instance.GetGlobalKey(s))) && (string.IsNullOrEmpty(item.requiredPlayerKey) || !(from s in item.requiredPlayerKey.Split(new char[1] { ',' })
				select s.Trim() into s
				where !Utility.IsNullOrWhiteSpace(s)
				select s).Any((string s) => !((Humanoid)Player.m_localPlayer).HaveUniqueKey(s))) && (string.IsNullOrEmpty(item.notRequiredPlayerKey) || !(from s in item.notRequiredPlayerKey.Split(new char[1] { ',' })
				select s.Trim() into s
				where !Utility.IsNullOrWhiteSpace(s)
				select s).Any((string s) => ((Humanoid)Player.m_localPlayer).HaveUniqueKey(s))) && TryGetPriceKey(item, out var key))
			{
				if (!tempItemsPrice.ContainsKey(key))
				{
					tempItemsPrice[key] = new Dictionary<int, int>();
				}
				tempItemsPrice[key][item.stack] = item.price;
			}
		}

		private static bool TryGetPriceKey(TradersExtended.TradeableItem item, out string key)
		{
			key = "";
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item.prefab);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				return false;
			}
			ItemData itemData = itemPrefab.GetComponent<ItemDrop>().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)
		{
			if (item.m_shared.m_name == StoreGui.instance.m_coinPrefab.m_itemData.m_shared.m_name)
			{
				return true;
			}
			if (!string.IsNullOrWhiteSpace(((TMP_InputField)playerFilter).text) && Localization.instance.Localize(item.m_shared.m_name).ToLower().IndexOf(((TMP_InputField)playerFilter).text.ToLower()) == -1)
			{
				return true;
			}
			if (TradersExtended.hideEquippedAndHotbarItems.Value && item.m_equipped)
			{
				return true;
			}
			if (TradersExtended.hideEquippedAndHotbarItems.Value && item.m_gridPos.y == 0 && item.IsEquipable())
			{
				return true;
			}
			if (TradersExtended.hideEquippedAndHotbarItems.Value && (from func in AzuExtendedPlayerInventory.API.GetSlots().GetItemFuncs
				where func != null
				select func(Player.m_localPlayer)).Contains(item))
			{
				return true;
			}
			if (TradersExtended.hideEquippedAndHotbarItems.Value && ExtraSlots.API.GetAllExtraSlotsItems().Contains(item))
			{
				return true;
			}
			return false;
		}

		private static Dictionary<int, int> 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;
		}

		private static void AddToSellList(ItemData item, int itemStack, int itemPrice, float priceFactor, int quality, ItemToSell.ItemType itemType)
		{
			int price = itemPrice;
			if (itemType == ItemToSell.ItemType.Combined)
			{
				price *= itemStack;
			}
			if (itemType != ItemToSell.ItemType.Stack && TradersExtended.qualityMultiplier.Value != 0f && quality == 0 && item.m_quality > 1)
			{
				price += (int)(TradersExtended.qualityMultiplier.Value * (float)price * (float)(item.m_quality - 1));
			}
			price = Math.Max((int)((float)price * priceFactor), 1);
			if (itemType == ItemToSell.ItemType.Single)
			{
				tempItems.Add(new ItemToSell
				{
					itemType = itemType,
					item = item,
					stack = itemStack,
					price = price,
					quality = quality
				});
			}
			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 && (quality == 0 || tmpItem.item.m_quality == quality) && tmpItem.price == price);
				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 = quality
				});
			}
			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 && (quality == 0 || tmpItem.item.m_quality == quality) && tmpItem.stack == 1);
				if (itemToSell2 != null)
				{
					itemToSell2.price += price;
					itemToSell2.amount += itemStack;
					return;
				}
				tempItems.Add(new ItemToSell
				{
					itemType = itemType,
					item = item,
					stack = 1,
					price = price,
					amount = itemStack,
					quality = quality,
					pricePerItem = itemPrice + ((TradersExtended.qualityMultiplier.Value != 0f && quality == 0 && item.m_quality > 1) ? ((int)(TradersExtended.qualityMultiplier.Value * (float)itemPrice * (float)(item.m_quality - 1))) : 0)
				});
			}
		}

		public static void FillSellableList(StoreGui __instance)
		{
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: 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_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: 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_0523: Expected O, but got Unknown
			//IL_04f5: 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.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);
				});
			}
			if (TradersExtended.sellableItems.ContainsKey(TradersExtended.CommonListKey(TradersExtended.ItemsListType.Sell)))
			{
				TradersExtended.sellableItems[TradersExtended.CommonListKey(TradersExtended.ItemsListType.Sell)].ForEach(delegate(TradersExtended.TradeableItem item)
				{
					AddItemToSellList(item);
				});
			}
			float priceFactor = TraderCoins.GetPriceFactor(buyPrice: false);
			foreach (ItemData item in ((Humanoid)Player.m_localPlayer).GetInventory().GetAllItemsSortedByName())
			{
				if (IgnoreItemForSell(item))
				{
					continue;
				}
				int quality;
				Dictionary<int, int> stackPrices = GetStackPrices(item, out quality);
				if (stackPrices == null)
				{
					continue;
				}
				foreach (int item2 in stackPrices.Keys.OrderBy((int x) => x))
				{
					if (item2 == 1)
					{
						if (item.m_shared.m_maxStackSize == 1)
						{
							AddToSellList(item, 1, stackPrices[item2], priceFactor, quality, ItemToSell.ItemType.Single);
						}
						else
						{
							AddToSellList(item, item.m_stack, stackPrices[item2], priceFactor, quality, ItemToSell.ItemType.Combined);
						}
					}
					else
					{
						AddToSellList(item, item2, stackPrices[item2], priceFactor, quality, ItemToSell.ItemType.Stack);
					}
				}
			}
			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 i = 0; i < tempItems.Count; i++)
			{
				ItemToSell itemToSell = tempItems[i];
				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 num2 = (width - ((Rect)(ref rect)).width) / 2f;
				val.anchoredPosition = new Vector2(num2, (float)i * (0f - __instance.m_itemSpacing) - num2);
				bool flag = TraderCoins.CanSell(itemToSell.price);
				Image component = ((Component)element.transform.Find("icon")).GetComponent<Image>();
				component.sprite = itemToSell.item.GetIcon();
				((Graphic)component).color = (Color)(flag ? 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));
				TMP_Text component3 = ((Component)element.transform.Find("coin_bkg").Find("price")).GetComponent<TMP_Text>();
				component3.SetText(itemToSell.price.ToString());
				if (!flag)
				{
					((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_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			if (!ItemToSell.IsBuyBackItem(store.m_selectedItem))
			{
				return false;
			}
			bool flag;
			if (buybackItem.itemType == ItemToSell.ItemType.Single)
			{
				flag = ((Humanoid)Player.m_localPlayer).GetInventory().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);
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				GameObject dropPrefab = buybackItem.item.m_dropPrefab;
				flag = inventory.AddItem((dropPrefab != null) ? ((Object)dropPrefab).name : null, num2, num, variant, buybackItem.item.m_crafterID, buybackItem.item.m_crafterName, buybackItem.item.m_pickedUp) != null;
			}
			if (flag)
			{
				buybackItem = null;
				((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;
		}

		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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			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;
				}
				if (TradersExtended.fixedStoreGuiPosition.Value != Vector2.zero)
				{
					StoreGui.instance.m_rootPanel.transform.localPosition = Vector2.op_Implicit(TradersExtended.fixedStoreGuiPosition.Value);
				}
				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, List<TradeItem> __result)
		{
			if (TradersExtended.tradeableItems.ContainsKey(listKey))
			{
				CollectionExtensions.DoIf<TradersExtended.TradeableItem>((IEnumerable<TradersExtended.TradeableItem>)TradersExtended.tradeableItems[listKey], (Func<TradersExtended.TradeableItem, bool>)((TradersExtended.TradeableItem item) => item.IsItemToSell()), (Action<TradersExtended.TradeableItem>)delegate(TradersExtended.TradeableItem item)
				{
					__result.Add(item.ToTradeItem());
				});
			}
		}

		public static void UpdateNames()
		{
			Trader trader = StoreGui.instance.m_trader;
			string text = ((trader != null) ? trader.GetHoverName() : null);
			string text2 = Player.m_localPlayer.GetPlayerName();
			if (TradersExtended.traderUseCoins.Value && TradersExtended.traderUseFlexiblePricing.Value)
			{
				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)
			{
				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)
		{
			return TradersExtended.traderRepair.Value && (TradersExtended._tradersToRepairWeapons.Contains(TradersExtended.TraderName(trader)) || TradersExtended._tradersToRepairArmor.Contains(TradersExtended.TraderName(trader)));
		}

		public static void Update(StoreGui storeGui)
		{
			if (!((Object)(object)StoreGui.instance == (Object)null) && StorePanel.IsOpen())
			{
				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_00e9: 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)
			//IL_010c: 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)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			ItemData itemToRepair = GetItemToRepair(storeGui);
			if (itemToRepair == null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, Player.m_localPlayer.GetPlayerName() + " $msg_doesnotneedrepair", 0, (Sprite)null);
				return;
			}
			if (storeGui.GetPlayerCoins() < Math.Abs(TradersExtended.traderRepairCost.Value))
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "$msg_outof $item_coins", 0, (Sprite)null);
				return;
			}
			itemToRepair.m_durability = itemToRepair.GetMaxDurability();
			if (TradersExtended.traderRepairCost.Value != 0)
			{
				((Humanoid)Player.m_localPlayer).GetInventory().RemoveItem(storeGui.m_coinPrefab.m_itemData.m_shared.m_name, Math.Abs(TradersExtended.traderRepairCost.Value), -1, true);
			}
			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)
			{
				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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Invalid comparison between Unknown and I4
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Invalid comparison between Unknown and I4
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Invalid comparison between Unknown and I4
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Invalid comparison between Unknown and I4
			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 TradersExtended._tradersToRepairWeapons.Contains(TradersExtended.TraderName(trader));
			}
			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 TradersExtended._tradersToRepairArmor.Contains(TradersExtended.TraderName(trader));
			}
			return false;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("randyknapp.mods.auga")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("shudnal.TradersExtended", "Traders Extended", "1.3.13")]
	public class TradersExtended : BaseUnityPlugin
	{
		[Serializable]
		public class TradeableItem
		{
			public const int qualityStackMultiplier = 1000000;

			public string prefab;

			public int stack = 1;

			public int price = 1;

			public int quality = 0;

			public string requiredGlobalKey = "";

			public string notRequiredGlobalKey = "";

			public string requiredPlayerKey = "";

			public string notRequiredPlayerKey = "";

			[NonSerialized]
			public ItemDrop itemDrop;

			public bool IsItemToSell()
			{
				if (!Object.op_Implicit((Object)(object)ZoneSystem.instance) || !Object.op_Implicit((Object)(object)ObjectDB.instance) || !Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return false;
				}
				if (!string.IsNullOrEmpty(requiredGlobalKey) && (from s in requiredGlobalKey.Split(new char[1] { ',' })
					select s.Trim() into s
					where !Utility.IsNullOrWhiteSpace(s)
					select s).Any((string s) => !ZoneSystem.instance.GetGlobalKey(s)))
				{
					return false;
				}
				if (!string.IsNullOrEmpty(notRequiredGlobalKey) && (from s in notRequiredGlobalKey.Split(new char[1] { ',' })
					select s.Trim() into s
					where !Utility.IsNullOrWhiteSpace(s)
					select s).Any((string s) => ZoneSystem.instance.GetGlobalKey(s)))
				{
					return false;
				}
				if (!string.IsNullOrEmpty(requiredPlayerKey) && (from s in requiredPlayerKey.Split(new char[1] { ',' })
					select s.Trim() into s
					where !Utility.IsNullOrWhiteSpace(s)
					select s).Any((string s) => !((Humanoid)Player.m_localPlayer).HaveUniqueKey(s)))
				{
					return false;
				}
				if (!string.IsNullOrEmpty(notRequiredPlayerKey) && (from s in notRequiredPlayerKey.Split(new char[1] { ',' })
					select s.Trim() into s
					where !Utility.IsNullOrWhiteSpace(s)
					select s).Any((string s) => ((Humanoid)Player.m_localPlayer).HaveUniqueKey(s)))
				{
					return false;
				}
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefab);
				if ((Object)(object)itemPrefab == (Object)null || !itemPrefab.TryGetComponent<ItemDrop>(ref itemDrop))
				{
					return false;
				}
				return !checkForDiscovery.Value || IgnoreItemDiscovery(prefab.ToLower()) || Player.m_localPlayer.IsMaterialKnown(itemDrop.m_itemData.m_shared.m_name);
			}

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

			public static void NormalizeStack(TradeItem item)
			{
				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 m_stack, out int stack, out int quality)
			{
				stack = m_stack % 1000000;
				quality = m_stack / 1000000;
			}

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

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

		public enum ItemsListType
		{
			Buy,
			Sell
		}

		public class ItemToExport
		{
			public string p;

			public string n;

			public int se;

			public int b;

			public int s;

			public string f;
		}

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

			public static EventHandler <>9__54_0;

			public static EventHandler <>9__54_1;

			public static EventHandler <>9__54_2;

			public static EventHandler <>9__54_3;

			public static EventHandler <>9__54_4;

			public static ConsoleEvent <>9__57_0;

			public static ConsoleOptionsFetcher <>9__57_1;

			public static ConsoleEventFailable <>9__57_2;

			public static ConsoleOptionsFetcher <>9__57_3;

			public static Action<ItemToExport> <>9__60_0;

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

			public static Func<ItemToExport, string> <>9__60_2;

			public static Func<ItemToExport, string> <>9__60_3;

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

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

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

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

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

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

			public static Func<bool> <>9__69_0;

			internal void <ConfigInit>b__54_0(object sender, EventArgs args)
			{
				FillConfigLists();
			}

			internal void <ConfigInit>b__54_1(object sender, EventArgs args)
			{
				FillConfigLists();
			}

			internal void <ConfigInit>b__54_2(object sender, EventArgs args)
			{
				FillConfigLists();
			}

			internal void <ConfigInit>b__54_3(object sender, EventArgs args)
			{
				StartConfigLoad();
			}

			internal void <ConfigInit>b__54_4(object sender, EventArgs args)
			{
				StorePanel.SetStoreGuiPosition();
			}

			internal void <InitCommands>b__57_0(ConsoleEventArgs args)
			{
				if (args.Length >= 2)
				{
					string text = args.FullLine.Substring(args[0].Length + 1);
					if (text == "save")
					{
						SaveFromObjectDB(args.Context);
					}
					else if (text == "itemlist")
					{
						ExportItemListFromObjectDB(args.Context);
					}
				}
				else
				{
					args.Context.AddString("Actions: save - Save full item list into config folder, itemlist - Save filtered item list into config folder");
				}
			}

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

			internal object <InitCommands>b__57_2(ConsoleEventArgs args)
			{
				if (args.Length <= 1)
				{
					return false;
				}
				TraderCoins.SetTraderCoins(StringExtensionMethods.GetStableHashCode(args[1]), args.TryParameterInt(2, traderCoinsMinimumAmount.Value));
				return true;
			}

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

			internal void <ExportItemListFromObjectDB>b__60_0(ItemToExport item)
			{
				LogInfo(item.p + " " + item.f);
			}

			internal bool <ExportItemListFromObjectDB>b__60_1(Humanoid human)
			{
				BaseAI val = default(BaseAI);
				return ((Component)human).TryGetComponent<BaseAI>(ref val);
			}

			internal string <ExportItemListFromObjectDB>b__60_2(ItemToExport item)
			{
				return item.p;
			}

			internal string <ExportItemListFromObjectDB>b__60_3(ItemToExport item)
			{
				return item.f;
			}

			internal string <FillConfigLists>b__61_0(string p)
			{
				return p.Trim().ToLower();
			}

			internal bool <FillConfigLists>b__61_1(string p)
			{
				return !string.IsNullOrWhiteSpace(p);
			}

			internal string <FillConfigLists>b__61_2(string p)
			{
				return TraderName(p.Trim());
			}

			internal bool <FillConfigLists>b__61_3(string p)
			{
				return !string.IsNullOrWhiteSpace(p);
			}

			internal string <FillConfigLists>b__61_4(string p)
			{
				return TraderName(p.Trim());
			}

			internal bool <FillConfigLists>b__61_5(string p)
			{
				return !string.IsNullOrWhiteSpace(p);
			}

			internal bool <AddCommonValuableItems>b__69_0()
			{
				return Object.op_Implicit((Object)(object)ObjectDB.instance);
			}
		}

		[CompilerGenerated]
		private sealed class <AddCommonValuableItems>d__69 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private string <listKey>5__1;

			private int <itemsCount>5__2;

			private List<GameObject>.Enumerator <>s__3;

			private GameObject <prefab>5__4;

			private ItemDrop <itemDrop>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AddCommonValuableItems>d__69(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<listKey>5__1 = null;
				<>s__3 = default(List<GameObject>.Enumerator);
				<prefab>5__4 = null;
				<itemDrop>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => Object.op_Implicit((Object)(object)ObjectDB.instance)));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<listKey>5__1 = CommonListKey(ItemsListType.Sell);
					if (!sellableItems.ContainsKey(<listKey>5__1))
					{
						sellableItems[<listKey>5__1] = new List<TradeableItem>();
					}
					<itemsCount>5__2 = sellableItems[<listKey>5__1].Count;
					<>s__3 = ObjectDB.instance.m_items.GetEnumerator();
					try
					{
						while (<>s__3.MoveNext())
						{
							<prefab>5__4 = <>s__3.Current;
							if (<prefab>5__4.TryGetComponent<ItemDrop>(ref <itemDrop>5__5) && <itemDrop>5__5.m_itemData.m_shared.m_value > 0 && !IsItemInSellList(((Object)<prefab>5__4).name))
							{
								sellableItems[<listKey>5__1].Add(new TradeableItem
								{
									prefab = ((Object)<prefab>5__4).name,
									price = <itemDrop>5__5.m_itemData.m_shared.m_value
								});
								<itemDrop>5__5 = null;
								<prefab>5__4 = null;
							}
						}
					}
					finally
					{
						((IDisposable)<>s__3).Dispose();
					}
					<>s__3 = default(List<GameObject>.Enumerator);
					LogInfo($"Loaded {sellableItems[<listKey>5__1].Count - <itemsCount>5__2} common valuable items from ObjectDB");
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <LoadConfigs>d__66 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private Dictionary<string, string>.Enumerator <>s__1;

			private KeyValuePair<string, string> <configJSON>5__2;

			private string[] <configKey>5__3;

			private string <trader>5__4;

			private ItemsListType <list>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LoadConfigs>d__66(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = default(Dictionary<string, string>.Enumerator);
				<configJSON>5__2 = default(KeyValuePair<string, string>);
				<configKey>5__3 = null;
				<trader>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					tradeableItems.Clear();
					sellableItems.Clear();
					<>s__1 = configsJSON.Value.GetEnumerator();
					try
					{
						while (<>s__1.MoveNext())
						{
							<configJSON>5__2 = <>s__1.Current;
							<configKey>5__3 = <configJSON>5__2.Key.Split(new char[1] { '.' });
							<trader>5__4 = <configKey>5__3[0];
							Enum.TryParse<ItemsListType>(<configKey>5__3[1], ignoreCase: true, out <list>5__5);
							if (<list>5__5 == ItemsListType.Buy)
							{
								LoadTradeableItems(<configJSON>5__2.Value, <trader>5__4);
							}
							else
							{
								LoadSellableItems(<configJSON>5__2.Value, <trader>5__4);
							}
							<configKey>5__3 = null;
							<trader>5__4 = null;
							<configJSON>5__2 = default(KeyValuePair<string, string>);
						}
					}
					finally
					{
						((IDisposable)<>s__1).Dispose();
					}
					<>s__1 = default(Dictionary<string, string>.Enumerator);
					if (addCommonValuableItemsToSellList.Value)
					{
						<>2__current = AddCommonValuableItems();
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public const string pluginID = "shudnal.TradersExtended";

		public const string pluginName = "Traders Extended";

		public const string pluginVersion = "1.3.13";

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

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

		public static ManualLogSource logger;

		internal static TradersExtended instance;

		private static ConfigEntry<bool> loggingEnabled;

		private static ConfigEntry<bool> configLocked;

		public static ConfigEntry<bool> checkForDiscovery;

		private static ConfigEntry<string> checkForDiscoveryIgnoreItems;

		public static ConfigEntry<bool> traderRepair;

		public static ConfigEntry<int> traderRepairCost;

		private static ConfigEntry<string> tradersToRepairWeapons;

		private 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<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<Color> colorBuybackNormal;

		public static ConfigEntry<Color> colorBuybackHighlighted;

		public static ConfigEntry<Color> colorBuybackText;

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

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

		private static readonly CustomSyncedValue<Dictionary<string, string>> configsJSON = new CustomSyncedValue<Dictionary<string, string>>(configSync, "JSON configs", new Dictionary<string, string>());

		private static DirectoryInfo pluginDirectory;

		private static DirectoryInfo configDirectory;

		public static Component epicLootPlugin;

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

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

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

		private void Awake()
		{
			harmony.PatchAll();
			instance = this;
			logger = ((BaseUnityPlugin)this).Logger;
			pluginDirectory = new DirectoryInfo(Assembly.GetExecutingAssembly().Location).Parent;
			configDirectory = new DirectoryInfo(Paths.ConfigPath);
			ConfigInit();
			configSync.AddLockingConfigEntry<bool>(configLocked);
			configsJSON.ValueChanged += StartConfigLoad;
			epicLootPlugin = ((Component)this).GetComponent("EpicLoot");
			Game.isModded = true;
		}

		private void Update()
		{
			AmountDialog.Update();
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
			instance = null;
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}

		public static void LogInfo(object data)
		{
			if (loggingEnabled.Value)
			{
				((BaseUnityPlugin)instance).Logger.LogInfo(data);
			}
		}

		private void ConfigInit()
		{
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			config("General", "NexusID", 2509, "Nexus mod ID for updates", synchronizedSetting: false);
			configLocked = config("General", "Lock Configuration", defaultValue: true, "Configuration is locked and can be changed by server admins only.");
			loggingEnabled = config("General", "Logging enabled", defaultValue: false, "Enable logging. [Not Synced with Server]", synchronizedSetting: false);
			checkForDiscovery = config("Item discovery", "Sell only discovered items", defaultValue: true, "Trader will not sell items had not discovered by a buyer.");
			checkForDiscoveryIgnoreItems = config("Item discovery", "Undiscovered items list to sell", "", "Trader will sell items from that list without check for discovery. Vanilla items are included by default.");
			checkForDiscoveryIgnoreItems.SettingChanged += delegate
			{
				FillConfigLists();
			};
			coinsPatch = config("Item coins", "Change values", defaultValue: false, "Change properties of coins item");
			coinsWeight = config("Item coins", "Coins weight", 0f, "Weight of single coin");
			coinsStackSize = config("Item coins", "Coins stack size", 2000, "Max size of coins stack");
			traderRepair = config("Trader repair", "Traders can repair items", defaultValue: true, "Traders will have an ability to repair items");
			tradersToRepairWeapons = config("Trader repair", "Traders capable to repair weapons", "Haldor", "Prefab name of Traders that have an ability to repair weapons");
			tradersToRepairArmor = config("Trader repair", "Traders capable to repair armor", "Hildir", "Prefab name of Traders that have an ability to repair armor");
			traderRepairCost = config("Trader repair", "Traders repair cost", 2, "Cost of repair in gold");
			tradersToRepairWeapons.SettingChanged += delegate
			{
				FillConfigLists();
			};
			tradersToRepairArmor.SettingChanged += delegate
			{
				FillConfigLists();
			};
			traderUseCoins = config("Trader coins", "Traders use coins", defaultValue: true, "Traders will have an limited daily refilled amount of coins");
			traderUseFlexiblePricing = config("Trader coins", "Traders use flexible pricing", defaultValue: true, "Traders will give a discount when their amount of coins is more than minimum or will set a markup when their amount of coins is less than minimum. Amount changes gradually.");
			traderCoinsMinimumAmount = config("Trader coins pricing", "Amount of coins after replenishment minimum", 2000, "Minimum amount of coins trader will have after replenishment.");
			traderCoinsIncreaseAmount = config("Trader coins pricing", "Amount of coins replenished daily", 1000, "Amount of coins added to current amount until maximum is reached");
			traderCoinsDecreaseAmount = config("Trader coins pricing", "Amount of coins removed daily", 0, "Amount of coins removed from current amount until maximum is reached");
			traderCoinsMaximumAmount = config("Trader coins pricing", "Amount of coins after replenishment maximum", 6000, "Maximum amount of coins for replenishments to stop.");
			traderDiscount = config("Trader coins pricing", "Trader discount", 0.7f, "Discount for items to buy from trader when current amount of coins is more than maximum replenishment amount.");
			traderMarkup = config("Trader coins pricing", "Trader markup", 1.5f, "Markup for items to buy from trader when current amount of coins is less than minimum replenishment amount.");
			traderCoinsReplenishmentRate = config("Trader coins pricing", "Trader coins replenishment rate in days", 1, "Amount of coins is updated at morning");
			traderCoinsSendReplenishmentMessage = config("Trader coins pricing", "Send replenishment message in the morning", defaultValue: true, "Show message when trader coins are updated");
			tradersCustomPrefabs = config("Misc", "Custom traders prefab names", "", "List of custom prefab names of Trader added by mods to control coins. Prefab name, case sensitive, comma separated");
			disableVanillaItems = config("Misc", "Disable vanilla items", defaultValue: false, "Disable vanilla items on traders. Custom traders could or could not work depending on their implementation.");
			qualityMultiplier = config("Misc", "Quality multiplier", 0f, "Quality multiplier for price. Each level of additional quality level adds that percent of price.");
			hideEquippedAndHotbarItems = config("Misc", "Hide equipped and hotbar items", defaultValue: true, "Equippable items from first row of inventory and all items currently equipped will not be shown at the sell list.");
			addCommonValuableItemsToSellList = config("Misc", "Add common valuable items to sell list", defaultValue: true, "Add common valuable items to all traders sell list.");
			fixedStoreGuiPosition = config<Vector2>("Misc", "Fixed position for Store GUI", Vector2.zero, "If set then Store GUI will take that absolute position.");
			disableOtherModsItems = config("Misc", "Disable other mods items", defaultValue: false, "Disable items from every other mod. Custom traders could or could not work depending on their implementation.");
			addCommonValuableItemsToSellList.SettingChanged += delegate
			{
				StartConfigLoad();
			};
			fixedStoreGuiPosition.SettingChanged += delegate
			{
				StorePanel.SetStoreGuiPosition();
			};
			enableBuyBack = config("Trader buyback", "Enable buyback for last item sold", defaultValue: true, "First item to buy will be the last item you have recently sold.");
			colorBuybackNormal = config<Color>("Trader buyback", "Item background color", new Color(0f, 0.42f, 0.42f), "Color of buyback item background.");
			colorBuybackHighlighted = config<Color>("Trader buyback", "Item highlighted color", new Color(0.25f, 0.62f, 0.62f), "Color of highlighted buyback item.");
			colorBuybackText = config<Color>("Trader buyback", "Item font color", new Color(1f, 0.81f, 0f), "Color of buyback item name.");
			InitCommands();
		}

		private ConfigEntry<T> config<T>(string group, string name, T defaultValue, ConfigDescription description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, defaultValue, description);
			SyncedConfigEntry<T> syncedConfigEntry = configSync.AddConfigEntry<T>(val);
			syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
			return val;
		}

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

		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__57_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					if (args.Length >= 2)
					{
						string text = args.FullLine.Substring(args[0].Length + 1);
						if (text == "save")
						{
							SaveFromObjectDB(args.Context);
						}
						else if (text == "itemlist")
						{
							ExportItemListFromObjectDB(args.Context);
						}
					}
					else
					{
						args.Context.AddString("Actions: save - Save full item list into config folder, itemlist - Save filtered item list into config folder");
					}
				};
				<>c.<>9__57_0 = val;
				obj = (object)val;
			}
			object obj2 = <>c.<>9__57_1;
			if (obj2 == null)
			{
				ConsoleOptionsFetcher val2 = () => new List<string> { "save", "itemlist" };
				<>c.<>9__57_1 = val2;
				obj2 = (object)val2;
			}
			new ConsoleCommand("tradersextended", "save - Save full item list into config folder, itemlist - Save filtered item list into config folder", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)obj2, true, false, false);
			object obj3 = <>c.<>9__57_2;
			if (obj3 == null)
			{
				ConsoleEventFailable val3 = delegate(ConsoleEventArgs args)
				{
					if (args.Length <= 1)
					{
						return false;
					}
					TraderCoins.SetTraderCoins(StringExtensionMethods.GetStableHashCode(args[1]), args.TryParameterInt(2, traderCoinsMinimumAmount.Value));
					return true;
				};
				<>c.<>9__57_2 = val3;
				obj3 = (object)val3;
			}
			object obj4 = <>c.<>9__57_3;
			if (obj4 == null)
			{
				ConsoleOptionsFetcher val4 = () => TraderCoins.GetTraderPrefabs();
				<>c.<>9__57_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)
		{
			List<TradeableItem> list = new List<TradeableItem>();
			ItemDrop val = default(ItemDrop);
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if (item.TryGetComponent<ItemDrop>(ref val))
				{
					list.Add(new TradeableItem
					{
						prefab = ((Object)item).name,
						price = Math.Max(val.m_itemData.m_shared.m_value, 1)
					});
				}
			}
			string contents = JsonConvert.SerializeObject((object)list, (Formatting)1);
			Directory.CreateDirectory(Path.Combine(configDirectory.FullName, "shudnal.TradersExtended"));
			string path = Path.Combine(configDirectory.FullName, "shudnal.TradersExtended", "ObjectDB.list.json");
			File.WriteAllText(path, contents);
			context.AddString(string.Format("Saved {0} items to \"\\config\\{1}\\ObjectDB.list.json\"", list.Count, "shudnal.TradersExtended"));
		}

		public static void ExportItemListFromObjectDB(Terminal context)
		{
			//IL_00ba: 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_00d9: Invalid comparison between Unknown and I4
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Expected O, but got Unknown
			//IL_0329: 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_0343: Invalid comparison between Unknown and I4
			List<ItemToExport> list = new List<ItemToExport>();
			HashSet<string> hashSet = new HashSet<string>();
			Trader[] array = Resources.FindObjectsOfTypeAll<Trader>();
			Trader[] array2 = array;
			foreach (Trader val in array2)
			{
				foreach (TradeItem item in val.m_items)
				{
					if (!hashSet.Contains(((Object)item.m_prefab).name))
					{
						hashSet.Add(((Object)item.m_prefab).name);
						if (!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 ItemToExport
							{
								p = ((Object)item.m_prefab).name,
								n = Localization.instance.Localize(item.m_prefab.m_itemData.m_shared.m_name),
								se = Math.Max(item.m_prefab.m_itemData.m_shared.m_value, 0),
								b = item.m_price,
								s = item.m_stack,
								f = Utils.GetPrefabName(((Object)val).name)
							});
						}
					}
				}
			}
			CollectionExtensions.Do<ItemToExport>((IEnumerable<ItemToExport>)list, (Action<ItemToExport>)delegate(ItemToExport item)
			{
				LogInfo(item.p + " " + item.f);
			});
			BaseAI val6 = default(BaseAI);
			IEnumerable<Humanoid> enumerable = from human in Resources.FindObjectsOfTypeAll<Humanoid>()
				where ((Component)human).TryGetComponent<BaseAI>(ref val6)
				select human;
			ItemDrop val3 = default(ItemDrop);
			foreach (Humanoid item2 in enumerable)
			{
				GameObject[] defaultItems = item2.m_defaultItems;
				foreach (GameObject val2 in defaultItems)
				{
					if (val2.TryGetComponent<ItemDrop>(ref val3) && !hashSet.Contains(((Object)val2).name))
					{
						hashSet.Add(((Object)val2).name);
					}
				}
			}
			ItemDrop val4 = default(ItemDrop);
			foreach (GameObject item3 in ObjectDB.instance.m_items)
			{
				if (!item3.TryGetComponent<ItemDrop>(ref val4) || hashSet.Contains(((Object)item3).name))
				{
					continue;
				}
				hashSet.Add(((Object)item3).name);
				if (val4.m_itemData.m_shared.m_name.StartsWith("$") && 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)
				{
					if (val4.m_itemData.m_shared.m_value > 0)
					{
						list.Add(new ItemToExport
						{
							p = ((Object)val4).name,
							n = Localization.instance.Localize(val4.m_itemData.m_shared.m_name),
							se = val4.m_itemData.m_shared.m_value
						});
					}
					else
					{
						list.Add(new ItemToExport
						{
							p = ((Object)val4).name,
							n = Localization.instance.Localize(val4.m_itemData.m_shared.m_name)
						});
					}
				}
			}
			JsonSerializerSettings val5 = new JsonSerializerSettings
			{
				Formatting = (Formatting)0,
				NullValueHandling = (NullValueHandling)1,
				DefaultValueHandling = (DefaultValueHandling)1
			};
			string contents = JsonConvert.SerializeObject((object)(from item in list
				orderby item.p
				orderby item.f descending
				select item), val5);
			Directory.CreateDirectory(Path.Combine(configDirectory.FullName, "shudnal.TradersExtended"));
			string path = Path.Combine(configDirectory.FullName, "shudnal.TradersExtended", "ItemList.json");
			File.WriteAllText(path, contents);
			context.AddString(string.Format("Saved {0} items to \"\\config\\{1}\\ItemList.json\"", list.Count, "shudnal.TradersExtended"));
		}

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

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

		public static void SetupConfigWatcher()
		{
			string filter = "shudnal.TradersExtended.*.json";
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(pluginDirectory.FullName, filter);
			fileSystemWatcher.Changed += ReadConfigs;
			fileSystemWatcher.Created += ReadConfigs;
			fileSystemWatcher.Renamed += ReadConfigs;
			fileSystemWatcher.Deleted += ReadConfigs;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
			FileSystemWatcher fileSystemWatcher2 = new FileSystemWatcher(configDirectory.FullName, filter);
			fileSystemWatcher2.Changed += ReadConfigs;
			fileSystemWatcher2.Created += ReadConfigs;
			fileSystemWatcher2.Renamed += ReadConfigs;
			fileSystemWatcher2.Deleted += ReadConfigs;
			fileSystemWatcher2.IncludeSubdirectories = true;
			fileSystemWatcher2.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher2.EnableRaisingEvents = true;
			ReadConfigs(null, null);
		}

		private static void ReadConfigs(object sender, FileSystemEventArgs eargs)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			FileInfo[] files = pluginDirectory.GetFiles("*.json", SearchOption.AllDirectories);
			foreach (FileInfo fileInfo in files)
			{
				string[] array = fileInfo.Name.Split(new char[1] { '.' });
				if (array.Length != 5 || !fileInfo.Name.ToLower().StartsWith("shudnal.TradersExtended".ToLower()) || !Enum.TryParse<ItemsListType>(array[3], ignoreCase: true, out var result))
				{
					continue;
				}
				LogInfo("Found " + fileInfo.FullName);
				string key = TraderListKey(array[2], result) + ".plugin";
				try
				{
					using FileStream fileStream = new FileStream(fileInfo.FullName, FileMode.Open, FileAccess.Read, FileShare.Read);
					using StreamReader streamReader = new StreamReader(fileStream);
					dictionary.Add(key, streamReader.ReadToEnd());
					streamReader.Close();
					fileStream.Dispose();
				}
				catch (Exception ex)
				{
					logger.LogWarning((object)("Error reading file (" + fileInfo.FullName + ")! Error: " + ex.Message));
				}
			}
			FileInfo[] files2 = configDirectory.GetFiles("*.json", SearchOption.AllDirectories);
			foreach (FileInfo fileInfo2 in files2)
			{
				string[] array2 = fileInfo2.Name.Split(new char[1] { '.' });
				if (array2.Length != 5 || !fileInfo2.Name.ToLower().StartsWith("shudnal.TradersExtended".ToLower()) || !Enum.TryParse<ItemsListType>(array2[3], ignoreCase: true, out var result2))
				{
					continue;
				}
				LogInfo("Found " + fileInfo2.FullName);
				string key2 = TraderListKey(array2[2], result2) + ".config";
				try
				{
					using FileStream fileStream2 = new FileStream(fileInfo2.FullName, FileMode.Open, FileAccess.Read, FileShare.Read);
					using StreamReader streamReader2 = new StreamReader(fileStream2);
					dictionary.Add(key2, streamReader2.ReadToEnd());
					streamReader2.Close();
					fileStream2.Dispose();
				}
				catch (Exception ex2)
				{
					logger.LogWarning((object)("Error reading file (" + fileInfo2.FullName + ")! Error: " + ex2.Message));
				}
			}
			string[] manifestResourceNames = Assembly.GetExecutingAssembly().GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (!text.StartsWith("TradersExtended.Configs.") && !text.EndsWith(".json"))
				{
					continue;
				}
				string[] array3 = text.Replace("TradersExtended.Configs.", "").Replace(".json", "").Split(new char[1] { '.' });
				if (array3.Length != 2 || !Enum.TryParse<ItemsListType>(array3[1], ignoreCase: true, out var result3))
				{
					continue;
				}
				string text2 = TraderListKey(array3[0], result3) + ".internal";
				LogInfo("Found resource " + text2);
				try
				{
					using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(text);
					using StreamReader streamReader3 = new StreamReader(stream);
					dictionary.Add(text2, streamReader3.ReadToEnd());
					streamReader3.Close();
					stream.Dispose();
				}
				catch (Exception ex3)
				{
					logger.LogWarning((object)("Error reading resource (" + text + ")! Error: " + ex3.Message));
				}
			}
			configsJSON.AssignLocalValue(dictionary);
		}

		private static void StartConfigLoad()
		{
			((MonoBehaviour)instance).StartCoroutine(LoadConfigs());
		}

		[IteratorStateMachine(typeof(<LoadConfigs>d__66))]
		private static IEnumerator LoadConfigs()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadConfigs>d__66(0);
		}

		private static void LoadTradeableItems(string JSON, string trader)
		{
			string text = TraderListKey(trader, ItemsListType.Buy);
			if (!tradeableItems.ContainsKey(text))
			{
				tradeableItems.Add(text, new List<TradeableItem>());
			}
			List<TradeableItem> list;
			try
			{
				list = JsonConvert.DeserializeObject<List<TradeableItem>>(JSON);
			}
			catch (Exception ex)
			{
				logger.LogWarning((object)("Error parsing items (" + text + ")! Error: " + ex.Message));
				return;
			}
			List<TradeableItem> value = ((list == null) ? new List<TradeableItem>() : tradeableItems[text].Concat(list).ToList());
			LogInfo($"Loaded {list?.Count ?? 0} tradeable item from {text}");
			tradeableItems[text] = value;
		}

		private static void LoadSellableItems(string JSON, string trader)
		{
			string text = TraderListKey(trader, ItemsListType.Sell);
			if (!sellableItems.ContainsKey(text))
			{
				sellableItems.Add(text, new List<TradeableItem>());
			}
			List<TradeableItem> list;
			try
			{
				list = JsonConvert.DeserializeObject<List<TradeableItem>>(JSON);
			}
			catch (Exception ex)
			{
				logger.LogWarning((object)("Error parsing items (" + text + ")! Error: " + ex.Message));
				return;
			}
			List<TradeableItem> value = sellableItems[text].Concat(list).ToList();
			LogInfo($"Loaded {list?.Count ?? 0} sellable item from {text}");
			sellableItems[text] = value;
		}

		[IteratorStateMachine(typeof(<AddCommonValuableItems>d__69))]
		private static IEnumerator AddCommonValuableItems()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AddCommonValuableItems>d__69(0);
		}

		private static bool IsItemInSellList(string prefabName)
		{
			foreach (string key in sellableItems.Keys)
			{
				if (sellableItems[key].Any((TradeableItem item) => item.prefab == prefabName))
				{
					return true;
				}
			}
			return false;
		}

		internal static string TraderName(Trader trader)
		{
			return Utils.GetPrefabName(((Object)trader).name).ToLower().Replace("$npc_", "")
				.Replace("npc_", "");
		}

		internal static string TraderName(string name)
		{
			return name.ToLower().Replace("$npc_", "").Replace("npc_", "");
		}

		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
	{
		[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(EnvMan __instance, float oldDayFraction, float newDayFraction)
			{
				if (!TradersExtended.traderUseCoins.Value || !ZNet.instance.IsServer() || !IsMorning(oldDayFraction, newDayFraction))
				{
					return;
				}
				UpdateTradersCoinsDaily();
				if (TradersExtended.traderCoinsSendReplenishmentMessage.Value)
				{
					MessageHud instance = MessageHud.instance;
					if (instance != null)
					{
						instance.MessageAll((MessageType)1, "$store_topic: $msg_added $item_coins");
					}
				}
			}
		}

		[HarmonyPatch(typeof(StoreGui), "Update")]
		public static class StoreGui_Update_PlayerTraderCoinsUpdate
		{
			private static void Postfix(StoreGui __instance)
			{
				if (StorePanel.IsOpen())
				{
					playerCoins.SetText(__instance.GetPlayerCoins().ToString());
					if (TradersExtended.traderUseCoins.Value)
					{
						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
		{
			public static void Prefix(int amount, ref int __state)
			{
				__state = amount;
			}

			public static void Postfix(Inventory __instance, string name, int __state)
			{
				if (!(name != "$item_coins") && __state != 0 && StorePanel.IsOpen() && !((Object)(object)Player.m_localPlayer == (Object)null) && ((Humanoid)Player.m_localPlayer).GetInventory() == __instance)
				{
					UpdateTraderCoins(__state);
				}
			}
		}

		[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
		{
			public static void Postfix(Inventory __instance, string name, int stack, ItemData __result)
			{
				if (__result != null && !(name != "Coins") && stack != 0 && StorePanel.IsOpen() && !((Object)(object)Player.m_localPlayer == (Object)null) && ((Humanoid)Player.m_localPlayer).GetInventory() == __instance)
				{
					UpdateTraderCoins(-stack);
				}
			}
		}

		private static ZNetView traderNetView;

		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");

		public static List<string> GetTraderPrefabs()
		{
			return new List<string> { "Haldor", "Hildir", "BogWitch" }.Concat(from p in TradersExtended.tradersCustomPrefabs.Value.Split(new char[1] { ',' })
				select p.Trim() into p
				where !string.IsNullOrWhiteSpace(p)
				select p).ToList();
		}

		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) => prefab == zdo.GetPrefab()))
			{
				int @int = item.GetInt(s_traderCoins, 0);
				item.Set(s_traderCoins, newAmount, false);
				item.Set(s_traderCoinsReplenished, EnvMan.instance.GetCurrentDay(), false);
				GameObject prefab2 = ZNetScene.instance.GetPrefab(item.GetPrefab());
				TradersExtended.LogInfo($"{((prefab2 != null) ? ((Object)prefab2).name : null)} coins updated {@int} -> {newAmount}");
			}
		}

		public static void UpdateTradersCoinsDaily()
		{
			HashSet<int> traderPrefabs = new HashSet<int>(from selector in GetTraderPrefabs()
				select StringExtensionMethods.GetStableHashCode(selector));
			foreach (ZDO item in ZDOMan.instance.m_objectsByID.Values.Where((ZDO zdo) => traderPrefabs.Contains(zdo.GetPrefab())))
			{
				int @int = item.GetInt(s_traderCoinsReplenished, 0);
				if (EnvMan.instance.GetCurrentDay() - @int >= TradersExtended.traderCoinsReplenishmentRate.Value)
				{
					int int2 = item.GetInt(s_traderCoins, 0);
					if (int2 < TradersExtended.traderCoinsMaximumAmount.Value || TradersExtended.traderCoinsDecreaseAmount.Value > 0)
					{
						int num = ((int2 >= TradersExtended.traderCoinsMaximumAmount.Value) ? Math.Max(TradersExtended.traderCoinsMaximumAmount.Value, int2 - TradersExtended.traderCoinsDecreaseAmount.Value) : Mathf.Clamp(int2 + TradersExtended.traderCoinsIncreaseAmount.Value, TradersExtended.traderCoinsMinimumAmount.Value, TradersExtended.traderCoinsMaximumAmount.Value));
						item.Set(s_traderCoins, num, false);
						item.Set(s_traderCoinsReplenished, EnvMan.instance.GetCurrentDay(), false);
						GameObject prefab = ZNetScene.instance.GetPrefab(item.GetPrefab());
						TradersExtended.LogInfo($"{((prefab != null) ? ((Object)prefab).name : null)} coins updated {int2} -> {num}");
					}
				}
			}
		}

		public static bool CanSell(int price)
		{
			return !TradersExtended.traderUseCoins.Value || price <= GetTraderCoins();
		}

		public static void UpdateTraderCoins(int amountToAdd = 0)
		{
			if (!TradersExtended.traderUseCoins.Value)
			{
				return;
			}
			if ((Object)(object)traderNetView == (Object)null)
			{
				Trader trader = StoreGui.instance.m_trader;
				traderNetView = ((trader != null) ? ((Component)trader).GetComponent<ZNetView>() : null);
			}
			if (!((Object)(object)traderNetView == (Object)null) && traderNetView.IsValid())
			{
				traderNetView.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()
		{
			traderCoinsPanel.SetActive(TradersExtended.traderUseCoins.Value);
		}

		public static int GetTraderCoins()
		{
			if ((Object)(object)traderNetView == (Object)null)
			{
				Trader trader = StoreGui.instance.m_trader;
				traderNetView = ((trader != null) ? ((Component)trader).GetComponent<ZNetView>() : null);
			}
			if ((Object)(object)traderNetView == (Object)null || !traderNetView.IsValid())
			{
				return TradersExtended.traderCoinsMinimumAmount.Value;
			}
			return traderNetView.GetZDO().GetInt(s_traderCoins, TradersExtended.traderCoinsMinimumAmount.Value);
		}

		private static float GetTraderBuyPriceFactor(int coins)
		{
			if (!TradersExtended.traderUseFlexiblePricing.Value)
			{
				return 1f;
			}
			if (coins < TradersExtended.traderCoinsMinimumAmount.Value)
			{
				return RoundFactorToPercent(Mathf.Lerp(TradersExtended.traderMarkup.Value, 1f, (float)coins / (float)TradersExtended.traderCoinsMinimumAmount.Value));
			}
			return RoundFactorToPercent(Mathf.Lerp(1f, TradersExtended.traderDiscount.Value, (float)(coins - TradersExtended.traderCoinsMinimumAmount.Value) / (float)(TradersExtended.traderCoinsMaximumAmount.Value - TradersExtended.traderCoinsMinimumAmount.Value)));
		}

		private static float GetTraderSellPriceFactor(int coins)
		{
			if (!TradersExtended.traderUseFlexiblePricing.Value)
			{
				return 1f;
			}
			if (coins < TradersExtended.traderCoinsMinimumAmount.Value)
			{
				return RoundFactorToPercent(Mathf.Lerp(TradersExtended.traderDiscount.Value, 1f, (float)coins / (float)TradersExtended.traderCoinsMinimumAmount.Value));
			}
			return RoundFactorToPercent(Mathf.Lerp(1f, TradersExtended.traderMarkup.Value, (float)(coins - TradersExtended.traderCoinsMinimumAmount.Value) / (float)(TradersExtended.traderCoinsMaximumAmount.Value - TradersExtended.traderCoinsMinimumAmount.Value)));
		}

		private static float RoundFactorToPercent(float factor)
		{
			return Mathf.Round(factor * 100f) / 100f;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[<ed824176-c4eb-471e-b153-cdd589fc0ff9>Embedded]
	[CompilerGenerated]
	internal sealed class <ed824176-c4eb-471e-b153-cdd589fc0ff9>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<ed824176-c4eb-471e-b153-cdd589fc0ff9>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <4b50466e-6b37-4c0d-8bb2-84f35d67efa3>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <4b50466e-6b37-4c0d-8bb2-84f35d67efa3>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <4b50466e-6b37-4c0d-8bb2-84f35d67efa3>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<ed824176-c4eb-471e-b153-cdd589fc0ff9>Embedded]
	internal sealed class <6442f216-3769-4175-b302-89372a5a3593>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <6442f216-3769-4175-b302-89372a5a3593>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[<ed824176-c4eb-471e-b153-cdd589fc0ff9>Embedded]
	[CompilerGenerated]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)]
	[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
	internal abstract class OwnConfigEntryBase
	{
		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		public object LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
	[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)]
	internal class SyncedConfigEntry<[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)] T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
			base..ctor();
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)]
	[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(2)]
	internal abstract class CustomSyncedValueBase
	{
		public object LocalBaseValue;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(1)]
		public readonly string Identifier;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(1)]
		public readonly Type Type;

		private object boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action ValueChanged;

		[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
	[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)]
	internal sealed class CustomSyncedValue<[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)] T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)]
	[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
	[PublicAPI]
	internal class ConfigSync
	{
		[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)]
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
			public static ZRpc currentRpc;

			[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)]
		private class ParsedConfigs
		{
			[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<OwnConfigEntryBase, object> configValues = new Dictionary<OwnConfigEntryBase, object>();

			[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<CustomSyncedValueBase, object> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)]
		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)]
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

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

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix([<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(new byte[] { 2, 1, 1 })] ref Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend > 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZNetPeer peer;
				if (__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)]
		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
			public object value;
		}

		[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)]
		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)]
		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)]
		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		public string DisplayName;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		public string CurrentVersion;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		public string MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		private OwnConfigEntryBase lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(new byte[] { 1, 0, 1 })]
		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag.GetValueOrDefault();
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
				IL_0052:
				result = 0;
				goto IL_0053;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; } = false;


		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		[method: <6442f216-3769-4175-b302-89372a5a3593>NullableContext(2)]
		[field: <4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		public event Action<bool> SourceOfTruthChanged;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		[method: <6442f216-3769-4175-b302-89372a5a3593>NullableContext(2)]
		[field: <4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		private event Action lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)] T>(ConfigEntry<T> configEntry)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += [<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (object _, EventArgs _) =>
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)] T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += [<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (object _, EventArgs _) =>
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (CustomSyncedValueBase v) => v.Priority));
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(([<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(new byte[] { 0, 1 })] KeyValuePair<long, string> kv) =>
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out var value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, [<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (CustomSyncedValueBase c) => c.Identifier, [<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		[return: <4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		private static OwnConfigEntryBase configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		[return: <4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(new byte[] { 2, 1 })]
		public static SyncedConfigEntry<T> ConfigData<[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)] T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)] T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage([<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(new byte[] { 2, 1 })] IEnumerable<ConfigEntryBase> configs = null, [<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(new byte[] { 2, 1 })] IEnumerable<CustomSyncedValueBase> customValues = null, [<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(new byte[] { 2, 1 })] IEnumerable<PackageEntry> packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, [<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)] object value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[<6442f216-3769-4175-b302-89372a5a3593>NullableContext(1)]
	[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(0)]
	[PublicAPI]
	[HarmonyPatch]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		private string displayName;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		private string currentVersion;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		private string minimumRequiredVersion;

		public bool ModRequired = true;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		private string ReceivedCurrentVersion;

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		private string ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		[<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)]
		private ConfigSync ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error([<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(2)] ZRpc rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, [<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(new byte[] { 2, 1, 1 })] Action<ZRpc, ZPackage> original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			foreach (VersionCheck versionCheck in array2)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (ZRpc rpc, [<4b50466e-6b37-4c0d-8bb2-84f35d67efa3>Nullable(1)] ZPackage pkg) =>
				{
					CheckVersion(rpc, pkg, action);
				}));
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: 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_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy([<6442f216-3769-4175-b302-89372a5a3593>NullableContext(0)] (KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
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;
		}
	}
}