using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CloverAPI.Assets;
using CloverAPI.Classes;
using CloverAPI.Classes.Interfaces;
using CloverAPI.Content.Audio;
using CloverAPI.Content.Builders;
using CloverAPI.Content.Charms;
using CloverAPI.Content.Data;
using CloverAPI.Content.Settings;
using CloverAPI.Content.Strings;
using CloverAPI.Content.Textures;
using CloverAPI.Internal;
using CloverAPI.SaveData;
using CloverAPI.Utils;
using Cysharp.Threading.Tasks;
using Cysharp.Threading.Tasks.CompilerServices;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Panik;
using TMPro;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("CloverAPI")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+063ae6889603213608ea6b82b49f8f3dc7dac3f0")]
[assembly: AssemblyProduct("CloverAPI")]
[assembly: AssemblyTitle("CloverAPI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CloverAPI
{
	public static class Logging
	{
		public static ManualLogSource Logger => Plugin.Log;

		public static void Log(LogLevel level, object message)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Logger.Log(level, message);
		}

		public static void LogInfo(object message)
		{
			Logger.LogInfo(message);
		}

		public static void LogDebug(object message)
		{
			Logger.LogDebug(message);
		}

		public static void LogWarning(object message)
		{
			Logger.LogWarning(message);
		}

		public static void LogError(object message)
		{
			Logger.LogError(message);
		}

		public static void LogFatal(object message)
		{
			Logger.LogFatal(message);
		}
	}
	[BepInPlugin("ModdingAPIs.cloverpit.CloverAPI", "Clover API", "0.2.1")]
	[HarmonyPatch]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "ModdingAPIs.cloverpit.CloverAPI";

		public const string PluginName = "Clover API";

		public const string PluginVer = "0.2.1";

		internal const string MainContentFolder = "CloverAPI_Content";

		private const int FONT_SIZE = 16;

		internal static ManualLogSource Log;

		internal static readonly Harmony Harmony = new Harmony("ModdingAPIs.cloverpit.CloverAPI");

		internal static string PluginPath;

		internal static ConfigEntry<bool> EnableDebugKeys;

		internal static ConfigEntry<bool> UseFullQualityTextures;

		internal static ConfigEntry<string> OverrideOrdering;

		public static string DataPath { get; private set; }

		public static string ImagePath { get; private set; }

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			PluginPath = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			DataPath = Path.Combine(PluginPath, "CloverAPI_Content", "Data");
			ImagePath = Path.Combine(PluginPath, "CloverAPI_Content", "Images");
			MakeConfig();
			LoadAssets();
			GameUtils.OnGameReady += OnReady;
			PersistentDataManager.RegisterData("CharmMappings", CharmMappings.Instance);
			PersistentDataManager.RegisterData("CharmData", AllCharmData.Instance);
		}

		private void Update()
		{
			if (!EnableDebugKeys.Value)
			{
				return;
			}
			int num = 1;
			if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
			{
				num *= 10;
			}
			if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305))
			{
				num *= 100;
			}
			if (Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307))
			{
				num *= 1000;
			}
			if (Input.GetKeyDown((KeyCode)282))
			{
				GameplayData.CoinsAdd((BigInteger)num, false);
			}
			if (Input.GetKeyDown((KeyCode)283))
			{
				GameplayData.CloverTicketsAdd((long)num, false);
			}
			if (Input.GetKeyDown((KeyCode)284))
			{
				PowerupScript[] array = (from x in CharmManager.CustomCharms.Pick(4)
					select PowerupScript.GetPowerup_Quick(x.id)).ToArray();
				if (array.Length < 4)
				{
					array = array.Concat(Enumerable.Repeat<PowerupScript>(null, 4 - array.Length)).ToArray();
				}
				StoreCapsuleScript.Restock(false, true, array, false, false);
			}
		}

		private void OnReady()
		{
			LoadData();
		}

		private void OnEnable()
		{
			Harmony.PatchAll();
			Logging.LogInfo("Loaded Clover API!");
		}

		private void OnDisable()
		{
			Harmony.UnpatchSelf();
			Logging.LogInfo("Unloaded Clover API!");
		}

		private void MakeConfig()
		{
			EnableDebugKeys = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableDebugKeys", false, "If true, enables debug keybinds for testing purposes.");
			UseFullQualityTextures = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "UseFullQualityTextures", true, "If true, uses full quality textures for modded content. If false, resizes them to match the size of the original texture. Some textures require a restart to take effect.");
			ModSettingsManager.RegisterPageFromConfig((BaseUnityPlugin)(object)this, "Clover API Settings");
			OverrideOrdering = ((BaseUnityPlugin)this).Config.Bind<string>("General", "OverrideOrdering", "", "A comma-separated list of mod GUIDs that specifies the order in which overrides are applied. The leftmost mod in the list has the highest priority. Mods that have conflicting overrides will automatically be added to the end.");
			ResourceOrdering._ConfigRef(OverrideOrdering);
		}

		private void LoadAssets()
		{
			string text = Path.Combine(PluginPath, DataPath, "templatemodel");
			if (File.Exists(text))
			{
				APIAssets._assetBundle = AssetBundle.LoadFromFile(text);
				return;
			}
			Logging.LogError("AssetBundle not found at " + text + "!");
			Logging.LogError("Make sure you have the '" + DataPath + "' folder in the same directory as the plugin DLL with the 'templatemodel' AssetBundle inside it.");
		}

		private void LoadData()
		{
			LoadTranslations();
		}

		private void LoadTranslations()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			string[] files = Directory.GetFiles(PluginPath, "*.loc", SearchOption.AllDirectories);
			string[] array = files;
			for (int i = 0; i < array.Length; i++)
			{
				LanguageManager.LoadFromFile(array[i]);
			}
			if (files.Length != 0)
			{
				Logging.LogInfo($"Loaded {files.Length} translation files.");
			}
		}
	}
}
namespace CloverAPI.Utils
{
	public static class AssetBundleUtils
	{
		private static readonly Dictionary<string, AssetBundle> LoadedAssetBundles = new Dictionary<string, AssetBundle>();

		public static GameObject InstantiateCustomModelCharm(string assetBundleName, string prefabName = null)
		{
			return Object.Instantiate<GameObject>(AssetBundleUtils.LoadFromAssetBundle<GameObject>(assetBundleName, prefabName));
		}

		public static T LoadFromAssetBundle<T>(string assetBundleName, string assetName = null) where T : Object
		{
			string text = FileUtils.FindFile(assetBundleName);
			AssetBundle val = LoadAssetBundle(text);
			if ((Object)(object)val == (Object)null)
			{
				Logging.LogError("Could not load AssetBundle from path: " + text);
				return default(T);
			}
			if (string.IsNullOrEmpty(assetName))
			{
				T[] array = val.LoadAllAssets<T>();
				if (array.Length != 0)
				{
					if (array.Length > 1)
					{
						Logging.LogWarning($"Multiple assets of type {typeof(T)} found in AssetBundle '{assetBundleName}'. Using the first one found: '{((Object)array[0]).name}'.");
					}
					return array[0];
				}
				Logging.LogError($"No assets of type {typeof(T)} found in AssetBundle '{assetBundleName}'.");
				PrintContentsOfAssetBundle(val);
				return default(T);
			}
			T val2 = val.LoadAsset<T>(assetName);
			if ((Object)(object)val2 == (Object)null)
			{
				Logging.LogError($"Could not find asset '{assetName}' of type {typeof(T)} in AssetBundle '{assetBundleName}'.");
				PrintContentsOfAssetBundle(val);
				return default(T);
			}
			return val2;
		}

		public static AssetBundle LoadAssetBundle(string path)
		{
			if (LoadedAssetBundles.TryGetValueNoCase(path, out var value))
			{
				return value;
			}
			AssetBundle val = AssetBundle.LoadFromFile(path);
			if ((Object)(object)val == (Object)null)
			{
				Logging.LogError("Failed to load AssetBundle from path: " + path);
				return null;
			}
			LoadedAssetBundles[path] = val;
			return val;
		}

		public static void PrintContentsOfAssetBundle(AssetBundle assetBundle)
		{
			string[] allAssetNames = assetBundle.GetAllAssetNames();
			Logging.LogInfo("AssetBundle contains the following assets:");
			string[] array = allAssetNames;
			foreach (string text in array)
			{
				Logging.LogInfo("- " + text);
			}
		}
	}
	public static class AudioUtils
	{
		public static AudioClip LoadAudioFromFile(string filePath, string onNotFound = "error", string onMultipleFound = "warn")
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			string text = FileUtils.FindFile(filePath, onNotFound, onMultipleFound);
			if (!File.Exists(text))
			{
				throw new FileNotFoundException("File '" + filePath + "' not found.");
			}
			UnityWebRequest audioClip = UnityWebRequestMultimedia.GetAudioClip("file://" + text, (AudioType)0);
			audioClip.SendWebRequest();
			while (!audioClip.isDone)
			{
			}
			if ((int)audioClip.result == 1)
			{
				AudioClip content = DownloadHandlerAudioClip.GetContent(audioClip);
				audioClip.Dispose();
				return content;
			}
			Logging.LogError("Failed to load audio clip from file '" + filePath + "': " + audioClip.error);
			audioClip.Dispose();
			return null;
		}
	}
	public class FileUtils
	{
		public static string[] FindFiles(string fileName)
		{
			if (Path.IsPathRooted(fileName))
			{
				if (File.Exists(fileName))
				{
					return new string[1] { fileName };
				}
				return Array.Empty<string>();
			}
			return Directory.GetFiles(Paths.PluginPath, fileName, SearchOption.AllDirectories);
		}

		public static string FindFile(string fileName, string onNotFound = "error", string onMultipleFound = "warn")
		{
			string[] array = FindFiles(fileName);
			if (array.Length < 1)
			{
				if (onNotFound == "error")
				{
					throw new FileNotFoundException("File '" + fileName + "' not found in plugin directory.");
				}
				if (onNotFound == "warn")
				{
					Logging.LogWarning("File '" + fileName + "' not found in plugin directory.");
				}
				return null;
			}
			if (array.Length > 1)
			{
				if (onMultipleFound == "error")
				{
					throw new Exception("Multiple files named '" + fileName + "' found in plugin directory.");
				}
				if (onMultipleFound == "warn")
				{
					Logging.LogWarning("Multiple files named '" + fileName + "' found. Using the first one found at '" + array[0] + "'.");
				}
			}
			return array[0];
		}

		public static byte[] LoadFileBytes(string filePath, string onNotFound = "error", string onMultipleFound = "warn")
		{
			string path = FindFile(filePath, onNotFound, onMultipleFound);
			if (!File.Exists(path))
			{
				throw new FileNotFoundException("File '" + filePath + "' not found.");
			}
			return File.ReadAllBytes(path);
		}
	}
	public class GameUtils
	{
		public static bool GameReady { get; internal set; } = false;


		public static event Action OnGameReady;

		internal static void TriggerGameReady()
		{
			GameReady = true;
			GameUtils.OnGameReady();
		}

		static GameUtils()
		{
			GameUtils.OnGameReady = delegate
			{
			};
		}
	}
	public static class LinqExtensions
	{
		public static T MaxBy<T, TKey>(this IEnumerable<T> source, Func<T, TKey> selector) where TKey : IComparable<TKey>
		{
			using IEnumerator<T> enumerator = source.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				throw new InvalidOperationException("Sequence contains no elements");
			}
			T val = enumerator.Current;
			TKey other = selector(val);
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				TKey val2 = selector(current);
				if (val2.CompareTo(other) > 0)
				{
					val = current;
					other = val2;
				}
			}
			return val;
		}

		public static bool TryGetValueNoCase<TValue>(this IDictionary<string, TValue> dictionary, string key, out TValue value)
		{
			foreach (KeyValuePair<string, TValue> item in dictionary)
			{
				if (string.Equals(item.Key, key, StringComparison.OrdinalIgnoreCase))
				{
					value = item.Value;
					return true;
				}
			}
			value = default(TValue);
			return false;
		}
	}
	public class MathUtils
	{
		public static float RoundToMultipleOf(float value, float multiple)
		{
			if (multiple == 0f)
			{
				throw new ArgumentException("Multiple cannot be zero.", "multiple");
			}
			return (float)(Math.Round(value / multiple) * (double)multiple);
		}

		public static float RoundToNearestSignificantFive(float value, int unroundedSignificantDigits = 1)
		{
			if (value == 0f)
			{
				return 0f;
			}
			float num = (float)Math.Pow(10.0, Math.Floor(Math.Log10(Math.Abs(value))) + 1.0 - (double)unroundedSignificantDigits);
			return RoundToMultipleOf(value, 0.5f * num);
		}

		public static float RoundToNearestSignificant(float value, int significantDigits = 1)
		{
			if (value == 0f)
			{
				return 0f;
			}
			float num = (float)Math.Pow(10.0, Math.Floor(Math.Log10(Math.Abs(value))) + 1.0 - (double)significantDigits);
			return (float)(Math.Round(value / num) * (double)num);
		}
	}
	public static class RandomUtils
	{
		public static IList<T> Pick<T>(this IList<T> list, int count)
		{
			if (count == 1)
			{
				return new List<T> { list.Pick() };
			}
			if (list == null)
			{
				throw new ArgumentNullException("list", "The list cannot be null.");
			}
			if (list.Count == 0)
			{
				throw new ArgumentException("The list cannot be empty.", "list");
			}
			if (count > list.Count)
			{
				count = list.Count;
			}
			HashSet<int> hashSet = new HashSet<int>();
			while (hashSet.Count < count)
			{
				int item = Random.Range(0, list.Count);
				hashSet.Add(item);
			}
			List<T> list2 = new List<T>();
			foreach (int item2 in hashSet)
			{
				list2.Add(list[item2]);
			}
			return list2;
		}

		public static T Pick<T>(this IList<T> list)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list", "The list cannot be null.");
			}
			if (list.Count == 0)
			{
				throw new ArgumentException("The list cannot be empty.", "list");
			}
			int index = Random.Range(0, list.Count);
			return list[index];
		}
	}
	public static class TextureUtils
	{
		public static Texture2D LoadTextureFromFile(string filePath, FilterMode filterMode = 0, string onNotFound = "error", string onMultipleFound = "warn")
		{
			//IL_0004: 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_0019: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			byte[] array = FileUtils.LoadFileBytes(filePath, onNotFound, onMultipleFound);
			if (!ImageConversion.LoadImage(val, array))
			{
				throw new Exception("Failed to load texture from file '" + filePath + "'. The file may not be a valid image.");
			}
			((Texture)val).filterMode = filterMode;
			((Object)val).name = Path.GetFileNameWithoutExtension(filePath);
			return val;
		}

		public static Texture2D ResizeTexture(Texture2D original, int width, int height)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			RenderTexture val = (RenderTexture.active = RenderTexture.GetTemporary(width, height));
			Graphics.Blit((Texture)(object)original, val);
			Texture2D val2 = new Texture2D(width, height);
			val2.ReadPixels(new Rect(0f, 0f, (float)width, (float)height), 0, 0);
			val2.Apply();
			RenderTexture.active = null;
			RenderTexture.ReleaseTemporary(val);
			return val2;
		}

		public static Texture2D CopyTexture(Texture2D original)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(((Texture)original).width, ((Texture)original).height, original.format, ((Texture)original).mipmapCount > 1);
			if (((Texture)original).isReadable)
			{
				val.SetPixels(original.GetPixels());
				val.Apply();
				return val;
			}
			RenderTexture val2 = (RenderTexture.active = RenderTexture.GetTemporary(((Texture)original).width, ((Texture)original).height));
			Graphics.Blit((Texture)(object)original, val2);
			val.ReadPixels(new Rect(0f, 0f, (float)((Texture)original).width, (float)((Texture)original).height), 0, 0);
			val.Apply();
			RenderTexture.active = null;
			RenderTexture.ReleaseTemporary(val2);
			return val;
		}
	}
}
namespace CloverAPI.SaveData
{
	public class AllCharmData : JsonPersistentData
	{
		public static AllCharmData Instance = new AllCharmData();

		[JsonProperty]
		internal Dictionary<string, CharmData> Entries = new Dictionary<string, CharmData>();

		public CharmData this[string guid]
		{
			get
			{
				return GetCharmDataByGUID(guid);
			}
			set
			{
				SetCharmDataByGuid(guid, value);
			}
		}

		public CharmData this[Identifier id]
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return GetCharmDataByID(id);
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				SetCharmDataById(id, value);
			}
		}

		public CharmData GetCharmDataByGUID(string guid)
		{
			if (!Entries.TryGetValueNoCase(guid, out var value))
			{
				value = new CharmData();
				Entries[guid] = value;
			}
			return value;
		}

		public CharmData GetCharmDataByID(Identifier id)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (CharmManager.IdToGUID.TryGetValue(id, out var value))
			{
				return GetCharmDataByGUID(value);
			}
			return null;
		}

		public bool HasCharmDataByGuid(string guid)
		{
			return Entries.ContainsKey(guid);
		}

		public bool HasCharmDataById(Identifier id)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (CharmManager.IdToGUID.TryGetValue(id, out var value))
			{
				return HasCharmDataByGuid(value);
			}
			return false;
		}

		public void RemoveCharmDataByGuid(string guid)
		{
			Entries.Remove(guid);
		}

		public void RemoveCharmDataById(Identifier id)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (CharmManager.IdToGUID.TryGetValue(id, out var value))
			{
				RemoveCharmDataByGuid(value);
			}
		}

		public void SetCharmDataByGuid(string guid, CharmData data)
		{
			Entries[guid] = data;
		}

		public void SetCharmDataById(Identifier id, CharmData data)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (CharmManager.IdToGUID.TryGetValue(id, out var value))
			{
				SetCharmDataByGuid(value, data);
			}
		}

		public override void OnReset()
		{
			Entries.Clear();
		}
	}
	public class CharmData
	{
		[JsonProperty]
		internal Dictionary<string, object> Data = new Dictionary<string, object>();

		public T Get<T>(string key, T defaultValue = default(T))
		{
			if (Data.TryGetValueNoCase(key, out var value))
			{
				if (value is T)
				{
					return (T)value;
				}
				T val = JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(value));
				if (val != null)
				{
					return val;
				}
				return defaultValue;
			}
			return defaultValue;
		}

		public string GetString(string key, string defaultValue = null)
		{
			return Get(key, defaultValue);
		}

		public int GetInt(string key, int defaultValue = 0)
		{
			return Get(key, defaultValue);
		}

		public float GetFloat(string key, float defaultValue = 0f)
		{
			return Get(key, defaultValue);
		}

		public bool GetBool(string key, bool defaultValue = false)
		{
			return Get(key, defaultValue);
		}

		public BigInteger GetBigInteger(string key, BigInteger defaultValue = default(BigInteger))
		{
			return Get(key, defaultValue);
		}

		public List<T> GetList<T>(string key, List<T> defaultValue = null)
		{
			return Get(key, defaultValue ?? new List<T>());
		}

		public T[] GetArray<T>(string key, T[] defaultValue = null)
		{
			return Get(key, defaultValue ?? Array.Empty<T>());
		}

		public Dictionary<TKey, TValue> GetDictionary<TKey, TValue>(string key, Dictionary<TKey, TValue> defaultValue = null)
		{
			return Get(key, defaultValue ?? new Dictionary<TKey, TValue>());
		}

		public void Set<T>(string key, T value)
		{
			Data[key] = value;
		}

		public void Remove(string key)
		{
			Data.Remove(key);
		}

		public bool ContainsKey(string key)
		{
			return Data.ContainsKey(key);
		}
	}
}
namespace CloverAPI.Patches
{
	[HarmonyPatch]
	public class AudioPatcher
	{
		[HarmonyPatch(typeof(AssetMaster), "GetSound")]
		[HarmonyPrefix]
		internal static bool AssetMaster_GetSound_Prefix(ref AudioClip __result, ref string clipName)
		{
			if (AudioManager.TryGetSoundOverride(clipName, out var audioClip))
			{
				__result = audioClip;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(AssetMaster), "GetMusic")]
		[HarmonyPrefix]
		internal static bool AssetMaster_GetMusic_Prefix(ref AudioClip __result, ref string clipName)
		{
			if (AudioManager.TryGetMusicOverride(clipName, out var audioClip))
			{
				__result = audioClip;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal class CharmPatcher
	{
		[CompilerGenerated]
		private sealed class <PowerupScript_InitializeAll_Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<CodeInstruction> instructions;

			public IEnumerable<CodeInstruction> <>3__instructions;

			private IEnumerator<CodeInstruction> <enumerator>5__2;

			private bool <done>5__3;

			private CodeInstruction <instruction>5__4;

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

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

			[DebuggerHidden]
			public <PowerupScript_InitializeAll_Transpiler>d__0(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<enumerator>5__2 = null;
				<instruction>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Expected O, but got Unknown
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<enumerator>5__2 = instructions.GetEnumerator();
					<done>5__3 = false;
					goto IL_00b9;
				case 1:
					<>1__state = -1;
					if (!(<instruction>5__4.opcode == OpCodes.Ldc_I4) || !(<instruction>5__4.operand is int num) || num != 163)
					{
						<instruction>5__4 = null;
						goto IL_00b9;
					}
					goto IL_01ab;
				case 2:
					<>1__state = -1;
					if (<instruction>5__4.opcode == OpCodes.Callvirt && <instruction>5__4.operand is MethodInfo methodInfo && methodInfo == AccessTools.Method(typeof(PowerupScript), "Initialize", (Type[])null, (Type[])null))
					{
						<>2__current = new CodeInstruction(OpCodes.Ldarg_1, (object)null);
						<>1__state = 3;
						return true;
					}
					<instruction>5__4 = null;
					goto IL_01ab;
				case 3:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CharmPatcher), "InitCustomCharms", (Type[])null, (Type[])null));
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<done>5__3 = true;
					break;
				case 5:
					{
						<>1__state = -1;
						break;
					}
					IL_00b9:
					if (<enumerator>5__2.MoveNext())
					{
						<instruction>5__4 = <enumerator>5__2.Current;
						<>2__current = <instruction>5__4;
						<>1__state = 1;
						return true;
					}
					goto IL_01ab;
					IL_01ab:
					if (<enumerator>5__2.MoveNext())
					{
						<instruction>5__4 = <enumerator>5__2.Current;
						<>2__current = <instruction>5__4;
						<>1__state = 2;
						return true;
					}
					break;
				}
				if (<enumerator>5__2.MoveNext())
				{
					<>2__current = <enumerator>5__2.Current;
					<>1__state = 5;
					return true;
				}
				if (!<done>5__3)
				{
					Logging.LogError("Failed to apply PowerupScript.InitializeAll transpiler patch!");
				}
				<enumerator>5__2.Dispose();
				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();
			}

			[DebuggerHidden]
			IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
			{
				<PowerupScript_InitializeAll_Transpiler>d__0 <PowerupScript_InitializeAll_Transpiler>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<PowerupScript_InitializeAll_Transpiler>d__ = this;
				}
				else
				{
					<PowerupScript_InitializeAll_Transpiler>d__ = new <PowerupScript_InitializeAll_Transpiler>d__0(0);
				}
				<PowerupScript_InitializeAll_Transpiler>d__.instructions = <>3__instructions;
				return <PowerupScript_InitializeAll_Transpiler>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <ReplaceILCharmCounts>d__3 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			private int replaceAmount;

			public int <>3__replaceAmount;

			private int expectedAmountSeen;

			public int <>3__expectedAmountSeen;

			private string caller;

			public string <>3__caller;

			private IEnumerable<CodeInstruction> instructions;

			public IEnumerable<CodeInstruction> <>3__instructions;

			private string onNotFound;

			public string <>3__onNotFound;

			private string onMultipleFound;

			public string <>3__onMultipleFound;

			private int <seen>5__2;

			private IEnumerator<CodeInstruction> <>7__wrap2;

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

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

			[DebuggerHidden]
			public <ReplaceILCharmCounts>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 2u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (replaceAmount < 1 || expectedAmountSeen < 1)
						{
							Logging.LogError("Invalid arguments to ReplaceILCharmCounts in '" + caller + "'. Both replaceAmount and expectedAmountSeen must be at least 1.");
							replaceAmount = Mathf.Max(1, replaceAmount);
							expectedAmountSeen = Mathf.Max(1, expectedAmountSeen);
						}
						<seen>5__2 = 0;
						<>7__wrap2 = instructions.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						goto IL_014c;
					case 2:
						<>1__state = -3;
						goto IL_014c;
					case 3:
						{
							<>1__state = -3;
							break;
						}
						IL_014c:
						<seen>5__2++;
						break;
					}
					if (<>7__wrap2.MoveNext())
					{
						CodeInstruction current = <>7__wrap2.Current;
						if (current.opcode == OpCodes.Ldc_I4 && current.operand is int num && num == 164)
						{
							if (<seen>5__2 < replaceAmount)
							{
								<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(CharmManager), "NewCount"));
								<>1__state = 1;
								return true;
							}
							<>2__current = current;
							<>1__state = 2;
							return true;
						}
						<>2__current = current;
						<>1__state = 3;
						return true;
					}
					<>m__Finally1();
					<>7__wrap2 = null;
					if (<seen>5__2 < expectedAmountSeen)
					{
						if (expectedAmountSeen == 1)
						{
							if (onNotFound == "error")
							{
								Logging.LogError($"Transpiler patch in '{caller}' failed to replace any instances of 'ldc.i4 {164}'!");
							}
							else if (onNotFound == "warn")
							{
								Logging.LogWarning($"Transpiler patch in '{caller}' failed to replace any instances of 'ldc.i4 {164}'!");
							}
						}
						else if (onNotFound == "error")
						{
							Logging.LogError($"Transpiler patch in '{caller}' replaced only {<seen>5__2} instances of 'ldc.i4 {164}'. Expected to replace exactly {expectedAmountSeen} instances, but could be fine if an update changed this.");
						}
						else if (onNotFound == "warn")
						{
							Logging.LogWarning($"Transpiler patch in '{caller}' replaced only {<seen>5__2} instances of 'ldc.i4 {164}'. Expected to replace exactly {expectedAmountSeen} instances, but could be fine if an update changed this.");
						}
					}
					if (<seen>5__2 > expectedAmountSeen)
					{
						if (onMultipleFound == "error")
						{
							Logging.LogError(string.Format("Transpiler patch in '{0}' replaced {1} instances of 'ldc.i4 {2}'. Expected to replace exactly {3} instance{4}!", caller, <seen>5__2, 164, expectedAmountSeen, (expectedAmountSeen == 1) ? "" : "s"));
						}
						else if (onMultipleFound == "warn")
						{
							Logging.LogWarning(string.Format("Transpiler patch in '{0}' replaced {1} instances of 'ldc.i4 {2}'. Expected to replace exactly {3} instance{4}!", caller, <seen>5__2, 164, expectedAmountSeen, (expectedAmountSeen == 1) ? "" : "s"));
						}
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap2 != null)
				{
					<>7__wrap2.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
			{
				<ReplaceILCharmCounts>d__3 <ReplaceILCharmCounts>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<ReplaceILCharmCounts>d__ = this;
				}
				else
				{
					<ReplaceILCharmCounts>d__ = new <ReplaceILCharmCounts>d__3(0);
				}
				<ReplaceILCharmCounts>d__.instructions = <>3__instructions;
				<ReplaceILCharmCounts>d__.onNotFound = <>3__onNotFound;
				<ReplaceILCharmCounts>d__.onMultipleFound = <>3__onMultipleFound;
				<ReplaceILCharmCounts>d__.replaceAmount = <>3__replaceAmount;
				<ReplaceILCharmCounts>d__.expectedAmountSeen = <>3__expectedAmountSeen;
				<ReplaceILCharmCounts>d__.caller = <>3__caller;
				return <ReplaceILCharmCounts>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
			}
		}

		[IteratorStateMachine(typeof(<PowerupScript_InitializeAll_Transpiler>d__0))]
		[HarmonyPatch(typeof(PowerupScript), "InitializeAll")]
		[HarmonyTranspiler]
		internal static IEnumerable<CodeInstruction> PowerupScript_InitializeAll_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PowerupScript_InitializeAll_Transpiler>d__0(-2)
			{
				<>3__instructions = instructions
			};
		}

		[HarmonyPatch(typeof(GameplayData), "_EnsurePowerupDataArray")]
		[HarmonyTranspiler]
		internal static IEnumerable<CodeInstruction> GameplayData__EnsurePowerupDataArray_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return ReplaceILCharmCounts(instructions, "error", "warn", 1, 1, "GameplayData._EnsurePowerupDataArray");
		}

		[HarmonyPatch(typeof(TerminalScript), "Initialize")]
		[HarmonyTranspiler]
		internal static IEnumerable<CodeInstruction> TerminalScript_Initialize_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return ReplaceILCharmCounts(instructions, "error", "warn", 1, 2, "TerminalScript.Initialize");
		}

		[IteratorStateMachine(typeof(<ReplaceILCharmCounts>d__3))]
		private static IEnumerable<CodeInstruction> ReplaceILCharmCounts(IEnumerable<CodeInstruction> instructions, string onNotFound = "error", string onMultipleFound = "warn", int replaceAmount = 1, int expectedAmountSeen = 1, string caller = "unknown")
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ReplaceILCharmCounts>d__3(-2)
			{
				<>3__instructions = instructions,
				<>3__onNotFound = onNotFound,
				<>3__onMultipleFound = onMultipleFound,
				<>3__replaceAmount = replaceAmount,
				<>3__expectedAmountSeen = expectedAmountSeen,
				<>3__caller = caller
			};
		}

		private static void InitCustomCharms(bool isNewGame)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			foreach (CharmBuilder customCharm in CharmManager.CustomCharms)
			{
				CharmManager.SpawnCustomCharm(customCharm.id, isNewGame);
			}
		}
	}
	[HarmonyPatch]
	public class GamePatcher
	{
		[HarmonyPatch(typeof(IntroScript), "Start")]
		[HarmonyPrefix]
		internal static void IntroScript_Start_Prefix()
		{
			GameUtils.TriggerGameReady();
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		internal static bool Master__PlatformKind_Get_Prefix(ref PlatformKind __result)
		{
			__result = (PlatformKind)0;
			return false;
		}
	}
	[HarmonyPatch]
	internal class SavePatcher
	{
		[HarmonyPatch(typeof(Data), "SaveGame")]
		[HarmonyPrefix]
		internal static void Data_SaveGame_Postfix()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			UniTaskExtensions.Forget<bool>(PersistentDataManager.SaveData());
		}

		[HarmonyPatch(typeof(Data), "LoadGame")]
		[HarmonyPostfix]
		internal static void Data_LoadGame_Postfix()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			UniTaskExtensions.Forget<bool>(PersistentDataManager.LoadData());
		}

		[HarmonyPatch(typeof(GameData), "GameplayDataReset")]
		[HarmonyPostfix]
		internal static void Data_GameData_GameplayDataReset_Postfix(GameData __instance)
		{
			PersistentDataManager.ResetAll();
		}

		[HarmonyPatch(typeof(PlatformDataMaster), "PathGet_GameDataFile")]
		[HarmonyPostfix]
		internal static void PlatformDataMaster_PathGet_GameDataFile_Postfix(ref string __result, string extraAppendix)
		{
			string text = PlatformDataMaster.GameFolderPath + "GameDataModded" + extraAppendix + ".json";
			if (!File.Exists(text) && File.Exists(__result))
			{
				File.Copy(__result, text);
			}
			__result = text;
		}
	}
	internal static class HubState
	{
		public enum View
		{
			None,
			HubIndex,
			Page
		}

		public static View Current = View.None;

		public static int HubPageOffset = 0;

		public static int PageItemOffset = 0;

		public static int ActivePage = -1;

		public static void Reset()
		{
			Current = View.None;
			HubPageOffset = 0;
			PageItemOffset = 0;
			ActivePage = -1;
		}
	}
	[HarmonyPatch]
	internal static class MainMenu_Patches
	{
		private readonly struct HubLayout
		{
			public int Capacity { get; }

			public int ListSlots { get; }

			public int NextRow { get; }

			public int BackRow { get; }

			public int Step { get; }

			public HubLayout(int capacity)
			{
				Capacity = capacity;
				BackRow = capacity - 1;
				NextRow = ((capacity >= 2) ? (capacity - 2) : (-1));
				ListSlots = Mathf.Max(0, capacity - 2);
				Step = Math.Max(1, ListSlots);
			}
		}

		private const int ModsSlotWithoutTwitch = 4;

		private const int ModsSlotWithTwitch = 5;

		private static bool _rowValidationLogged;

		private static readonly FieldInfo DesiredNavigationIndexField = AccessTools.Field(typeof(MainMenuScript), "desiredNavigationIndex");

		private static readonly FieldInfo ControllerElementsField = AccessTools.Field(typeof(DiegeticMenuController), "elements");

		private static readonly FieldInfo RightNavigationPressField = AccessTools.Field(typeof(MainMenuScript), "rightNavigationPress");

		private static readonly FieldInfo LeftNavigationPressField = AccessTools.Field(typeof(MainMenuScript), "leftNavigationPress");

		private static readonly FieldInfo MenuIndexField = AccessTools.Field(typeof(MainMenuScript), "menuIndex");

		private static bool IsInHub()
		{
			return HubState.Current != HubState.View.None;
		}

		private static bool HasPages()
		{
			return ModSettingsManager.Pages.Count > 0;
		}

		private static int GetModsSlotIndex()
		{
			if (!TwitchMaster.IsTwitchSupported())
			{
				return 4;
			}
			return 5;
		}

		private static int GetBackSlotIndex()
		{
			return GetModsSlotIndex() + 1;
		}

		private static void SetDesiredNavigationIndex(MainMenuScript menu, int value)
		{
			DesiredNavigationIndexField?.SetValue(menu, value);
		}

		private static MenuIndex GetMenuIndex(MainMenuScript menu)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (MenuIndexField == null)
			{
				return (MenuIndex)(-1);
			}
			object value = MenuIndexField.GetValue(menu);
			if (value is MenuIndex)
			{
				return (MenuIndex)value;
			}
			return (MenuIndex)(-1);
		}

		private static void SetMenuIndex(MainMenuScript menu, MenuIndex value)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			MenuIndexField?.SetValue(menu, value);
		}

		private static List<DiegeticMenuElement>? GetElementsList(DiegeticMenuController? controller)
		{
			if ((Object)(object)controller == (Object)null || ControllerElementsField == null)
			{
				return null;
			}
			return ControllerElementsField.GetValue(controller) as List<DiegeticMenuElement>;
		}

		private static bool GetFlag(FieldInfo field, MainMenuScript menu)
		{
			bool flag = default(bool);
			int num;
			if (field != null && (Object)(object)menu != (Object)null)
			{
				object value = field.GetValue(menu);
				if (value is bool)
				{
					flag = (bool)value;
					num = 1;
				}
				else
				{
					num = 0;
				}
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}

		private static void SetTextSafe(TextMeshProUGUI[] texts, int index, string? value)
		{
			if (texts != null && index >= 0 && index < texts.Length && (Object)(object)texts[index] != (Object)null)
			{
				((TMP_Text)texts[index]).text = value ?? string.Empty;
			}
		}

		private static DiegeticMenuElement? GetMenuElement(MainMenuScript? menu, int index)
		{
			if (menu?.menuElements == null || index < 0 || index >= menu.menuElements.Length)
			{
				return null;
			}
			return menu.menuElements[index];
		}

		private static bool TryGetOptionTexts(MainMenuScript menu, out TextMeshProUGUI[] optionTexts)
		{
			if (menu?.optionTexts == null || menu.optionTexts.Length == 0)
			{
				optionTexts = Array.Empty<TextMeshProUGUI>();
				return false;
			}
			optionTexts = menu.optionTexts;
			return true;
		}

		private static bool TryGetHubLayout(MainMenuScript menu, out HubLayout layout)
		{
			layout = default(HubLayout);
			if ((Object)(object)menu == (Object)null)
			{
				return false;
			}
			int num = VisibleCapacity(menu);
			if (num <= 0)
			{
				return false;
			}
			layout = new HubLayout(num);
			return true;
		}

		private static bool TryGetActivePage(out ModSettingsManager.Page page)
		{
			int activePage = HubState.ActivePage;
			if (activePage >= 0 && activePage < ModSettingsManager.Pages.Count)
			{
				page = ModSettingsManager.Pages[activePage];
				return true;
			}
			page = null;
			return false;
		}

		private static void RenderListEntries(TextMeshProUGUI[] optionTexts, int listSlots, int start, int total, Func<int, string> labelSelector)
		{
			int i = 0;
			int num = start;
			while (num < total && i < listSlots)
			{
				SetTextSafe(optionTexts, i, labelSelector(num));
				num++;
				i++;
			}
			for (; i < listSlots; i++)
			{
				SetTextSafe(optionTexts, i, string.Empty);
			}
		}

		private static void RenderPaginationFooter(TextMeshProUGUI[] optionTexts, HubLayout layout, int renderedEnd, int total)
		{
			if (layout.NextRow >= 0)
			{
				SetTextSafe(optionTexts, layout.NextRow, (renderedEnd < total) ? "NEXT" : string.Empty);
			}
			SetTextSafe(optionTexts, layout.BackRow, "BACK");
		}

		private static int ClampPageOffset(int requested, int total)
		{
			if (total <= 0)
			{
				return 0;
			}
			int num = Math.Max(0, total - 1);
			return Mathf.Clamp(requested, 0, num);
		}

		private static int GetDesiredNavigationIndex(MainMenuScript menu)
		{
			if (DesiredNavigationIndexField == null)
			{
				return -1;
			}
			object value = DesiredNavigationIndexField.GetValue(menu);
			if (value is int)
			{
				return (int)value;
			}
			return -1;
		}

		private static void EnsureSlotState(MainMenuScript menu, int index, bool enabled)
		{
			if ((Object)(object)menu?.menuController == (Object)null)
			{
				return;
			}
			DiegeticMenuElement menuElement = GetMenuElement(menu, index);
			if ((Object)(object)menuElement == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)menuElement).transform;
			object obj;
			if (transform == null)
			{
				obj = null;
			}
			else
			{
				Transform parent = transform.parent;
				obj = ((parent != null) ? ((Component)parent).gameObject : null);
			}
			if (obj != null)
			{
				((GameObject)obj).SetActive(enabled);
			}
			List<DiegeticMenuElement> elementsList = GetElementsList(menu.menuController);
			if (elementsList == null)
			{
				return;
			}
			if (enabled)
			{
				if (!elementsList.Contains(menuElement))
				{
					int index2 = Mathf.Clamp(index, 0, elementsList.Count);
					elementsList.Insert(index2, menuElement);
					menuElement.SetMyController(menu.menuController);
				}
				if (!VirtualCursors.IsCursorVisible(0, true) && GetDesiredNavigationIndex(menu) == index)
				{
					menu.menuController.HoveredElement = menuElement;
				}
			}
			else
			{
				elementsList.Remove(menuElement);
				if (menu.menuController.HoveredElement == menuElement)
				{
					menu.menuController.HoveredElement = null;
				}
			}
		}

		private static void EnsureSlotEnabled(MainMenuScript menu, int index)
		{
			EnsureSlotState(menu, index, enabled: true);
		}

		private static void EnsureSlotDisabled(MainMenuScript menu, int index)
		{
			EnsureSlotState(menu, index, enabled: false);
		}

		private static bool ValidateMenuRows(MainMenuScript menu, int requiredIndex)
		{
			if ((Object)(object)menu == (Object)null)
			{
				return false;
			}
			DiegeticMenuElement[] menuElements = menu.menuElements;
			int num = ((menuElements != null) ? menuElements.Length : 0);
			TextMeshProUGUI[] optionTexts = menu.optionTexts;
			int num2 = ((optionTexts != null) ? optionTexts.Length : 0);
			bool num3 = num > requiredIndex;
			bool flag = num2 > requiredIndex;
			if ((!num3 || !flag) && !_rowValidationLogged)
			{
				_rowValidationLogged = true;
				Logging.LogFatal($"ModSettingsExtender detected missing menu rows. Expected index {requiredIndex} but found menuElements={num}, optionTexts={num2}. The base menu prefab likely changed; mods menu injection is disabled.");
			}
			return num3 && flag;
		}

		private static int VisibleCapacity(MainMenuScript menu)
		{
			return Mathf.Max(0, GetElementsList(menu?.menuController)?.Count ?? 0);
		}

		private static bool InputSuppressed(MainMenuScript menu)
		{
			bool num = Controls.MouseButton_PressedGet(0, (MouseElement)1);
			bool flag = GetFlag(RightNavigationPressField, menu);
			bool flag2 = GetFlag(LeftNavigationPressField, menu);
			return num || flag || flag2;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MainMenuScript), "OptionsUpdateText_Desktop")]
		private static void OptionsUpdateText_Desktop_Postfix(MainMenuScript __instance)
		{
			AfterOptionsUpdateText(__instance);
		}

		private static void AfterOptionsUpdateText(MainMenuScript menu)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			if ((Object)(object)menu == (Object)null)
			{
				return;
			}
			try
			{
				if ((int)GetMenuIndex(menu) == 1)
				{
					EnsureModsRow(menu);
				}
				else
				{
					DisableExtraRow(menu);
				}
				if (IsInHub())
				{
					RenderHub(menu);
				}
				else if (HubState.Current != 0 && !HasPages())
				{
					HubState.Reset();
				}
			}
			catch (Exception arg)
			{
				Logging.LogError($"OptionsUpdate postfix failed: {arg}");
			}
		}

		private static void DisableExtraRow(MainMenuScript menu)
		{
			if (!((Object)(object)menu == (Object)null))
			{
				int backSlotIndex = GetBackSlotIndex();
				if (ValidateMenuRows(menu, backSlotIndex))
				{
					SetTextSafe(menu.optionTexts, backSlotIndex, string.Empty);
					EnsureSlotDisabled(menu, backSlotIndex);
				}
			}
		}

		private static void EnsureModsRow(MainMenuScript menu)
		{
			TextMeshProUGUI[] optionTexts = menu.optionTexts;
			if (optionTexts == null)
			{
				return;
			}
			int modsSlotIndex = GetModsSlotIndex();
			int backSlotIndex = GetBackSlotIndex();
			bool flag = HasPages();
			if (!ValidateMenuRows(menu, Math.Max(modsSlotIndex, backSlotIndex)))
			{
				return;
			}
			if (!flag)
			{
				SetTextSafe(optionTexts, modsSlotIndex, Translation.Get("MENU_OPTION_BACK"));
				SetTextSafe(optionTexts, backSlotIndex, string.Empty);
				EnsureSlotDisabled(menu, backSlotIndex);
			}
			else if (modsSlotIndex < optionTexts.Length && backSlotIndex < optionTexts.Length)
			{
				TextMeshProUGUI obj = optionTexts[modsSlotIndex];
				string value = ((obj != null) ? ((TMP_Text)obj).text : null) ?? Translation.Get("MENU_OPTION_BACK");
				if (string.IsNullOrEmpty(value))
				{
					value = Translation.Get("MENU_OPTION_BACK");
				}
				EnsureSlotEnabled(menu, modsSlotIndex);
				EnsureSlotEnabled(menu, backSlotIndex);
				SetTextSafe(optionTexts, backSlotIndex, value);
				SetTextSafe(optionTexts, modsSlotIndex, "MODS");
			}
		}

		private static void RenderHub(MainMenuScript menu)
		{
			if (TryGetOptionTexts(menu, out TextMeshProUGUI[] optionTexts) && TryGetHubLayout(menu, out var layout))
			{
				ModSettingsManager.Page page;
				if (HubState.Current == HubState.View.HubIndex)
				{
					RenderHubIndex(menu, optionTexts, layout);
				}
				else if (HubState.Current == HubState.View.Page && TryGetActivePage(out page))
				{
					RenderHubPage(menu, optionTexts, layout, page);
				}
			}
		}

		private static void RenderHubIndex(MainMenuScript menu, TextMeshProUGUI[] optionTexts, HubLayout layout)
		{
			if ((Object)(object)menu.titleText != (Object)null)
			{
				((TMP_Text)menu.titleText).text = "MOD SETTINGS";
			}
			int hubPageOffset = HubState.HubPageOffset;
			int count = ModSettingsManager.Pages.Count;
			int renderedEnd = Mathf.Min(hubPageOffset + layout.ListSlots, count);
			RenderListEntries(optionTexts, layout.ListSlots, hubPageOffset, count, (int index) => ModSettingsManager.GetDisplayTitle(ModSettingsManager.Pages[index]));
			RenderPaginationFooter(optionTexts, layout, renderedEnd, count);
		}

		private static void RenderHubPage(MainMenuScript menu, TextMeshProUGUI[] optionTexts, HubLayout layout, ModSettingsManager.Page page)
		{
			ModSettingsManager.Page page2 = page;
			if ((Object)(object)menu.titleText != (Object)null)
			{
				((TMP_Text)menu.titleText).text = ModSettingsManager.GetDisplayTitle(page2);
			}
			int pageItemOffset = HubState.PageItemOffset;
			int count = page2.Items.Count;
			int renderedEnd = Mathf.Min(pageItemOffset + layout.ListSlots, count);
			RenderListEntries(optionTexts, layout.ListSlots, pageItemOffset, count, (int index) => page2.Items[index].Label?.Invoke() ?? "(item)");
			RenderPaginationFooter(optionTexts, layout, renderedEnd, count);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MainMenuScript), "Select_Desktop")]
		private static bool Select_Desktop_Prefix(MainMenuScript __instance, MenuIndex _menuIndex, int selectionIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Invalid comparison between Unknown and I4
			if (IsInHub() && (int)_menuIndex == 0 && selectionIndex == 0)
			{
				if (HubState.Current == HubState.View.Page)
				{
					Sound.Play("SoundMenuBack", 1f, 1f);
					HubState.Current = HubState.View.HubIndex;
					HubState.PageItemOffset = 0;
				}
				else
				{
					Sound.Play("SoundMenuBack", 1f, 1f);
					HubState.Reset();
					SetDesiredNavigationIndex(__instance, GetModsSlotIndex());
				}
				__instance.OptionsUpdate();
				return false;
			}
			if (IsInHub())
			{
				HandleHubSelection(__instance, selectionIndex);
				__instance.OptionsUpdate();
				return false;
			}
			if ((int)_menuIndex == 1 && HasPages())
			{
				int modsSlotIndex = GetModsSlotIndex();
				int backSlotIndex = GetBackSlotIndex();
				bool flag = InputSuppressed(__instance);
				if (selectionIndex == modsSlotIndex && !flag)
				{
					Sound.Play("SoundMenuSelect", 1f, 1f);
					HubState.Current = HubState.View.HubIndex;
					HubState.HubPageOffset = 0;
					HubState.ActivePage = -1;
					HubState.PageItemOffset = 0;
					SetDesiredNavigationIndex(__instance, 0);
					__instance.OptionsUpdate();
					return false;
				}
				if (selectionIndex == backSlotIndex && !flag)
				{
					Sound.Play("SoundMenuBack", 1f, 1f);
					SetMenuIndex(__instance, (MenuIndex)0);
					int value = ((!Master.IsDemo) ? 2 : 3);
					SetDesiredNavigationIndex(__instance, value);
					HubState.Reset();
					__instance.OptionsUpdate();
					return false;
				}
			}
			return true;
		}

		private static void HandleHubSelection(MainMenuScript menu, int selectionIndex)
		{
			if (TryGetHubLayout(menu, out var layout))
			{
				if (HubState.Current == HubState.View.HubIndex)
				{
					HandleHubIndexSelection(menu, selectionIndex, layout);
				}
				else if (HubState.Current == HubState.View.Page)
				{
					int navigationDirection = GetNavigationDirection(menu);
					HandleHubPageSelection(menu, selectionIndex, layout, navigationDirection);
				}
			}
		}

		private static void HandleHubIndexSelection(MainMenuScript menu, int selectionIndex, HubLayout layout)
		{
			int hubPageOffset = HubState.HubPageOffset;
			int count = ModSettingsManager.Pages.Count;
			int num = Mathf.Min(hubPageOffset + layout.ListSlots, count);
			if (selectionIndex >= 0 && selectionIndex < layout.ListSlots)
			{
				int num2 = hubPageOffset + selectionIndex;
				if (num2 >= hubPageOffset && num2 < num)
				{
					Sound.Play("SoundMenuSelect", 1f, 1f);
					HubState.ActivePage = num2;
					HubState.PageItemOffset = 0;
					HubState.Current = HubState.View.Page;
					SetDesiredNavigationIndex(menu, 0);
				}
			}
			else if (selectionIndex == layout.NextRow && num < count)
			{
				Sound.Play("SoundMenuSelect", 1f, 1f);
				HubState.HubPageOffset = ClampPageOffset(HubState.HubPageOffset + layout.Step, count);
			}
			else if (selectionIndex == layout.BackRow)
			{
				Sound.Play("SoundMenuBack", 1f, 1f);
				HubState.Reset();
				SetDesiredNavigationIndex(menu, GetModsSlotIndex());
			}
		}

		private static void HandleHubPageSelection(MainMenuScript menu, int selectionIndex, HubLayout layout, int direction)
		{
			if (!TryGetActivePage(out ModSettingsManager.Page page))
			{
				return;
			}
			int pageItemOffset = HubState.PageItemOffset;
			int count = page.Items.Count;
			int num = Mathf.Min(pageItemOffset + layout.ListSlots, count);
			if (selectionIndex >= 0 && selectionIndex < layout.ListSlots)
			{
				int num2 = pageItemOffset + selectionIndex;
				if (num2 >= pageItemOffset && num2 < num)
				{
					ModSettingsManager.Item item = page.Items[num2];
					if ((direction != 0) ? TryInvokeAdjust(page, num2, item, direction) : TryInvokeSelect(page, num2, item))
					{
						Sound.Play("SoundMenuSelect", 1f, 1f);
					}
				}
			}
			else if (selectionIndex == layout.NextRow && num < count)
			{
				Sound.Play("SoundMenuSelect", 1f, 1f);
				HubState.PageItemOffset = ClampPageOffset(HubState.PageItemOffset + layout.Step, count);
			}
			else if (selectionIndex == layout.BackRow)
			{
				Sound.Play("SoundMenuBack", 1f, 1f);
				HubState.Current = HubState.View.HubIndex;
				HubState.PageItemOffset = 0;
				HubState.ActivePage = -1;
				SetDesiredNavigationIndex(menu, 0);
			}
		}

		private static int GetNavigationDirection(MainMenuScript menu)
		{
			bool flag = GetFlag(RightNavigationPressField, menu);
			bool flag2 = GetFlag(LeftNavigationPressField, menu);
			int num = (flag ? 1 : (flag2 ? (-1) : 0));
			if (num == 0 && Controls.MouseButton_PressedGet(0, (MouseElement)1))
			{
				num = -1;
			}
			return num;
		}

		private static bool TryInvokeSelect(ModSettingsManager.Page page, int itemIndex, ModSettingsManager.Item item)
		{
			if (item == null || item.OnSelect == null)
			{
				return true;
			}
			return TryInvokeItemHandler(page, itemIndex, "OnSelect", item.OnSelect);
		}

		private static bool TryInvokeAdjust(ModSettingsManager.Page page, int itemIndex, ModSettingsManager.Item item, int direction)
		{
			ModSettingsManager.Item item2 = item;
			if (item2 == null || item2.OnAdjust == null)
			{
				return true;
			}
			return TryInvokeItemHandler(page, itemIndex, "OnAdjust", delegate
			{
				item2.OnAdjust(direction);
			});
		}

		private static bool TryInvokeItemHandler(ModSettingsManager.Page page, int itemIndex, string handler, Action invoke)
		{
			try
			{
				invoke();
				return true;
			}
			catch (Exception ex)
			{
				LogHandlerException(handler, page, itemIndex, ex);
				return false;
			}
		}

		private static void LogHandlerException(string handler, ModSettingsManager.Page page, int itemIndex, Exception ex)
		{
			string text = page?.Name ?? "(unnamed page)";
			Logging.LogError($"Exception during {handler} for page '{text}' item index {itemIndex}: {ex}");
		}
	}
	[HarmonyPatch]
	public class TexturePatcher
	{
		[HarmonyPatch(typeof(Object), "Internal_CloneSingle", new Type[] { typeof(Object) })]
		[HarmonyPostfix]
		public static void Object_CloneSingle(ref Object __result)
		{
			Object obj = __result;
			GameObject val = (GameObject)(object)((obj is GameObject) ? obj : null);
			if (val == null)
			{
				return;
			}
			Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val2 in componentsInChildren)
			{
				Material[] materials = val2.materials;
				foreach (Material val3 in materials)
				{
					if (!val3.HasProperty("_MainTex") || (Object)(object)val3.mainTexture == (Object)null)
					{
						continue;
					}
					string text = ((Object)val3.mainTexture).name.ToLower();
					string text2 = ((Object)val).name.Replace("(Clone)", "").Trim().ToLower() + "_" + ((Object)val3.mainTexture).name.ToLower();
					string text3 = ((Object)val).name.Replace("(Clone)", "").Trim().ToLower() + "_" + ((Object)val2).name.Trim().ToLower() + "_" + ((Object)val3.mainTexture).name.ToLower();
					if (TextureManager.TryGetTextureOverride(out var texture, text, text2, text3))
					{
						if ((val3.mainTexture.width != ((Texture)texture).width || val3.mainTexture.height != ((Texture)texture).height) && !Plugin.UseFullQualityTextures.Value)
						{
							texture = TextureUtils.ResizeTexture(texture, val3.mainTexture.width, val3.mainTexture.height);
						}
						val3.mainTexture = (Texture)(object)texture;
					}
				}
			}
			AudioSource[] componentsInChildren2 = val.GetComponentsInChildren<AudioSource>(true);
			foreach (AudioSource val4 in componentsInChildren2)
			{
				if (!((Object)(object)val4.clip == (Object)null) && AudioManager.TryGetSoundOverride(out var audioClip, ((Object)val4.clip).name))
				{
					val4.clip = audioClip;
				}
			}
		}
	}
	[HarmonyPatch]
	internal class TranslationPatcher
	{
		[HarmonyPatch(typeof(Translation), "Get")]
		[HarmonyPrefix]
		internal static bool Translation_Get_Prefix(ref string key, ref string __result)
		{
			if (string.IsNullOrEmpty(key))
			{
				return true;
			}
			bool result = true;
			if (LocalizationManager.TryGetValueNoCase(key, out var value))
			{
				__result = value;
				result = false;
			}
			if (LanguageManager.IsCustomLanguage && LanguageManager.TryGetTerm(key, out var termValue))
			{
				__result = termValue;
				result = false;
			}
			return result;
		}

		[HarmonyPatch(typeof(Strings), "Sanitize")]
		[HarmonyPrefix]
		internal static void Strings_Sanitize_Prefix(ref string input, SantizationKind santizationKind, SanitizationSubKind subKind)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			StringManager.Sanitize(ref input, santizationKind, subKind);
		}

		[HarmonyPatch(typeof(Strings), "Sanitize")]
		[HarmonyPostfix]
		internal static void Strings_Sanitize_Postfix(ref string __result, SantizationKind santizationKind, SanitizationSubKind subKind)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			StringManager.SanitizeLate(ref __result, santizationKind, subKind);
		}

		[HarmonyPatch(typeof(Translation), "LanguageGet")]
		[HarmonyPrefix]
		internal static bool Translation_LanguageGet_Prefix(ref Language __result)
		{
			if (LanguageManager.IsCustomLanguage)
			{
				__result = (Language)0;
				return false;
			}
			return true;
		}
	}
}
namespace CloverAPI.Internal
{
	internal class CharmMappings : JsonPersistentData
	{
		internal static CharmMappings Instance = new CharmMappings();

		[JsonProperty]
		internal Dictionary<string, Identifier> Mappings = new Dictionary<string, Identifier>();

		public override void BeforeSave()
		{
			Mappings = CharmManager.GUIDToId;
		}

		public override void AfterLoad()
		{
			//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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<Identifier, Identifier> dictionary = CharmManager.GenerateRemaps(Mappings);
			if (dictionary.Count == 0)
			{
				Logging.LogInfo("No Charm mappings to apply.");
				return;
			}
			Logging.LogInfo("Current Charm mappings:");
			foreach (KeyValuePair<Identifier, Identifier> item in dictionary)
			{
				Logging.LogInfo($"  {item.Key} -> {item.Value}");
			}
			for (int i = 0; i < GameplayData.Instance.equippedPowerups.Length; i++)
			{
				Identifier key = PlatformDataMaster.EnumEntryFromString<Identifier>(GameplayData.Instance.equippedPowerups[i], (Identifier)(-1));
				if (dictionary.TryGetValue(key, out var value))
				{
					GameplayData.Instance.equippedPowerups[i] = ((object)(Identifier)(ref value)).ToString();
				}
			}
			for (int j = 0; j < GameplayData.Instance.equippedPowerups_Skeleton.Length; j++)
			{
				Identifier key2 = PlatformDataMaster.EnumEntryFromString<Identifier>(GameplayData.Instance.equippedPowerups_Skeleton[j], (Identifier)(-1));
				if (dictionary.TryGetValue(key2, out var value2))
				{
					GameplayData.Instance.equippedPowerups_Skeleton[j] = ((object)(Identifier)(ref value2)).ToString();
				}
			}
			for (int k = 0; k < GameplayData.Instance.drawerPowerups.Length; k++)
			{
				Identifier key3 = PlatformDataMaster.EnumEntryFromString<Identifier>(GameplayData.Instance.drawerPowerups[k], (Identifier)(-1));
				if (dictionary.TryGetValue(key3, out var value3))
				{
					GameplayData.Instance.drawerPowerups[k] = ((object)(Identifier)(ref value3)).ToString();
				}
			}
		}
	}
	public static class ResourceOrdering
	{
		private static readonly object _lock = new object();

		private static ConfigEntry<string> _overrideOrdering;

		public static List<string> OrderedPluginUuids { get; private set; } = new List<string>();


		public static int GetPriority(string pluginUuid)
		{
			lock (_lock)
			{
				if (!OrderedPluginUuids.Contains(pluginUuid))
				{
					OrderedPluginUuids.Add(pluginUuid);
					ApplyToConfig();
				}
				return OrderedPluginUuids.IndexOf(pluginUuid);
			}
		}

		internal static void _ConfigRef(ConfigEntry<string> overrideOrdering)
		{
			lock (_lock)
			{
				if (overrideOrdering == null)
				{
					throw new ArgumentNullException("overrideOrdering");
				}
				_overrideOrdering = overrideOrdering;
				OrderedPluginUuids = new List<string>((from s in overrideOrdering.Value.Split(new char[1] { ',' })
					select s.Trim() into s
					where !string.IsNullOrEmpty(s)
					select s).ToArray());
			}
		}

		internal static void ApplyToConfig()
		{
			lock (_lock)
			{
				if (_overrideOrdering == null)
				{
					throw new InvalidOperationException("Config reference not set. Call _ConfigRef first.");
				}
				_overrideOrdering.Value = string.Join(", ", OrderedPluginUuids);
			}
		}
	}
}
namespace CloverAPI.Content.Textures
{
	public class TextureManager
	{
		internal class TextureOverride : IPriority
		{
			public Texture2D Texture;

			public string OwnerGuid;

			public int Priority => ResourceOrdering.GetPriority(OwnerGuid);
		}

		internal static ConcurrentDictionary<string, OrderedList<TextureOverride, PriorityComparer>> TextureOverrides = new ConcurrentDictionary<string, OrderedList<TextureOverride, PriorityComparer>>();

		public static void RegisterTextureOverride(string name, Texture2D texture, ModGuid guid)
		{
			_RegisterOverride(name, TextureOverrides, texture, guid);
		}

		private static void _RegisterOverride(string name, ConcurrentDictionary<string, OrderedList<TextureOverride, PriorityComparer>> dict, Texture2D texture, ModGuid guid)
		{
			if (!dict.ContainsKey(name))
			{
				dict[name] = new OrderedList<TextureOverride, PriorityComparer>();
			}
			TextureOverride textureOverride = dict[name].FirstOrDefault((TextureOverride o) => o.OwnerGuid == guid);
			if (textureOverride != null)
			{
				textureOverride.Texture = texture;
				return;
			}
			dict[name].Add(new TextureOverride
			{
				Texture = texture,
				OwnerGuid = guid
			});
		}

		public static bool TryGetTextureOverride(string name, out Texture2D texture)
		{
			return _TryGetOverride(name, TextureOverrides, out texture);
		}

		public static bool TryGetTextureOverride(out Texture2D texture, params string[] names)
		{
			for (int i = 0; i < names.Length; i++)
			{
				if (_TryGetOverride(names[i], TextureOverrides, out texture))
				{
					return true;
				}
			}
			texture = null;
			return false;
		}

		private static bool _TryGetOverride(string name, ConcurrentDictionary<string, OrderedList<TextureOverride, PriorityComparer>> dict, out Texture2D texture)
		{
			if (dict.TryGetValueNoCase(name, out var value) && value.Count > 0)
			{
				TextureOverride textureOverride = value[0];
				texture = textureOverride.Texture;
				return true;
			}
			texture = null;
			return false;
		}
	}
}
namespace CloverAPI.Content.Strings
{
	public static class LanguageManager
	{
		internal static List<string> CustomLanguages = new List<string>();

		internal static Dictionary<Language, string> LangMap = new Dictionary<Language, string>();

		internal static Dictionary<string, Language> LangMapT = new Dictionary<string, Language>();

		internal static Dictionary<string, Dictionary<string, string>> TermsByLanguage = new Dictionary<string, Dictionary<string, string>>();

		private static int NextId => Enum.GetValues(typeof(Language)).Length + CustomLanguages.Count - 1;

		public static bool IsCustomLanguage => (int)Data.settings.language >= Enum.GetValues(typeof(Language)).Length - 1;

		public static Language LoadFromFile(string filePath)
		{
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			string[] array = File.ReadAllText(filePath).Replace("\\;", "<SEMICOLON>").Split(new char[2] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			string text = "";
			string[] array2 = array;
			foreach (string text2 in array2)
			{
				if (!text2.StartsWith("#") && !text2.StartsWith("//") && !string.IsNullOrWhiteSpace(text2))
				{
					string[] array3 = text2.Split(new char[1] { ';' }, 2);
					if (array3.Length == 2)
					{
						text = array3[0].Trim();
						dictionary[text] = array3[1].Replace("<SEMICOLON>", ";").Trim();
					}
					else
					{
						Dictionary<string, string> dictionary2 = dictionary;
						string key = text;
						dictionary2[key] = dictionary2[key] + "\n" + text2.Replace("<SEMICOLON>", ";");
					}
				}
			}
			if (!dictionary.ContainsKey("YOUR_LANGUAGE_TRANSLATED"))
			{
				dictionary["YOUR_LANGUAGE_TRANSLATED"] = Path.GetFileNameWithoutExtension(filePath);
			}
			return RegisterLanguage(dictionary);
		}

		public static Language RegisterLanguage(params (string termKey, string termValue)[] terms)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			for (int i = 0; i < terms.Length; i++)
			{
				(string termKey, string termValue) tuple = terms[i];
				string item = tuple.termKey;
				string item2 = tuple.termValue;
				dictionary[item] = item2;
			}
			string languageName = $"UnnamedLanguage{CustomLanguages.Count + 1}";
			if (dictionary.TryGetValue("YOUR_LANGUAGE_TRANSLATED", out var value))
			{
				languageName = value;
			}
			return RegisterLanguage(languageName, dictionary);
		}

		public static Language RegisterLanguage(Dictionary<string, string> terms)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			string languageName = $"UnnamedLanguage{CustomLanguages.Count + 1}";
			if (terms.TryGetValue("YOUR_LANGUAGE_TRANSLATED", out var value))
			{
				languageName = value;
			}
			return RegisterLanguage(languageName, terms);
		}

		public static Language RegisterLanguage(string languageName, params (string termKey, string termValue)[] terms)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			for (int i = 0; i < terms.Length; i++)
			{
				(string termKey, string termValue) tuple = terms[i];
				string item = tuple.termKey;
				string item2 = tuple.termValue;
				dictionary[item] = item2;
			}
			return RegisterLanguage(languageName, dictionary);
		}

		public static Language RegisterLanguage(string languageName, Dictionary<string, string> terms)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (!CustomLanguages.Contains(languageName))
			{
				Language val = (Language)NextId;
				LangMap[val] = languageName;
				LangMapT[languageName] = val;
				TermsByLanguage[languageName] = new Dictionary<string, string>(terms);
				CustomLanguages.Add(languageName);
				_ = Translation.LanguagesInOrder;
				Translation._languagesInOrder = Translation._languagesInOrder.Append(val).ToArray();
				Translation.languageNamesTranslated = Translation.languageNamesTranslated.Append(languageName).ToArray();
				Translation.languagesI2Names = Translation.languagesI2Names.Append("English").ToArray();
				return val;
			}
			throw new Exception("Language " + languageName + " is already registered.");
		}

		public static bool TryGetTerm(string termKey, out string termValue)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Language language = Data.settings.language;
			if (LangMap.TryGetValue(language, out var value) && TermsByLanguage.TryGetValue(value, out var value2))
			{
				return value2.TryGetValue(termKey, out termValue);
			}
			termValue = null;
			return false;
		}

		public static Language GetLanguageByName(string languageName)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (LangMapT.TryGetValue(languageName, out var value))
			{
				return value;
			}
			throw new Exception("Language " + languageName + " is not registered.");
		}

		private static bool TryGetLanguageByName(string languageName, out Language lang)
		{
			return LangMapT.TryGetValue(languageName, out lang);
		}
	}
	public static class LocalizationManager
	{
		public static Dictionary<string, StringSource> Translations = new Dictionary<string, StringSource>();

		public static string RegisterTranslation(string key, StringSource value)
		{
			value.SetKey(key);
			Translations[key] = value;
			return key;
		}

		public static string Get(string key)
		{
			if (Translations.TryGetValue(key, out var value))
			{
				return value.GetString();
			}
			return key;
		}

		public static bool TryGetValueNoCase(string key, out string value)
		{
			if (Translations.TryGetValueNoCase(key, out var value2))
			{
				if (value2 is VanillaLocalizedString)
				{
					value = null;
					return false;
				}
				value = value2.GetString();
				return true;
			}
			value = null;
			return false;
		}
	}
	public class StringManager
	{
		private static readonly Dictionary<string, StringSource> Strings = new Dictionary<string, StringSource>();

		private static readonly Dictionary<string, Tuple<StringSource, SantizationKind, SanitizationSubKind>> ConditionalStrings = new Dictionary<string, Tuple<StringSource, SantizationKind, SanitizationSubKind>>();

		private static readonly Dictionary<string, StringSource> StringsLate = new Dictionary<string, StringSource>();

		private static readonly Dictionary<string, Tuple<StringSource, SantizationKind, SanitizationSubKind>> ConditionalStringsLate = new Dictionary<string, Tuple<StringSource, SantizationKind, SanitizationSubKind>>();

		public static void RegisterString(string key, StringSource value, bool late = false)
		{
			if (late)
			{
				StringsLate[key] = value;
			}
			else
			{
				Strings[key] = value;
			}
		}

		public static void RegisterConditional(string key, StringSource value, SantizationKind kind, SanitizationSubKind subKind, bool late = false)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (late)
			{
				ConditionalStringsLate[key] = new Tuple<StringSource, SantizationKind, SanitizationSubKind>(value, kind, subKind);
			}
			else
			{
				ConditionalStrings[key] = new Tuple<StringSource, SantizationKind, SanitizationSubKind>(value, kind, subKind);
			}
		}

		public static void Sanitize(ref string s, SantizationKind santizationKind, SanitizationSubKind subKind)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder(s);
			foreach (string key in Strings.Keys)
			{
				stringBuilder.Replace(key, Strings[key].GetString());
			}
			foreach (string key2 in ConditionalStrings.Keys)
			{
				var (stringSource2, val3, val4) = ConditionalStrings[key2];
				if (((int)santizationKind == 0 || santizationKind == val3) && ((int)subKind == 0 || subKind == val4))
				{
					stringBuilder.Replace(key2, stringSource2.GetString());
				}
			}
			s = stringBuilder.ToString();
		}

		public static void SanitizeLate(ref string s, SantizationKind santizationKind, SanitizationSubKind subKind)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder(s);
			foreach (string key in StringsLate.Keys)
			{
				stringBuilder.Replace(key, StringsLate[key].GetString());
			}
			foreach (string key2 in ConditionalStringsLate.Keys)
			{
				var (stringSource2, val3, val4) = ConditionalStringsLate[key2];
				if (((int)santizationKind == 0 || santizationKind == val3) && ((int)subKind == 0 || subKind == val4))
				{
					stringBuilder.Replace(key2, stringSource2.GetString());
				}
			}
			s = stringBuilder.ToString();
		}
	}
}
namespace CloverAPI.Content.Settings
{
	public class ModSettingsManager
	{
		public enum ToggleAdjustMode
		{
			Toggle,
			Directional
		}

		public sealed class Item
		{
			public Func<string>? Label { get; set; }

			public Action? OnSelect { get; set; }

			public Action<int>? OnAdjust { get; set; }

			public Item()
			{
			}

			internal Item(Func<string>? label, Action? onSelect, Action<int>? onAdjust)
			{
				Label = label;
				OnSelect = onSelect;
				OnAdjust = onAdjust;
			}
		}

		public sealed class Page
		{
			private readonly List<Item> items = new List<Item>();

			public string Name { get; }

			internal string OwnerGuid { get; }

			internal string OwnerName { get; }

			internal string NormalizedName { get; }

			public List<Item> Items => items;

			internal Page(string name, ModGuid ownerGuid, ModName ownerName, string normalizedName)
			{
				if (string.IsNullOrWhiteSpace(name))
				{
					throw new ArgumentException("Page name must not be empty.", "name");
				}
				if (string.IsNullOrWhiteSpace(ownerGuid))
				{
					throw new ArgumentException("Page owner GUID must not be empty.", "ownerGuid");
				}
				if (string.IsNullOrWhiteSpace(normalizedName))
				{
					throw new ArgumentException("Normalized page name must not be empty.", "normalizedName");
				}
				Name = name;
				OwnerGuid = ownerGuid;
				OwnerName = ownerName;
				NormalizedName = normalizedName;
			}

			internal Item AddItem(Func<string>? label, Action? onSelect, Action<int>? onAdjust)
			{
				return AddItem(new Item(label, onSelect, onAdjust));
			}

			internal Item AddItem(Item item)
			{
				if (item == null)
				{
					throw new ArgumentNullException("item");
				}
				items.Add(item);
				return item;
			}
		}

		public sealed class PageBuilder
		{
			private static readonly IReadOnlyList<float> DefaultMultiplierSteps = Array.AsReadOnly(new float[6] { 0f, 0.5f, 1f, 2f, 3f, 4f });

			private readonly Page page;

			public Page BuiltPage => page;

			internal PageBuilder(Page page)
			{
				this.page = page ?? throw new ArgumentNullException("page");
			}

			public PageBuilder AddItem(Func<string>? label, Action? onSelect = null, Action<int>? onAdjust = null)
			{
				page.AddItem(label, onSelect, onAdjust);
				return this;
			}

			public PageBuilder AddToggle(string label, Func<bool> getter, Action<bool> setter, string onLabel = "On", string offLabel = "Off", Action<bool>? onChanged = null, ToggleAdjustMode adjustMode = ToggleAdjustMode.Toggle)
			{
				string label2 = label;
				Func<bool> getter2 = getter;
				string onLabel2 = onLabel;
				string offLabel2 = offLabel;
				Action<bool> setter2 = setter;
				Action<bool> onChanged2 = onChanged;
				if (label2 == null)
				{
					throw new ArgumentNullException("label");
				}
				if (getter2 == null)
				{
					throw new ArgumentNullException("getter");
				}
				if (setter2 == null)
				{
					throw new ArgumentNullException("setter");
				}
				return AddItem(Format, delegate
				{
					SetValue(!getter2());
				}, delegate(int dir)
				{
					int num = NormalizeDirection(dir);
					if (num != 0)
					{
						if (adjustMode == ToggleAdjustMode.Directional)
						{
							SetValue(num > 0);
						}
						else
						{
							SetValue(!getter2());
						}
					}
				});
				string Format()
				{
					return label2 + ": " + (getter2() ? onLabel2 : offLabel2);
				}
				void SetValue(bool value)
				{
					UpdateIfChanged(getter2, setter2, value, onChanged2);
				}
			}

			public PageBuilder AddToggle(string label, ConfigEntry<bool> entry, string onLabel = "On", string offLabel = "Off", Action<bool>? onChanged = null, ToggleAdjustMode adjustMode = ToggleAdjustMode.Toggle)
			{
				ConfigEntry<bool> entry2 = entry;
				if (entry2 == null)
				{
					throw new ArgumentNullException("entry");
				}
				return AddToggle(label, () => entry2.Value, delegate(bool value)
				{
					entry2.Value = value;
				}, onLabel, offLabel, onChanged, adjustMode);
			}

			public PageBuilder OnOff(string label, Func<bool> getter, Action<bool> setter, string onLabel = "On", string offLabel = "Off", Action<bool>? onChanged = null, ToggleAdjustMode adjustMode = ToggleAdjustMode.Toggle)
			{
				return AddToggle(label, getter, setter, onLabel, offLabel, onChanged, adjustMode);
			}

			public PageBuilder OnOff(string label, ConfigEntry<bool> entry, string onLabel = "On", string offLabel = "Off", Action<bool>? onChanged = null, ToggleAdjustMode adjustMode = ToggleAdjustMode.Toggle)
			{
				ConfigEntry<bool> entry2 = entry;
				return OnOff(label, () => entry2.Value, delegate(bool value)
				{
					entry2.Value = value;
				}, onLabel, offLabel, onChanged, adjustMode);
			}

			public PageBuilder AddIntStepper(string label, Func<int> getter, Action<int> setter, int step = 1, int? min = null, int? max = null, bool wrap = false, Func<int, int>? normalizer = null, Func<int, string>? valueFormatter = null, Action<int>? onChanged = null)
			{
				Func<int, int> normalizer2 = normalizer;
				Func<int> getter2 = getter;
				Action<int> setter2 = setter;
				Action<int> onChanged2 = onChanged;
				Func<int, string> valueFormatter2 = valueFormatter;
				string label2 = label;
				if (label2 == null)
				{
					throw new ArgumentNullException("label");
				}
				if (getter2 == null)
				{
					throw new ArgumentNullException("getter");
				}
				if (setter2 == null)
				{
					throw new ArgumentNullException("setter");
				}
				if (step <= 0)
				{
					throw new ArgumentOutOfRangeException("step", "Step must be positive.");
				}
				if (min.HasValue && max.HasValue && min.Value > max.Value)
				{
					throw new ArgumentOutOfRangeException("max", "Max must be greater than or equal to min.");
				}
				return AddItem(Format, delegate
				{
					SetValue(getter2() + step);
				}, delegate(int dir)
				{
					int num5 = NormalizeDirection(dir);
					if (num5 != 0)
					{
						SetValue(getter2() + num5 * step);
					}
				});
				int ApplyBounds(int value)
				{
					if (wrap && min.HasValue && max.HasValue && min.Value <= max.Value)
					{
						int num = Math.Max(1, step);
						int num2 = max.Value - min.Value + num;
						if (num2 > 0)
						{
							int num3 = ((value - min.Value) % num2 + num2) % num2;
							return min.Value + num3;
						}
					}
					if (min.HasValue && value < min.Value)
					{
						value = min.Value;
					}
					if (max.HasValue && value > max.Value)
					{
						value = max.Value;
					}
					return value;
				}
				string Format()
				{
					int arg = getter2();
					string text = valueFormatter2?.Invoke(arg) ?? arg.ToString();
					return label2 + ": " + text;
				}
				int Normalize(int value)
				{
					int num4 = ApplyBounds(value);
					if (normalizer2 != null)
					{
						num4 = ApplyBounds(normalizer2(num4));
					}
					return num4;
				}
				void SetValue(int rawValue)
				{
					int value2 = Normalize(rawValue);
					UpdateIfChanged(getter2, setter2, value2, onChanged2);
				}
			}

			public PageBuilder AddIntStepper(string label, ConfigEntry<int> entry, int step = 1, int? min = null, int? max = null, bool wrap = false, Func<int, int>? normalizer = null, Func<int, string>? valueFormatter = null, Action<int>? onChanged = null)
			{
				ConfigEntry<int> entry2 = entry;
				if (entry2 == null)
				{
					throw new ArgumentNullException("entry");
				}
				return AddIntStepper(label, () => entry2.Value, delegate(int value)
				{
					entry2.Value = value;
				}, step, min, max, wrap, normalizer, valueFormatter, onChanged);
			}

			public PageBuilder Int(string label, Func<int> getter, Action<int> setter, int? min = null, int? max = null, int step = 1, bool wrap = false, Func<int, int>? normalizer = null, Func<int, string>? valueFormatter = null, Action<int>? onChanged = null)
			{
				return AddIntStepper(label, getter, setter, step, min, max, wrap, normalizer, valueFormatter, onChanged);
			}

			public PageBuilder Int(string label, ConfigEntry<int> entry, int? min = null, int? max = null, int step = 1, bool wrap = false, Func<int, int>? normalizer = null, Func<int, string>? valueFormatter = null, Action<int>? onChanged = null)
			{
				ConfigEntry<int> entry2 = entry;
				if (entry2 == null)
				{
					throw new ArgumentNullException("entry");
				}
				return Int(label, () => entry2.Value, delegate(int value)
				{
					entry2.Value = value;
				}, min, max, step, wrap, normalizer, valueFormatter, onChanged);
			}

			public PageBuilder Percent(string label, Func<int> getter, Action<int> setter, int minPercent = 0, int maxPercent = 100, int step = 5, bool wrap = false, bool showPercent = true, float scale = 1f, Action<int>? onChanged = null)
			{
				if (maxPercent < minPercent)
				{
					throw new ArgumentOutOfRangeException("maxPercent", "maxPercent must be greater than or equal to minPercent.");
				}
				return AddIntStepper(label, getter, setter, step, minPercent, maxPercent, wrap, null, Formatter, onChanged);
				string Formatter(int value)
				{
					int num = (int)((float)value * scale);
					if (!showPercent)
					{
						return num.ToString();
					}
					return $"{num}%";
				}
			}

			public PageBuilder Percent(string label, ConfigEntry<int> entry, int minPercent = 0, int maxPercent = 100, int step = 5, bool wrap = false, bool showPercent = true, float scale = 1f, Action<int>? onChanged = null)
			{
				ConfigEntry<int> entry2 = entry;
				if (entry2 == null)
				{
					throw new ArgumentNullException("entry");
				}
				return Percent(label, () => entry2.Value, delegate(int value)
				{
					entry2.Value = value;
				}, minPercent, maxPercent, step, wrap, showPercent, scale, onChanged);
			}

			public PageBuilder Percent(string label, Func<float> getter, Action<float> setter, float minPercent = 0f, float maxPercent = 100f, float step = 5f, bool wrap = false, int decimalPlaces = 1, bool showPercent = true, float scale = 1f, Action<float>? onChanged = null)
			{
				Action<float> onChanged2 = onChanged;
				Func<float> getter2 = getter;
				Action<float> setter2 = setter;
				if (label == null)
				{
					throw new ArgumentNullException("label");
				}
				if (getter2 == null)
				{
					throw new ArgumentNullException("getter");
				}
				if (setter2 == null)
				{
					throw new ArgumentNullException("setter");
				}
				if (step <= 0f)
				{
					throw new ArgumentOutOfRangeException("step", "Step must be positive.");
				}
				if (decimalPlaces < 0)
				{
					throw new ArgumentOutOfRangeException("decimalPlaces", "decimalPlaces must be zero or greater.");
				}
				float num = getter2();
				int requiredDecimalPlaces = GetRequiredDecimalPlaces(minPercent, maxPercent, step, num);
				int effectiveDecimalPlaces = Math.Max(decimalPlaces, requiredDecimalPlaces);
				int localScale = Pow10(effectiveDecimalPlaces);
				int num2 = Scale(step);
				if (num2 <= 0)
				{
					throw new ArgumentOutOfRangeException("step", "Step is too small for the configured decimalPlaces.");
				}
				int minScaled = Scale(minPercent);
				int maxScaled = Scale(maxPercent);
				if (maxScaled < minScaled)
				{
					throw new ArgumentOutOfRangeException("maxPercent", "maxPercent must be greater than or equal to minPercent.");
				}
				Action<int> onChanged3 = null;
				if (onChanged2 != null)
				{
					onChanged3 = delegate(int value)
					{
						onChanged2(Unscale(value));
					};
				}
				return AddIntStepper(label, () => Scale(getter2()), delegate(int value)
				{
					setter2(Unscale(value));
				}, num2, minScaled, maxScaled, wrap, RoundOnNonBounds, FormatPercentLabel, onChanged3);
				string FormatPercentLabel(int scaledValue)
				{
					float num3 = Unscale(scaledValue) * scale;
					string text = ((effectiveDecimalPlaces > 0) ? $"F{effectiveDecimalPlaces}" : "F0");
					string text2 = num3.ToString(text, CultureInfo.InvariantCulture);
					if (effectiveDecimalPlaces > 0)
					{
						text2 = text2.TrimEnd(new char[1] { '0' }).TrimEnd(new char[1] { '.' });
					}
					if (!showPercent)
					{
						return text2;
					}
					return text2 + "%";
				}
				int RoundOnNonBounds(int value)
				{
					if (value == minScaled || value == maxScaled)
					{
						return value;
					}
					return Scale(MathUtils.RoundToMultipleOf(Unscale(value), step));
				}
				int Scale(float value)
				{
					return (int)Math.Round((decimal)value * (decimal)localScale, MidpointRounding.AwayFromZero);
				}
				float Unscale(int value)
				{
					return (float)value / (float)localScale;
				}
			}

			public PageBuilder Percent(string label, ConfigEntry<float> entry, float minPercent = 0f, float maxPercent = 100f, float step = 5f, bool wrap = false, int decimalPlaces = 1, bool showPercent = true, float scale = 1f, Action<float>? onChanged = null)
			{
				ConfigEntry<float> entry2 = entry;
				if (entry2 == null)
				{
					throw new ArgumentNullException("entry");
				}
				return Percent(label, () => entry2.Value, delegate(float value)
				{
					entry2.Value = value;
				}, minPercent, maxPercent, step, wrap, decimalPlaces, showPercent, scale, onChanged);
			}

			public PageBuilder Multiplier(string label, Func<float> getter, Action<float> setter, float minMultiplier, float maxMultiplier, float step, bool wrap = false, int decimalPlaces = 2, Func<float, string>? valueFormatter = null, Action<float>? onChanged = null)
			{
				Func<float, string> valueFormatter2 = valueFormatter;
				Action<float> onChanged2 = onChanged;
				Func<float> getter2 = getter;
				Action<float> setter2 = setter;
				if (label == null)
				{
					throw new ArgumentNullException("label");
				}
				if (getter2 == null)
				{
					throw new ArgumentNullException("getter");
				}
				if (setter2 == null)
				{
					throw new ArgumentNullException("setter");
				}
				if (step <= 0f)
				{
					throw new ArgumentOutOfRangeException("step", "Step must be positive.");
				}
				if (decimalPlaces < 0)
				{
					throw new ArgumentOutOfRangeException("decimalPlaces", "decimalPlaces must be zero or greater.");
				}
				float num = getter2();
				int requiredDecimalPlaces = GetRequiredDecimalPlaces(minMultiplier, maxMultiplier, step, num);
				int effectiveDecimalPlaces = Math.Max(decimalPlaces, requiredDecimalPlaces);
				int scale = Pow10(effectiveDecimalPlaces);
				int num2 = Scale(step);
				if (num2 <= 0)
				{
					throw new ArgumentOutOfRangeException("step", "Step is too small for the configured decimalPlaces.");
				}
				int num3 = Scale(minMultiplier);
				int num4 = Scale(maxMultiplier);
				if (num4 < num3)
				{
					throw new ArgumentOutOfRangeException("maxMultiplier", "maxMultiplier must be greater than or equal to minMultiplier.");
				}
				Action<int> onChanged3 = null;
				if (onChanged2 != null)
				{
					onChanged3 = delegate(int value)
					{
						onChanged2(Unscale(value));
					};
				}
				return AddIntStepper(label, () => Scale(getter2()), delegate(int value)
				{
					setter2(Unscale(value));
				}, num2, num3, num4, wrap, null, FormatMultiplierLabel, onChanged3);
				string FormatMultiplierLabel(int scaledValue)
				{
					float arg = Unscale(scaledValue);
					if (valueFormatter2 != null)
					{
						return valueFormatter2(arg);
					}
					string text = ((effectiveDecimalPlaces > 0) ? $"F{effectiveDecimalPlaces}" : "F0");
					string text2 = arg.ToString(text, CultureInfo.InvariantCulture);
					if (effectiveDecimalPlaces > 0)
					{
						text2 = text2.TrimEnd(new char[1] { '0' }).TrimEnd(new char[1] { '.' });
					}
					return text2 + "x";
				}
				int Scale(float value)
				{
					return (int)Math.Round((decimal)value * (decimal)scale, MidpointRounding.AwayFromZero);
				}
				float Unscale(int value)
				{
					return (float)value / (float)scale;
				}
			}

			public PageBuilder Multiplier(string label, ConfigEntry<float> entry, float minMultiplier, float maxMultiplier, float step, bool wrap = false, int decimalPlaces = 2, Func<float, string>? valueFormatter = null, Action<float>? onChanged = null)
			{
				ConfigEntry<float> entry2 = entry;
				if (entry2 == null)
				{
					throw new ArgumentNullException("entry");
				}
				return Multiplier(label, () => entry2.Value, delegate(float value)
				{
					entry2.Value = value;
				}, minMultiplier, maxMultiplier, step, wrap, decimalPlaces, valueFormatter, onChanged);
			}

			public PageBuilder Multiplier(string label, Func<float> getter, Action<float> setter, IReadOnlyList<float>? options = null, Func<float, string>? valueFormatter = null, Action<float>? onChanged = null)
			{
				Func<float, string> valueFormatter2 = valueFormatter;
				IReadOnlyList<float> values = options ?? DefaultMultiplierSteps;
				int optionDecimalPlaces = ((valueFormatter2 == null) ? GetRequiredDecimalPlaces(values) : 0);
				return Cycle(label, getter, setter, values, formatter, onChanged);
				string formatter(float value)
				{
					if (valueFormatter2 != null)
					{
						return valueFormatter2(value);
					}
					string text = ((optionDecimalPlaces > 0) ? $"F{optionDecimalPlaces}" : "F0");
					string text2 = value.ToString(text, CultureInfo.InvariantCulture);
					if (optionDecimalPlaces > 0)
					{
						text2 = text2.TrimEnd(new char[1] { '0' }).TrimEnd(new char[1] { '.' });
					}
					return text2 + "x";
				}
			}

			public PageBuilder Multiplier(string label, ConfigEntry<float> entry, IReadOnlyList<float>? options = null, Func<float, string>? valueFormatter = null, Action<float>? onChanged = null)
			{
				ConfigEntry<float> entry2 = entry;
				if (entry2 == null)
				{
					throw new ArgumentNullException("entry");
				}
				return Multiplier(label, () => entry2.Value, delegate(float value)
				{
					entry2.Value = value;
				}, options, valueFormatter, onChanged);
			}

			public PageBuilder Cycle<T>(string label, Func<T> getter, Action<T> setter, IReadOnlyList<T> values, Func<T, string>? valueFormatter = null, Action<T>? onChanged = null, IEqualityComparer<T>? comparer = null)
			{
				return CycleInternal(label, getter, setter, values, valueFormatter, onChanged, comparer);
			}

			public PageBuilder Cycle<T>(string label, Func<T> getter, Action<T> setter, params T[] values)
			{
				if (values == null)
				{
					throw new ArgumentNullException("values");
				}
				return CycleInternal(label, getter, setter, Array.AsReadOnly(values), null, null, null);
			}

			public PageBuilder Cycle<T>(string label, ConfigEntry<T> entry, IReadOnlyList<T> values, Func<T, string>? valueFormatter = null, Action<T>? onChanged = null, IEqualityComparer<T>? comparer = null)
			{
				ConfigEntry<T> entry2 = entry;
				if (entry2 == null)
				{
					throw new ArgumentNullException("entry");
				}
				return Cycle(label, () => entry2.Value, delegate(T value)
				{
					entry2.Value = value;
				}, values, valueFormatter, onChanged, comparer);
			}

			public PageBuilder Cycle<T>(string label, ConfigEntry<T> entry, params T[] values)
			{
				if (values == null)
				{
					throw new ArgumentNullException("values");
				}
				return Cycle(label, entry, (IReadOnlyList<T>)Array.AsReadOnly(values), (Func<T, string>?)null, (Action<T>?)null, (IEqualityComparer<T>?)null);
			}

			public void Build()
			{
			}

			private PageBuilder CycleInternal<T>(string label, Func<T> getter, Action<T> setter, IReadOnlyList<T> values, Func<T, string>? valueFormatter, Action<T>? onChanged, IEqualityComparer<T>? comparer)
			{
				IReadOnlyList<T> values2 = values;
				Func<T, string> valueFormatter2 = valueFormatter;
				Func<T> getter2 = getter;
				string label2 = label;
				Action<T> setter2 = setter;
				Action<T> onChanged2 = onChanged;
				if (label2 == null)
				{
					throw new ArgumentNullException("label");
				}
				if (getter2 == null)
				{
					throw new ArgumentNullException("getter");
				}
				if (setter2 == null)
				{
					throw new ArgumentNullException("setter");
				}
				if (values2 == null)
				{
					throw new ArgumentNullException("values");
				}
				if (values2.Count == 0)
				{
					throw new ArgumentException("At least one value must be supplied.", "values");
				}
				IEqualityComparer<T> equalityComparer = comparer ?? EqualityComparer<T>.Default;
				return AddItem(Format, delegate
				{
					Advance(1);
				}, delegate(int dir)
				{
					Advance(dir);
				});
				void Advance(int direction)
				{
					int num = NormalizeDirection(direction);
					if (num != 0 && values2.Count != 1)
					{
						T candidate2 = getter2();
						int num2 = FindIndex(candidate2);
						int index = ((num2 >= 0) ? ((num2 + num + values2.Count) % values2.Count) : ((num <= 0) ? (values2.Count - 1) : 0));
						T value2 = values2[index];
						UpdateIfChanged(getter2, setter2, value2, onChanged2);
					}
				}
				int FindIndex(T candidate)
				{
					for (int i = 0; i < values2.Count; i++)
					{
						if (equalityComparer.Equals(values2[i], candidate))
						{
							return i;
						}
					}
					return -1;
				}
				string Format()
				{
					T value3 = getter2();
					return label2 + ": " + RenderValue(value3);
				}
				string RenderValue(T value)
				{
					if (valueFormatter2 != null)
					{
						return valueFormatter2(value);
					}
					if (!((object)value is IFormattable formattable))
					{
						object obj = value?.ToString();
						if (obj == null)
						{
							obj = string.Empty;
						}
						return (string)obj;
					}
					return formattable.ToString(null, CultureInfo.InvariantCulture);
				}
			}

			private static int NormalizeDirection(int value)
			{
				if (value == 0)
				{
					return 0;
				}
				if (value <= 0)
				{
					return -1;
				}
				return 1;
			}

			private static int Pow10(int exponent)
			{
				if (exponent < 0)
				{
					throw new ArgumentOutOfRangeException("exponent");
				}
				int num = 1;
				for (int i = 0; i < exponent; i++)
				{
					num = checked(num * 10);
				}
				return num;
			}

			private static int GetRequiredDecimalPlaces(IReadOnlyList<float> values)
			{
				if (values == null || values.Count == 0)
				{
					return 0;
				}
				int num = 0;
				for (int i = 0; i < values.Count; i++)
				{
					int num2 = CountDecimalPlaces(values[i]);
					if (num2 > num)
					{
						num = num2;
					}
				}
				return num;
			}

			private static int GetRequiredDecimalPlaces(params float[] values)
			{
				if (values == null || values.Length == 0)
				{
					return 0;
				}
				int num = 0;
				for (int i = 0; i < values.Length; i++)
				{
					int num2 = CountDecimalPlaces(values[i]);
					if (num2 > num)
					{
						num = num2;
					}
				}
				return num;
			}

			private static int CountDecimalPlaces(float value)
			{
				decimal value2 = decimal.Round((decimal)value, 6, MidpointRounding.AwayFromZero);
				value2 = Math.Abs(value2);
				for (int i = 0; i <= 6; i++)
				{
					decimal num = value2 * (decimal)Pow10(i);
					if (decimal.Truncate(num) == num)
					{
						return i;
					}
				}
				return 6;
			}

			private static void UpdateIfChanged<T>(Func<T> getter, Action<T> setter, T value, Action<T>? onChanged)
			{
				if (getter == null)
				{
					throw new ArgumentNullException("getter");
				}
				if (setter == null)
				{
					th