using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LethalUtilities.Configuration;
using LethalUtilitiesV2;
using Microsoft.CodeAnalysis;
using MonoMod.Utils;
using Newtonsoft.Json;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LethalUtilities")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+fc87b84960862e64d1b0d4748adc0adfa6ed415a")]
[assembly: AssemblyProduct("LethalUtilities")]
[assembly: AssemblyTitle("LethalUtilities")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Kyxino/LethalUtilities")]
[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 LethalUtilitiesV2
{
	public enum RunConfig
	{
		Enabled,
		UseLoadSettings,
		ConfigDisabled
	}
	public class Utils
	{
		[CompilerGenerated]
		private sealed class <HarmonyEnumerator>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerator Enumerator;

			public Action EnumeratorPrefix;

			public Action EnumeratorPostfix;

			public Action<object> YieldPrefix;

			public Func<object, object> YieldAction;

			public Action<object> YieldPostfix;

			private object <CurrentItem>5__1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<CurrentItem>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (EnumeratorPrefix != null)
					{
						EnumeratorPrefix();
					}
					break;
				case 1:
					<>1__state = -1;
					if (YieldPostfix != null)
					{
						YieldPostfix(<CurrentItem>5__1);
					}
					<CurrentItem>5__1 = null;
					break;
				}
				if (Enumerator.MoveNext())
				{
					<CurrentItem>5__1 = Enumerator.Current;
					if (YieldPrefix != null)
					{
						YieldPrefix(<CurrentItem>5__1);
					}
					<>2__current = ((YieldAction != null) ? YieldAction(<CurrentItem>5__1) : null);
					<>1__state = 1;
					return true;
				}
				if (EnumeratorPostfix != null)
				{
					EnumeratorPostfix();
				}
				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();
			}
		}

		private static T InvokeMethod<T>(object OBJECT, string METHOD, object[] PARAMETERS = null)
		{
			return (T)OBJECT.GetType().GetMethod(METHOD, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Invoke(OBJECT, PARAMETERS);
		}

		private static T GetField<T>(object OBJECT, string FIELD)
		{
			return (T)OBJECT.GetType().GetField(FIELD, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetValue(OBJECT);
		}

		private static T SetField<T>(object OBJECT, string FIELD, T VALUE)
		{
			OBJECT.GetType().GetField(FIELD, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).SetValue(OBJECT, VALUE);
			return VALUE;
		}

		[IteratorStateMachine(typeof(<HarmonyEnumerator>d__3))]
		public static IEnumerator HarmonyEnumerator(IEnumerator Enumerator, Action EnumeratorPrefix = null, Action EnumeratorPostfix = null, Action<object> YieldPrefix = null, Func<object, object> YieldAction = null, Action<object> YieldPostfix = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HarmonyEnumerator>d__3(0)
			{
				Enumerator = Enumerator,
				EnumeratorPrefix = EnumeratorPrefix,
				EnumeratorPostfix = EnumeratorPostfix,
				YieldPrefix = YieldPrefix,
				YieldAction = YieldAction,
				YieldPostfix = YieldPostfix
			};
		}
	}
	public static class ObjectExtensions
	{
		public static string Val(this object Value)
		{
			return string.Format("{0} ({1})", Value, (Value != null) ? ((object)Value.GetType()) : ((object)"N/A"));
		}
	}
	[BepInPlugin("Kyxino-LUv2", "Ky-LethalUtilities", "2.0.1")]
	public class UtilsMod : BaseUnityPlugin
	{
		[JsonConverter(typeof(IL_SubField))]
		internal class IL_SubFieldConverter : JsonConverter<IL_SubField>
		{
			public override bool CanRead => true;

			public override bool CanWrite => false;

			public override void WriteJson(JsonWriter writer, IL_SubField value, JsonSerializer serializer)
			{
			}

			public override IL_SubField ReadJson(JsonReader reader, Type objectType, IL_SubField existingValue, bool hasExistingValue, JsonSerializer serializer)
			{
				return IL_SubField.Parse(serializer.Deserialize<List<string>>(reader));
			}
		}

		public class IL_SubField
		{
			public static Dictionary<int, IL_SubField> HashChecks = new Dictionary<int, IL_SubField>();

			public IL_Field Field;

			public List<string> SubFieldList;

			public object SubFieldValue;

			public Type SubFieldType;

			public bool IsLocal;

			public int LocalHash;

			public IL_SubField(IL_Field Field, List<string> SubFieldList, bool IsLocal = false)
			{
				this.Field = Field;
				this.SubFieldList = SubFieldList;
				SubFieldType = (SubFieldValue = GetSubFieldValue(Field.OriginalValue))?.GetType();
				this.IsLocal = IsLocal;
				HashChecks.TryAdd(GetHashCode(), this);
			}

			public object GetSubFieldValue(object Field)
			{
				if (IsLocal)
				{
					return Field;
				}
				Logger("GetSubFieldValue", (LogLevel)16, (object)"START");
				Logger("GetSubFieldValue", (LogLevel)16, Field);
				foreach (string subField in SubFieldList)
				{
					try
					{
						Logger("GetSubFieldValue", (LogLevel)16, (object)$"Field: {Field} ({Field?.GetType()}) | SubField: {subField}");
						MethodInfo methodInfo = Field?.GetType()?.GetMethod("get_" + subField);
						Field = ((!(methodInfo != null)) ? Field?.GetType()?.GetField(subField)?.GetValue(Field) : methodInfo.Invoke(Field, Array.Empty<object>()));
						Logger("GetSubFieldValue", (LogLevel)8, (object)$"Field: {Field}");
					}
					catch (Exception ex)
					{
						Logger("GetSubFieldValue", (LogLevel)2, (object)("SubField Error | " + GeneralExtensions.Join<string>((IEnumerable<string>)SubFieldList, (Func<string, string>)null, ", ") + ": " + ex.Message));
						return null;
					}
				}
				Logger("GetSubFieldValue", (LogLevel)16, (object)"END");
				return Field;
			}

			public void SetSubFieldValue(object Field, object Value)
			{
				if (IsLocal)
				{
					return;
				}
				Logger("SetSubFieldValue", (LogLevel)16, (object)"START");
				Logger("SetSubFieldValue", (LogLevel)16, Field);
				for (int i = 0; i < SubFieldList.Count; i++)
				{
					string text = SubFieldList[i];
					try
					{
						Logger("SetSubFieldValue", (LogLevel)16, Field);
						if (i == SubFieldList.Count - 1)
						{
							MethodInfo methodInfo = Field?.GetType()?.GetMethod("set_" + text);
							if (methodInfo != null)
							{
								methodInfo.Invoke(Field = Value, Array.Empty<object>());
							}
							else
							{
								Field?.GetType()?.GetField(text)?.SetValue(Field, Field = Value);
							}
						}
						else
						{
							Field = Field?.GetType()?.GetMethod("get_" + text)?.Invoke(Field, Array.Empty<object>()) ?? Field?.GetType().GetField(text).GetValue(Field);
						}
						Logger("SetSubFieldValue", (LogLevel)8, Field);
					}
					catch (Exception ex)
					{
						Logger("SetSubFieldValue", (LogLevel)2, (object)string.Format("SubField Set Error {0}/{1} | {2}: {3}", i + 1, SubFieldList.Count, GeneralExtensions.Join<string>((IEnumerable<string>)SubFieldList, (Func<string, string>)null, ", "), ex.Message));
						return;
					}
				}
				Logger("SetSubFieldValue", (LogLevel)16, (object)"END");
			}

			public static IL_SubField Parse(List<string> SearchList, object FieldValue = null, bool CanSet = false, bool LiveValue = false)
			{
				List<string> list = SearchList.Where((string x) => x.Contains("::")).ToList();
				List<string> SubFieldList = SearchList.Where((string x) => !x.Contains("::")).ToList();
				bool flag = list.Count == 0;
				if (flag)
				{
					list = SubFieldList;
					SubFieldList = new List<string>();
				}
				int num = list.FindIndex((string x) => x.StartsWith("="));
				if (num == -1)
				{
					return null;
				}
				List<string> range = list.GetRange(0, num);
				string text = list[num];
				string fieldTarget = text.Substring(1, text.Length - 1);
				List<string> range2 = list.GetRange(num + 1, list.Count - num - 1);
				List<string> RawFieldList = range.Union(new <>z__ReadOnlySingleElementList<string>(list[num])).Union(range2).ToList();
				IL_Field iL_Field = (flag ? null : IL_Field.CachedIL_Fields.FirstOrDefault((IL_Field x) => x.RawFieldList != null && (RawFieldList?.SequenceEqual(x.RawFieldList) ?? false)));
				if (iL_Field == null)
				{
					iL_Field = new IL_Field(range, fieldTarget, range2, FieldValue, CanSet, LiveValue, flag);
					if (!flag)
					{
						IL_Field.CachedIL_Fields.Add(iL_Field);
					}
				}
				IL_SubField iL_SubField = (flag ? null : iL_Field.SubFields.FirstOrDefault((IL_SubField x) => SubFieldList.SequenceEqual(x.SubFieldList)));
				if (iL_SubField == null)
				{
					iL_Field.SubFields.Add(iL_SubField = new IL_SubField(iL_Field, SubFieldList, flag));
				}
				return iL_SubField;
			}

			public override int GetHashCode()
			{
				return HashCode.Combine(Field, SubFieldList);
			}
		}

		public class IL_Field : IEquatable<IL_Field>
		{
			public static List<IL_Field> CachedIL_Fields = new List<IL_Field>();

			public List<string> PreFieldLook;

			public object OriginalValue;

			public object FieldValue;

			public Type FieldType;

			public IL_Fragment FieldTarget;

			public List<string> PostFieldLook;

			public List<string> RawFieldList;

			public bool CanSet;

			public bool LiveValue;

			public bool IsLocal;

			public List<IL_SubField> SubFields;

			public IL_Field(List<string> PreFieldLook, string FieldTarget, List<string> PostFieldLook, object FieldValue = null, bool CanSet = false, bool LiveValue = false, bool IsLocal = false)
			{
				this.PreFieldLook = PreFieldLook;
				OriginalValue = FieldValue;
				this.FieldValue = FieldValue;
				FieldType = FieldValue?.GetType();
				this.FieldTarget = new IL_Fragment(FieldTarget);
				this.PostFieldLook = PostFieldLook;
				RawFieldList = PreFieldLook.Union(new <>z__ReadOnlySingleElementList<string>("=" + FieldTarget)).Union(PostFieldLook).ToList();
				this.CanSet = CanSet;
				this.LiveValue = LiveValue;
				SubFields = new List<IL_SubField>(1)
				{
					new IL_SubField(this, new List<string>())
				};
				this.IsLocal = IsLocal;
			}

			public override bool Equals(object obj)
			{
				return obj is IL_Field iL_Field && PreFieldLook.Equals(iL_Field.PreFieldLook) && FieldTarget.Equals(iL_Field.FieldTarget) && PostFieldLook.Equals(iL_Field.PostFieldLook);
			}

			public bool Equals(IL_Field IL_Obj)
			{
				return PreFieldLook.Equals(IL_Obj.PreFieldLook) && FieldTarget.Equals(IL_Obj.FieldTarget);
			}

			public override int GetHashCode()
			{
				return HashCode.Combine(PreFieldLook, FieldTarget, PostFieldLook);
			}
		}

		public class IL_Fragment
		{
			public static Dictionary<string, IL_Fragment> Cached_Fragments = new Dictionary<string, IL_Fragment>();

			public List<string> Raw;

			public List<string> Unorganized;

			public string SpecificTarget;

			public IL_Fragment(string Target)
			{
				Raw = Target.Split(' ').ToList();
				Unorganized = Raw.Where((string x) => !x.Contains("::")).ToList();
				SpecificTarget = Raw.FirstOrDefault((string x) => x.Contains("::"));
			}

			public bool Match(IL_Fragment OpNameSplit)
			{
				return OpNameSplit.SpecificTarget == SpecificTarget || (SpecificTarget != null && OpNameSplit.SpecificTarget != null && SpecificTarget.Contains(OpNameSplit.SpecificTarget) && OpNameSplit.Unorganized.All((string Partial) => Unorganized.FirstOrDefault((string x) => x.Contains(Partial)) != null));
			}

			public override string ToString()
			{
				return GeneralExtensions.Join<string>((IEnumerable<string>)Raw, (Func<string, string>)null, " ");
			}
		}

		public class CachedMethods
		{
			public static string Path = Directory.GetParent(Assembly.GetExecutingAssembly().Location)?.ToString() + "\\methods.LU.cache";

			public List<string> Methods = new List<string>();

			public Dictionary<string, string> Mods = new Dictionary<string, string>();

			public List<string> LUHashes = new List<string>();

			public string GameUUID;

			public string LU_UUID;
		}

		public static BepInPlugin Metadata = MetadataHelper.GetMetadata(typeof(UtilsMod));

		private readonly Harmony HarmonyX = new Harmony("Kyxino-LUv2");

		public static ManualLogSource MLS = Logger.CreateLogSource("LethalUtilitiesV2");

		public List<JsonVarLUFile> LUFiles;

		public static Dictionary<string, ManualLogSource> Loggers = new Dictionary<string, ManualLogSource>();

		public static Dictionary<IL_SubField, List<JsonVarLU>> VariablesLU = new Dictionary<IL_SubField, List<JsonVarLU>>();

		public static MethodInfo ManageField = AccessTools.Method(typeof(UtilsMod), "ManagingField", (Type[])null, (Type[])null);

		public static MethodInfo TypeMethod = AccessTools.Method(typeof(Type), "GetTypeFromHandle", (Type[])null, (Type[])null);

		public static int MethodsChanged = 0;

		public static string TranspileMethodName;

		private void Awake()
		{
			ConfigUtilities.AddAllTypes();
			JsonConvert.DefaultSettings = () => new JsonSerializerSettings
			{
				Converters = new List<JsonConverter>(1) { (JsonConverter)(object)new IL_SubFieldConverter() }
			};
			LUFiles = new List<JsonVarLUFile>();
			string[] files = Directory.GetFiles(Paths.BepInExRootPath, "*.LU.json", SearchOption.AllDirectories);
			foreach (string path in files)
			{
				string text = File.ReadAllText(path);
				JsonVarLUFile jsonVarLUFile = JsonConvert.DeserializeObject<JsonVarLUFile>(text);
				jsonVarLUFile.Hash = Extensions.ToHexadecimalString(MD5.Create().ComputeHash(Encoding.Default.GetBytes(text)));
				LUFiles.Add(jsonVarLUFile);
				string folderName = null;
				string fileName = null;
				string categoryName = null;
				NetworkedConfigSync syncType = NetworkedConfigSync.Unspecified;
				bool? includesRaw = null;
				for (int j = 0; j < jsonVarLUFile.Variables.Count; j++)
				{
					JsonVarLU jsonVarLU = jsonVarLUFile.Variables[j];
					if (jsonVarLUFile.Settings.RolloverFolder)
					{
						JsonVarLU jsonVarLU2 = jsonVarLU;
						folderName = jsonVarLU2.FolderName ?? (jsonVarLU2.FolderName = folderName);
					}
					if (jsonVarLUFile.Settings.RolloverFile)
					{
						JsonVarLU jsonVarLU2 = jsonVarLU;
						fileName = jsonVarLU2.FileName ?? (jsonVarLU2.FileName = fileName);
					}
					if (jsonVarLUFile.Settings.RolloverCategory)
					{
						JsonVarLU jsonVarLU2 = jsonVarLU;
						categoryName = jsonVarLU2.CategoryName ?? (jsonVarLU2.CategoryName = categoryName);
					}
					if (jsonVarLUFile.Settings.RolloverSyncType)
					{
						if (jsonVarLU.SyncType == NetworkedConfigSync.Unspecified)
						{
							jsonVarLU.SyncType = syncType;
						}
						else
						{
							syncType = jsonVarLU.SyncType;
						}
					}
					if (jsonVarLUFile.Settings.RolloverRaw)
					{
						if (!jsonVarLU.IncludesRaw.HasValue)
						{
							jsonVarLU.IncludesRaw = includesRaw;
						}
						else
						{
							includesRaw = jsonVarLU.IncludesRaw;
						}
					}
				}
			}
			LUFiles.Sort((JsonVarLUFile L, JsonVarLUFile N) => L.Settings.Priority.CompareTo(N.Settings.Priority));
			foreach (JsonVarLU item in LUFiles.SelectMany((JsonVarLUFile LUFile) => LUFile.Variables))
			{
				if (item.SearchForValue == null)
				{
					continue;
				}
				item.WaitFor.Add(item.SearchForValue.Field);
				if (!VariablesLU.TryGetValue(item.SearchForValue, out var value))
				{
					VariablesLU.TryAdd(item.SearchForValue, value = new List<JsonVarLU>());
				}
				if (!value.Contains(item))
				{
					value.Add(item);
				}
				if (item.SearchForKey == null)
				{
					continue;
				}
				item.WaitFor.Add(item.SearchForKey.Field);
				if (!VariablesLU.TryGetValue(item.SearchForKey, out var value2))
				{
					VariablesLU.TryAdd(item.SearchForKey, value2 = new List<JsonVarLU>());
				}
				if (!value2.Contains(item))
				{
					value2.Add(item);
				}
				if (item.ValidKeys != null)
				{
					if (!VariablesLU.TryGetValue(item.ValidKeys, out var value3))
					{
						VariablesLU.TryAdd(item.ValidKeys, value3 = new List<JsonVarLU>());
					}
					if (!value3.Contains(item))
					{
						value3.Add(item);
					}
				}
			}
			ApplyChanges();
			MLS.LogInfo((object)"All enabled patches have been executed.");
		}

		public static void Logger(string Name, LogLevel LogLevel, object Data)
		{
		}

		public static void Logger(string Name, object Data, LogLevel LogLevel = 16)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Logger(Name, LogLevel, Data);
		}

		public static object HandleVar(JsonVarLU Var, object ModifyValue)
		{
			ConfigEntry<object> entry = Var.Entry;
			ConfigUtilities.TypeConverterBase converter = entry.EntrySettings.GetConverter();
			if (converter.TypeEnum == ConfigUtilities.TypeConverterEnum.Variable)
			{
				Logger("LoggerVarTest", (LogLevel)2, (object)("Variable? " + Var.FolderName + "." + Var.FileName + "." + Var.CategoryName + "." + Var.VariableName));
				if (converter.KeyType == typeof(LU_EQ))
				{
					return (Var.Entry.Value is LU_EQ lU_EQ) ? lU_EQ.CalcFormula(ModifyValue.ToString()) : null;
				}
				if (converter.KeyType == typeof(string))
				{
					return Var.Entry.Value?.ToString();
				}
				if (converter.KeyType == typeof(bool))
				{
					return Var.Entry.Value;
				}
				return null;
			}
			if (converter.TypeEnum == ConfigUtilities.TypeConverterEnum.Dictionary)
			{
				Logger("LoggerVarTest", (LogLevel)2, (object)("Dictionary? " + Var.FolderName + "." + Var.FileName + "." + Var.CategoryName + "." + Var.VariableName));
				if (converter.ValueType == typeof(LU_EQ))
				{
					object obj = converter.ConvertToHash(entry.Value);
					Dictionary<int, LU_EQ> dictionary = (Dictionary<int, LU_EQ>)obj;
					IL_SubField searchForKey = Var.SearchForKey;
					Logger("HandleVar", (LogLevel)1, (object)$"VALUES: {searchForKey?.Field?.OriginalValue} | {searchForKey?.Field?.FieldValue}");
					object obj2 = searchForKey?.GetSubFieldValue(searchForKey?.Field?.OriginalValue);
					int? num = obj2?.GetHashCode();
					if (!num.HasValue)
					{
						return null;
					}
					List<object> usedKeys = entry.EntrySettings.UsedKeys;
					if (true && !usedKeys.Contains(obj2))
					{
						usedKeys.Add(obj2);
						entry.ConfigFile.Save();
					}
					LU_EQ value;
					LU_EQ lU_EQ2 = (dictionary.TryGetValue(num.Value, out value) ? value : LU_EQ.Default);
					Logger("HandleVar", (LogLevel)1, (object)$"HASH ({num}:{lU_EQ2.Formula}) | x = {ModifyValue}");
					return lU_EQ2.CalcFormula(ModifyValue.ToString());
				}
			}
			return null;
		}

		public static object ManagingField(object Field, int LoggedSubField_Hash, Type FieldType, bool IsSetting)
		{
			if (!IL_SubField.HashChecks.TryGetValue(LoggedSubField_Hash, out var value))
			{
				return Field;
			}
			IL_Field iL_Field = value?.Field;
			IL_Fragment iL_Fragment = iL_Field?.FieldTarget;
			Logger("ManagingField", (LogLevel)8, (object)"STARTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT");
			Logger("ManagingField", (LogLevel)16, (object)(IsSetting ? "Setting?" : "Getting?"));
			Logger("ManagingField", (LogLevel)1, (object)string.Format("{0} FIELD | Name: {1} | Value: {2} | Type: {3} | IsSetting: {4}", IsSetting ? "SETTING" : "GETTING", iL_Fragment?.ToString() ?? "N/A", Field, FieldType, IsSetting));
			if (!iL_Field.LiveValue)
			{
				iL_Field.LiveValue = true;
				iL_Field.OriginalValue = Field;
			}
			iL_Field.FieldValue = Field;
			object obj = (iL_Field.IsLocal ? Field : iL_Field.OriginalValue);
			value.SubFieldType = (value.SubFieldValue = value.GetSubFieldValue(obj)).GetType();
			if (!VariablesLU.TryGetValue(value, out var value2))
			{
				return Field;
			}
			Logger("ManagingField", (LogLevel)1, (object)string.Format("{0} {1}", iL_Fragment, IsSetting ? "SET" : "GET"));
			bool flag = false;
			object obj2 = obj;
			Logger("ManagingField", (LogLevel)1, (object)$"Pre-Value: {obj2.Val()}:({value.SubFieldType}) | {Field} ({Field.GetType()})");
			foreach (JsonVarLU item in value2)
			{
				Logger("ManagingField", (LogLevel)1, (object)string.Format("InList: {0}.{1} | {2} | {3}:{4}", item.CategoryName, item.VariableName, item.WaitFor.Count, item.SearchForKey?.Field?.FieldTarget?.ToString() ?? "N/A", item.SearchForValue?.Field?.FieldTarget?.ToString() ?? "N/A"));
				if (item.WaitFor.Contains(iL_Field))
				{
					item.WaitFor.Remove(iL_Field);
				}
				if (item.ValidKeys != null)
				{
					List<object> usedKeys = item.UsedKeys;
					if (usedKeys != null)
					{
						object subFieldValue = item.ValidKeys.GetSubFieldValue(item.ValidKeys.Field?.FieldValue);
						if (subFieldValue != null && !usedKeys.Contains(subFieldValue))
						{
							usedKeys.Add(subFieldValue);
							item.Entry?.ConfigFile?.Save();
						}
					}
				}
				if (item.WaitFor.Count <= 0)
				{
					item.SaveToFile();
					if (item.SearchForValue.Field.FieldTarget == iL_Field.FieldTarget && item.IsVarEnabled())
					{
						obj2 = HandleVar(item, obj2);
						flag = true;
						Logger("ManagingField", (LogLevel)1, (object)("Cur-Value: " + obj2.Val()));
					}
				}
			}
			if (!flag)
			{
				return Field;
			}
			Logger("ManagingField", (LogLevel)1, (object)$"Value ({iL_Fragment}): {obj2.Val()} | {iL_Field.FieldValue.Val()} : {value.SubFieldValue.Val()}");
			Logger("ManagingField", (LogLevel)1, (object)("Post1?: " + obj2.Val()));
			obj2 = obj2.ToString();
			if (value.SubFieldType == typeof(int))
			{
				obj2 = (int.TryParse((string)obj2, out var result) ? ((object)result) : null);
			}
			else if (value.SubFieldType == typeof(float))
			{
				obj2 = (float.TryParse((string)obj2, out var result2) ? ((object)result2) : null);
			}
			else if (value.SubFieldType == typeof(double))
			{
				obj2 = (double.TryParse((string)obj2, out var result3) ? ((object)result3) : null);
			}
			Logger("ManagingField", (LogLevel)1, (object)("Post2?: " + obj2.Val()));
			Logger("ManagingField", (LogLevel)1, (object)("Post-Value: " + obj2.Val() + " | " + iL_Field.FieldValue.Val() + " : " + value.SubFieldValue.Val()));
			Logger("ManagingField", (LogLevel)8, (object)"ENDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD");
			if (IsSetting)
			{
				value.SetSubFieldValue(obj, obj2);
			}
			object obj3 = ((value.SubFieldList.Count == 0) ? obj2 : Field);
			Logger("ManagingField", (LogLevel)8, (object)("RESULT " + obj3.Val()));
			return obj3;
		}

		public static KeyValuePair<IL_SubField, List<JsonVarLU>> GetVariable(List<CodeInstruction> InstructionList, int i, string SpecificMethod)
		{
			IL_Fragment OpNameSplit = new IL_Fragment(((object)InstructionList[i]).ToString());
			foreach (KeyValuePair<IL_SubField, List<JsonVarLU>> item in VariablesLU.Where((KeyValuePair<IL_SubField, List<JsonVarLU>> x) => OpNameSplit.Match(x.Key.Field.FieldTarget) && x.Value.FirstOrDefault((JsonVarLU y) => y.SearchAt == null || y.SearchAt.FirstOrDefault((string z) => SpecificMethod.Contains(z)) != null) != null))
			{
				bool flag = true;
				IL_Field field = item.Key.Field;
				List<string> preFieldLook = field.PreFieldLook;
				List<string> postFieldLook = field.PostFieldLook;
				for (int j = 0; j < preFieldLook.Count && flag; j++)
				{
					string pattern = preFieldLook[j];
					int num = i + (j - preFieldLook.Count);
					if (!(flag = 0 <= num && num < InstructionList.Count))
					{
						break;
					}
					CodeInstruction val = InstructionList[num];
					flag = Regex.IsMatch(((object)val).ToString(), pattern) || Regex.IsMatch(val.opcode.ToString(), pattern);
				}
				if (!flag)
				{
					continue;
				}
				for (int k = 0; k < postFieldLook.Count && flag; k++)
				{
					string pattern2 = postFieldLook[k];
					int num2 = i + k + 1;
					if (!(flag = 0 <= num2 && num2 < InstructionList.Count))
					{
						break;
					}
					CodeInstruction val2 = InstructionList[num2];
					flag = Regex.IsMatch(((object)val2).ToString(), pattern2) || Regex.IsMatch(val2.opcode.ToString(), pattern2);
				}
				if (!flag)
				{
					continue;
				}
				return item;
			}
			return default(KeyValuePair<IL_SubField, List<JsonVarLU>>);
		}

		private static IEnumerable<CodeInstruction> DecorateInstructions(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Expected O, but got Unknown
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>();
			bool flag = false;
			List<CodeInstruction> list2 = instructions.ToList();
			for (int i = 0; i < list2.Count; i++)
			{
				CodeInstruction val = list2[i];
				bool flag2 = val.opcode == OpCodes.Stfld || val.opcode == OpCodes.Stsfld;
				bool flag3 = val.opcode == OpCodes.Call;
				bool flag4 = val.opcode == OpCodes.Ldc_R4;
				if (!flag2 && !flag3 && !flag4 && val.opcode != OpCodes.Ldfld && val.opcode != OpCodes.Ldsfld)
				{
					list.Add(val);
					continue;
				}
				KeyValuePair<IL_SubField, List<JsonVarLU>> variable = GetVariable(list2, i, TranspileMethodName);
				if (variable.Value == null)
				{
					list.Add(val);
					continue;
				}
				Type type = (flag4 ? val.operand.GetType() : (flag3 ? ((MethodInfo)val.operand).ReturnType : ((FieldInfo)val.operand).FieldType));
				flag = true;
				if (!flag2)
				{
					list.Add(val);
				}
				IL_Field field = variable.Key.Field;
				field.CanSet |= flag2;
				field.FieldType = type;
				list.Add(new CodeInstruction(OpCodes.Box, (object)type));
				list.Add(new CodeInstruction(OpCodes.Ldc_I4, (object)variable.Key.GetHashCode()));
				list.Add(new CodeInstruction(OpCodes.Ldtoken, (object)type));
				list.Add(new CodeInstruction(OpCodes.Call, (object)TypeMethod));
				list.Add(new CodeInstruction(OpCodes.Ldc_I4, (object)(flag2 ? 1 : 0)));
				list.Add(new CodeInstruction(OpCodes.Call, (object)ManageField));
				list.Add(new CodeInstruction(OpCodes.Unbox_Any, (object)type));
				if (flag2)
				{
					list.Add(val);
				}
			}
			if (flag)
			{
				MethodsChanged++;
			}
			IEnumerable<CodeInstruction> result;
			if (!flag)
			{
				result = instructions;
			}
			else
			{
				IEnumerable<CodeInstruction> enumerable = list;
				result = enumerable;
			}
			return result;
		}

		public void ApplyChanges()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			string text = Assembly.GetExecutingAssembly().ManifestModule.ModuleVersionId.ToString();
			HarmonyMethod val = new HarmonyMethod(((object)this).GetType(), "DecorateInstructions", (Type[])null);
			Dictionary<string, PluginInfo> pluginInfos = Chainloader.PluginInfos;
			pluginInfos.Remove("com.sinai.unityexplorer");
			pluginInfos.Remove(HarmonyX.Id);
			Stopwatch stopwatch = Stopwatch.StartNew();
			CachedMethods Cached = JsonConvert.DeserializeObject<CachedMethods>(File.Exists(CachedMethods.Path) ? File.ReadAllText(CachedMethods.Path) : "{}");
			bool flag = true;
			foreach (JsonVarLUFile lUFile in LUFiles)
			{
				flag &= Cached.LUHashes.Contains(lUFile.Hash);
				if (!flag)
				{
					break;
				}
			}
			if (flag)
			{
				flag &= text == Cached.LU_UUID;
			}
			CachedMethods cachedMethods = new CachedMethods();
			cachedMethods.LU_UUID = text;
			cachedMethods.LUHashes = LUFiles.Select((JsonVarLUFile x) => x.Hash).ToList();
			IEnumerable<MethodInfo> first = Array.Empty<MethodInfo>();
			foreach (PluginInfo item in pluginInfos.Select((KeyValuePair<string, PluginInfo> x) => x.Value))
			{
				if (!((Object)(object)item.Instance == (Object)null))
				{
					Assembly assembly = Assembly.GetAssembly(((object)item.Instance).GetType());
					IEnumerable<MethodInfo> enumerable = ((IEnumerable<Type>)AccessTools.GetTypesFromAssembly(assembly)).SelectMany((Func<Type, IEnumerable<MethodInfo>>)AccessTools.GetDeclaredMethods).Where(FilterUnpatchable);
					cachedMethods.Mods.TryAdd(item.Metadata.GUID, assembly.ManifestModule.ModuleVersionId.ToString());
					if (flag && Cached.Mods.TryGetValue(item.Metadata.GUID, out var value) && value == assembly.ManifestModule.ModuleVersionId.ToString())
					{
						enumerable = enumerable.Where(FilterCached);
					}
					first = first.Union(enumerable);
				}
			}
			Assembly assembly2 = Assembly.GetAssembly(typeof(Item));
			IEnumerable<MethodInfo> enumerable2 = ((IEnumerable<Type>)AccessTools.GetTypesFromAssembly(assembly2)).SelectMany((Func<Type, IEnumerable<MethodInfo>>)AccessTools.GetDeclaredMethods).Where(FilterUnpatchable);
			first = ((!((cachedMethods.GameUUID = assembly2.ManifestModule.ModuleVersionId.ToString()) == Cached.GameUUID && flag)) ? first.Union(enumerable2) : first.Union(enumerable2.Where(FilterCached)));
			MLS.LogWarning((object)$"Attempting to patch up to {first.Count()} methods.");
			foreach (MethodInfo item2 in first)
			{
				int methodsChanged = MethodsChanged;
				try
				{
					TranspileMethodName = $"{item2.DeclaringType}::{item2.Name}";
					HarmonyX.Patch((MethodBase)item2, (HarmonyMethod)null, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null);
					if (MethodsChanged - methodsChanged == 1)
					{
						cachedMethods.Methods.Add($"{item2.ReturnType} {TranspileMethodName}");
					}
				}
				catch (Exception ex)
				{
					MLS.LogFatal((object)string.Format("Failed to patch {0} ({1}) with error: {2}\n{3}", item2, (MethodsChanged - methodsChanged == 1) ? "CHANGED" : "UNCHANGED", ex.Message, ex.GetBaseException()));
				}
			}
			File.WriteAllText(CachedMethods.Path, JsonConvert.SerializeObject((object)cachedMethods));
			MLS.LogMessage((object)$"Done adjusting {MethodsChanged}/{first.Count()} methods. Time: {stopwatch.Elapsed}");
			bool FilterCached(MethodInfo x)
			{
				return Cached.Methods.Contains($"{x.ReturnType} {x.DeclaringType}::{x.Name}");
			}
			static bool FilterUnpatchable(MethodInfo x)
			{
				return !x.ContainsGenericParameters && !x.IsGenericMethod && MethodBaseExtensions.HasMethodBody((MethodBase)x);
			}
		}
	}
	public class JsonVarLU
	{
		[JsonProperty("SearchAt")]
		public List<string> SearchAt;

		[JsonProperty("SearchForValue")]
		public UtilsMod.IL_SubField SearchForValue;

		[JsonProperty("SearchForKey")]
		public UtilsMod.IL_SubField SearchForKey;

		[JsonProperty("ValidKeys")]
		public UtilsMod.IL_SubField ValidKeys;

		[JsonProperty("FolderName")]
		public string FolderName;

		[JsonProperty("FileName")]
		public string FileName;

		[JsonProperty("CategoryName")]
		public string CategoryName;

		[JsonProperty("VariableName")]
		public string VariableName;

		[JsonProperty("Description")]
		public string Description;

		[JsonProperty("SectionOrder")]
		public int SectionOrder;

		[JsonProperty("SyncType")]
		public NetworkedConfigSync SyncType;

		[JsonProperty("IsVarList")]
		public bool IsVarList;

		[JsonProperty("IncludesRaw")]
		public bool? IncludesRaw;

		[JsonProperty("IncludeAccessedKeys")]
		public bool IncludeAccessedKeys;

		public ConfigEntry<object> Entry;

		public List<object> UsedKeys = new List<object>();

		public List<UtilsMod.IL_Field> WaitFor = new List<UtilsMod.IL_Field>();

		public ConfigFile VarConfigFile;

		public bool Saved = false;

		public static Dictionary<string, ConfigFile> Files = new Dictionary<string, ConfigFile>();

		public bool IsVarEnabled()
		{
			switch (VarConfigFile.ConfigEnabledVar.Value)
			{
			case LoadSettings.ApplyConfig:
				return true;
			case LoadSettings.Disabled:
				return false;
			default:
			{
				List<string> value = VarConfigFile.LoadSettingsVar.Value;
				return value.Contains(CategoryName) || value.Contains(VariableName);
			}
			}
		}

		public void SaveToFile()
		{
			if (!Saved)
			{
				Saved = true;
				UtilsMod.IL_Field iL_Field = SearchForValue?.Field;
				UtilsMod.IL_Field iL_Field2 = SearchForKey?.Field;
				Type type = SearchForKey?.SubFieldType;
				object defaultValue = SearchForValue?.GetSubFieldValue(SearchForValue.Field.OriginalValue);
				Type type2 = SearchForValue.SubFieldType;
				if (type2 == typeof(int) || type2 == typeof(float) || type2 == typeof(double))
				{
					type2 = typeof(LU_EQ);
					defaultValue = new LU_EQ();
				}
				ConfigEntrySettings configEntrySettings = new ConfigEntrySettings(null, CategoryName, VariableName)
				{
					KeyType = type,
					ValueType = type2,
					Description = Description,
					SectionOrder = SectionOrder,
					UsedKeys = UsedKeys,
					Rule = (IsVarList ? LU_Direction.DictionaryKey : LU_Direction.None),
					IncludeAccessedKeys = IncludeAccessedKeys,
					SyncType = SyncType
				};
				ConfigUtilities.TypeConverterBase converter = configEntrySettings.GetConverter();
				if (IsVarList && converter.GetDefaultValue != null)
				{
					defaultValue = converter.GetDefaultValue(type, type2);
				}
				string folderName = FolderName;
				string fileName = FileName;
				string text = Paths.BepInExRootPath + "\\LethalUtilities" + ((folderName != null) ? ("\\" + folderName) : "") + "\\" + fileName + ".cfg";
				if (!Files.TryGetValue(text, out VarConfigFile))
				{
					Files.TryAdd(text, VarConfigFile = new ConfigFile(text, saveOnInit: true, UtilsMod.Metadata));
					VarConfigFile.ConfigEnabledVar = VarConfigFile.Bind(new ConfigEntrySettings(null, "ACTIVE SETTINGS", "ConfigEnabled")
					{
						ValueType = typeof(LoadSettings),
						SectionOrder = -999,
						Rule = LU_Direction.None,
						SyncType = NetworkedConfigSync.SyncWithHost
					}, LoadSettings.OnlyLoadSettings);
					VarConfigFile.LoadSettingsVar = VarConfigFile.Bind(new ConfigEntrySettings(null, "ACTIVE SETTINGS", "LoadSettings")
					{
						ValueType = typeof(string),
						SectionOrder = -999,
						Rule = LU_Direction.DictionaryValue,
						SyncType = NetworkedConfigSync.SyncWithHost
					}, new List<string>());
				}
				Entry = VarConfigFile.Bind(configEntrySettings, defaultValue, (!IncludesRaw.GetValueOrDefault()) ? null : SearchForValue?.GetSubFieldValue(SearchForValue.Field.OriginalValue)?.ToString());
			}
		}
	}
	public class JsonVarLUSettings
	{
		[JsonProperty("Priority")]
		public int Priority;

		[JsonProperty("RolloverFolder")]
		public bool RolloverFolder;

		[JsonProperty("RolloverFile")]
		public bool RolloverFile;

		[JsonProperty("RolloverCategory")]
		public bool RolloverCategory;

		[JsonProperty("RolloverSyncType")]
		public bool RolloverSyncType;

		[JsonProperty("RolloverRaw")]
		public bool RolloverRaw;
	}
	public class JsonVarLUFile
	{
		[JsonProperty("Settings")]
		public JsonVarLUSettings Settings;

		[JsonProperty("Variables")]
		public List<JsonVarLU> Variables;

		public string Hash;
	}
	public class LU_EQ
	{
		public static LU_EQ Default = new LU_EQ();

		public string Formula;

		private static readonly List<List<string>> IDK_TableThing = new List<List<string>>(2)
		{
			new List<string>(1) { "^" },
			new List<string>(2) { "*", "/" }
		};

		public LU_EQ(string StringFormula = "1x")
		{
			Formula = StringFormula;
			base..ctor();
		}

		public string CalcFormula(string Value)
		{
			List<string> list = Convert(Formula);
			int num = 0;
			while (true)
			{
				num++;
				string s = ((num > 1) ? list.ElementAtOrDefault(num - 2) : null);
				string s2 = ((num > 0) ? list.ElementAtOrDefault(num - 1) : null);
				string text = list.ElementAtOrDefault(num);
				UtilsMod.Logger("LU_EQ", (LogLevel)4, (object)string.Join(" ", list));
				if (text == null)
				{
					break;
				}
				float.TryParse(s, out var result);
				float.TryParse(s2, out var result2);
				switch (text)
				{
				case "+":
					list.RemoveAt(num--);
					list.RemoveAt(num--);
					list[num] = (result + result2).ToString();
					break;
				case "-":
					list.RemoveAt(num--);
					list.RemoveAt(num--);
					list[num] = (result - result2).ToString();
					break;
				case "*":
					list.RemoveAt(num--);
					list.RemoveAt(num--);
					list[num] = (result * result2).ToString();
					break;
				case "/":
					list.RemoveAt(num--);
					list.RemoveAt(num--);
					list[num] = (result / result2).ToString();
					break;
				case "^":
					list.RemoveAt(num--);
					list.RemoveAt(num--);
					list[num] = MathF.Pow(result, result2).ToString();
					break;
				case "%":
					list.RemoveAt(num--);
					list.RemoveAt(num--);
					list[num] = (result % result2).ToString();
					break;
				case ">":
					list.RemoveAt(num--);
					list.RemoveAt(num--);
					list[num] = ((result > result2) ? "1" : "0");
					break;
				case "<":
					list.RemoveAt(num--);
					list.RemoveAt(num--);
					list[num] = ((result < result2) ? "1" : "0");
					break;
				case "x":
					list[num] = Value;
					break;
				}
			}
			return list.FirstOrDefault();
		}

		private static void IDK(List<object> Parent)
		{
			foreach (List<object> item3 in Parent.Where((object ObjectTesting) => ObjectTesting is List<object>).Cast<List<object>>())
			{
				IDK(item3);
				foreach (List<string> item4 in IDK_TableThing)
				{
					int num = 0;
					while (true)
					{
						object item = item3[num];
						num++;
						if (num >= item3.Count)
						{
							break;
						}
						object obj = item3[num];
						if (item4.Contains(obj.ToString()))
						{
							item3.RemoveAt(num);
							object item2 = item3[num];
							item3.RemoveAt(num);
							item3[--num] = new List<object> { item, obj, item2 };
						}
					}
				}
			}
		}

		private static void IDK2(List<string> Stack, List<object> Parent)
		{
			bool flag = false;
			for (int i = 0; i < Parent.Count; i += 2)
			{
				object obj = Parent[i];
				if (!flag)
				{
					if (obj is List<object>)
					{
						List<string> list = new List<string>();
						IDK2(list, obj as List<object>);
						foreach (string item in list)
						{
							Stack.Add(item);
						}
					}
					else
					{
						Stack.Add(obj.ToString());
					}
					flag = true;
				}
				object obj2 = Parent.ElementAtOrDefault(i + 1);
				object obj3 = Parent.ElementAtOrDefault(i + 2);
				if (obj2 == null)
				{
					continue;
				}
				if (obj3 is List<object>)
				{
					List<string> list2 = new List<string>();
					IDK2(list2, obj3 as List<object>);
					foreach (string item2 in list2)
					{
						Stack.Add(item2);
					}
				}
				else
				{
					Stack.Add(obj3.ToString());
				}
				Stack.Add(obj2.ToString());
			}
		}

		public static List<string> Convert(string Value)
		{
			UtilsMod.Logger("LU_EQ", (LogLevel)2, (object)("LU_EQ-Convert: " + Value));
			Value = Regex.Replace(Value, "\\s", "");
			Value = Regex.Replace(Value, "([\\)])([\\(])", "$1*$2");
			Value = Regex.Replace(Value, "([^\\+\\-\\*\\/\\^][\\(\\)])(\\d*x)", "$1*$2");
			Value = Regex.Replace(Value, "(\\d*x)([\\(\\)][^\\+\\-\\*\\/\\^])", "$1*$2");
			Value = Regex.Replace(Value, "(\\d+)(x)", "$1*$2");
			Value = Regex.Replace(Value, "(x)(\\d+)", "$1*$2");
			UtilsMod.Logger("LU_EQ", (LogLevel)2, (object)("LU_EQ-Convert: " + Value));
			List<string> list = new List<string>();
			List<object> list2 = new List<object>();
			Match match = Regex.Match(Value, "(\\-?[\\dx\\.]+)", RegexOptions.Multiline);
			Match match2 = Regex.Match(Value, "([\\+\\-\\*\\/\\^\\%])(\\-?[\\dx\\.]+)", RegexOptions.Multiline);
			Match match3 = match;
			for (int i = 0; i < Value.Length; i++)
			{
				char c = Value[i];
				switch (c)
				{
				case '(':
				{
					List<object> list3 = new List<object> { list2 };
					list2.Add(list3);
					list2 = list3;
					continue;
				}
				case ')':
				{
					List<object> list4 = list2;
					list2 = (List<object>)list4[0];
					list4.RemoveAt(0);
					if (list4.Count == 1)
					{
						List<object> list5 = list2;
						list5[list5.Count - 1] = list4[0];
					}
					continue;
				}
				}
				string text = match3.Groups.ElementAtOrDefault<Group>(1)?.Value;
				string text2 = match3.Groups.ElementAtOrDefault<Group>(2)?.Value;
				int index = match3.Index;
				int num = index + match3.Length - 1;
				if (text != null && i == index)
				{
					i = num;
					list2.Add(text);
					if (text2 != null)
					{
						list2.Add(text2);
					}
					match2 = ((match3 == match) ? match2 : match2.NextMatch());
					match3 = match2;
				}
				else
				{
					list2.Add(c);
				}
			}
			IDK(new List<object>(1) { list2 });
			IDK2(list, list2);
			return list;
		}
	}
}
namespace LethalUtilities.Preloader
{
	internal class Plugin
	{
	}
}
namespace LethalUtilities.Configuration
{
	public enum LU_Direction
	{
		None,
		DictionaryKey,
		DictionaryValue
	}
	public enum NetworkedConfigSync
	{
		Unspecified,
		HostOnly,
		ClientOnly,
		SyncWithHost
	}
	public enum LoadSettings
	{
		ApplyConfig,
		OnlyLoadSettings,
		Disabled
	}
	public class ConfigUtilities
	{
		public enum TypeConverterEnum
		{
			Unknown,
			Variable,
			List,
			Dictionary
		}

		public class TypeConverterBase
		{
			public Type KeyType;

			public Type ValueType;

			public Func<object, Type, Type, string> ConvertToString;

			public Func<string, Type, Type, object> ConvertToObject;

			public Func<object, object> ConvertToHash;

			public Func<Type, Type, object> GetDefaultValue;

			public TypeConverterEnum TypeEnum = TypeConverterEnum.Unknown;
		}

		public class DictTypeConverter<KeyT, ValueT> : TypeConverterBase
		{
			public Func<object, Type, Type, string> ConvertToString_Default = delegate(object input, Type keyType, Type valueType)
			{
				Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
				foreach (KeyValuePair<KeyT, ValueT> item in input as Dictionary<KeyT, ValueT>)
				{
					dictionary2.TryAdd(TomlTypeConverter.ConvertToString((object)item.Key, keyType), TomlTypeConverter.ConvertToString((object)item.Value, valueType));
				}
				return JsonConvert.SerializeObject((object)dictionary2);
			};

			public Func<string, Type, Type, object> ConvertToObject_Default = delegate(string input, Type keyType, Type valueType)
			{
				Dictionary<KeyT, ValueT> dictionary = new Dictionary<KeyT, ValueT>();
				foreach (KeyValuePair<string, string> item2 in JsonConvert.DeserializeObject<Dictionary<string, string>>(input))
				{
					dictionary.TryAdd((KeyT)TomlTypeConverter.ConvertToValue(item2.Key, keyType), (ValueT)TomlTypeConverter.ConvertToValue(item2.Value, valueType));
				}
				return dictionary;
			};

			public Func<object, object> ConvertToHash_Default = (object input) => ((Dictionary<KeyT, ValueT>)input).ToDictionary((KeyValuePair<KeyT, ValueT> x) => x.Key.GetHashCode(), (KeyValuePair<KeyT, ValueT> x) => x.Value);

			public ValueT GetValueFromKey(Dictionary<KeyT, ValueT> Dict, KeyT Key)
			{
				return Dict.GetValueOrDefault(Key);
			}

			public ValueT GetValueFromKey(object Dict, KeyT Key)
			{
				return GetValueFromKey((Dictionary<KeyT, ValueT>)Dict, Key);
			}

			public DictTypeConverter(Func<object, Type, Type, string> ConvertToString = null, Func<string, Type, Type, object> ConvertToObject = null, Func<Type, Type, object> GetDefaultValue = null)
			{
				KeyType = typeof(KeyT);
				ValueType = typeof(ValueT);
				base.ConvertToString = ConvertToString ?? ConvertToString_Default;
				base.ConvertToObject = ConvertToObject ?? ConvertToObject_Default;
				base.GetDefaultValue = GetDefaultValue;
				ConvertToHash = ConvertToHash_Default;
				TypeEnum = TypeConverterEnum.Dictionary;
			}
		}

		public class ListTypeConverter<ValueT> : TypeConverterBase
		{
			public Func<object, Type, Type, string> ConvertToString_Default = (object input, Type keyType, Type valueType) => JsonConvert.SerializeObject((object)(input as List<ValueT>).Select((ValueT E) => TomlTypeConverter.ConvertToString((object)E, valueType)));

			public Func<string, Type, Type, object> ConvertToObject_Default = (string input, Type keyType, Type valueType) => from E in JsonConvert.DeserializeObject<List<string>>(input)
				select (ValueT)TomlTypeConverter.ConvertToValue(E, valueType);

			public ListTypeConverter(Func<object, Type, Type, string> ConvertToString = null, Func<string, Type, Type, object> ConvertToObject = null, Func<Type, Type, object> GetDefaultValue = null)
			{
				ValueType = typeof(ValueT);
				base.ConvertToString = ConvertToString ?? ConvertToString_Default;
				base.ConvertToObject = ConvertToObject ?? ConvertToObject_Default;
				base.GetDefaultValue = GetDefaultValue;
				TypeEnum = TypeConverterEnum.List;
			}
		}

		public class TypeConverter<T> : TypeConverterBase
		{
			public Func<object, Type, Type, string> ConvertToString_Default = (object input, Type keyType, Type valueType) => TomlTypeConverter.ConvertToString(input, keyType);

			public Func<string, Type, Type, object> ConvertToObject_Default = (string input, Type keyType, Type valueType) => (T)TomlTypeConverter.ConvertToValue(input, keyType);

			public TypeConverter(Func<object, Type, Type, string> ConvertToString = null, Func<string, Type, Type, object> ConvertToObject = null, Func<Type, Type, object> GetDefaultValue = null)
			{
				KeyType = typeof(T);
				base.ConvertToString = ConvertToString ?? ConvertToString_Default;
				base.ConvertToObject = ConvertToObject ?? ConvertToObject_Default;
				base.GetDefaultValue = GetDefaultValue;
				TypeEnum = TypeConverterEnum.Variable;
			}
		}

		public static bool AddedTypes = false;

		public static List<TypeConverterBase> CustomDictTypeConverters = new List<TypeConverterBase>(9)
		{
			new DictTypeConverter<Enum, LU_EQ>(delegate(object input, Type keyType, Type valueType)
			{
				Dictionary<string, string> dictionary10 = new Dictionary<string, string>();
				foreach (KeyValuePair<Enum, LU_EQ> item in input as Dictionary<Enum, LU_EQ>)
				{
					dictionary10.TryAdd(item.Key.ToString(), item.Value.Formula);
				}
				return JsonConvert.SerializeObject((object)dictionary10);
			}, delegate(string input, Type keyType, Type valueType)
			{
				Dictionary<Enum, LU_EQ> dictionary9 = new Dictionary<Enum, LU_EQ>();
				foreach (KeyValuePair<string, string> item2 in JsonConvert.DeserializeObject<Dictionary<string, string>>(input))
				{
					if (Enum.TryParse(keyType, item2.Key, ignoreCase: true, out object result12))
					{
						dictionary9.TryAdd((Enum)result12, new LU_EQ(item2.Value));
					}
				}
				return dictionary9;
			}, delegate(Type keyType, Type valueType)
			{
				Dictionary<Enum, LU_EQ> dictionary8 = new Dictionary<Enum, LU_EQ>();
				foreach (Enum value2 in Enum.GetValues(keyType))
				{
					dictionary8.Add(value2, new LU_EQ());
				}
				return dictionary8;
			}),
			new DictTypeConverter<string, LU_EQ>(delegate(object input, Type keyType, Type valueType)
			{
				Dictionary<string, string> dictionary7 = new Dictionary<string, string>();
				foreach (KeyValuePair<string, LU_EQ> item3 in input as Dictionary<string, LU_EQ>)
				{
					dictionary7.TryAdd(item3.Key, item3.Value?.Formula);
				}
				return JsonConvert.SerializeObject((object)dictionary7);
			}, delegate(string input, Type keyType, Type valueType)
			{
				Dictionary<string, LU_EQ> dictionary6 = new Dictionary<string, LU_EQ>();
				foreach (KeyValuePair<string, string> item4 in JsonConvert.DeserializeObject<Dictionary<string, string>>(input))
				{
					dictionary6.TryAdd(item4.Key, new LU_EQ(item4.Value));
				}
				return dictionary6;
			}, (Type keyType, Type valueType) => new Dictionary<string, LU_EQ>()),
			new DictTypeConverter<string, List<string>>(),
			new DictTypeConverter<string, string>(null, null, (Type keyType, Type valueType) => new Dictionary<string, LU_EQ>()),
			new ListTypeConverter<string>((object input, Type keyType, Type valueType) => JsonConvert.SerializeObject((object)(input as List<string>)), (string input, Type keyType, Type valueType) => JsonConvert.DeserializeObject<List<string>>(input), (Type keyType, Type valueType) => new List<string>()),
			new TypeConverter<Enum>((object input, Type keyType, Type valueType) => input.ToString(), (string input, Type keyType, Type valueType) => Enum.TryParse(valueType, input, out object result11) ? result11 : null),
			new TypeConverter<string>(),
			new TypeConverter<bool>((object input, Type keyType, Type valueType) => input.ToString(), (string input, Type keyType, Type valueType) => bool.TryParse(input, out var result10) ? ((object)result10) : null, (Type keyType, Type valueType) => null),
			new TypeConverter<LU_EQ>((object input, Type keyType, Type valueType) => ((LU_EQ)input).Formula, (string input, Type keyType, Type valueType) => new LU_EQ(input), (Type keyType, Type valueType) => new LU_EQ())
		};

		public static readonly Dictionary<Type, TypeConverter> CustomTypeConverters = new Dictionary<Type, TypeConverter>
		{
			[typeof(Dictionary<string, List<string>>)] = new TypeConverter
			{
				ConvertToObject = (string input, Type type) => JsonConvert.DeserializeObject<Dictionary<string, List<string>>>(input),
				ConvertToString = (object input, Type type) => JsonConvert.SerializeObject(input)
			},
			[typeof(Dictionary<string, string>)] = new TypeConverter
			{
				ConvertToObject = (string input, Type type) => JsonConvert.DeserializeObject<Dictionary<string, string>>(input),
				ConvertToString = (object input, Type type) => JsonConvert.SerializeObject(input)
			},
			[typeof(List<string>)] = new TypeConverter
			{
				ConvertToObject = (string input, Type type) => JsonConvert.DeserializeObject<List<string>>(input),
				ConvertToString = (object input, Type type) => JsonConvert.SerializeObject(input)
			},
			[typeof(LU_EQ)] = new TypeConverter
			{
				ConvertToObject = (string input, Type type) => new LU_EQ(input),
				ConvertToString = (object input, Type type) => ((LU_EQ)input).Formula
			},
			[typeof(AnimationCurve)] = new TypeConverter
			{
				ConvertToObject = delegate(string input, Type type)
				{
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					//IL_001b: Expected O, but got Unknown
					//IL_0047: Unknown result type (might be due to invalid IL or missing references)
					//IL_004d: Expected O, but got Unknown
					//IL_031d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0323: Expected O, but got Unknown
					//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
					//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
					//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
					//IL_0300: Unknown result type (might be due to invalid IL or missing references)
					if (type != typeof(AnimationCurve))
					{
						return (object)new AnimationCurve();
					}
					string[] array4 = Regex.Replace(input, "[\\s%()%[\\]]+", "").Split(',');
					if (string.IsNullOrEmpty(array4[0]))
					{
						return (object)new AnimationCurve();
					}
					Keyframe[] array5 = (Keyframe[])(object)new Keyframe[array4.Length];
					Keyframe val11 = default(Keyframe);
					for (int l = 0; l < array5.Length; l++)
					{
						string[] array6 = array4[l].Split(';');
						string[] array7 = ((array6 != null && array6.Length >= 1) ? ((array6 != null) ? array6[0]?.Split(':') : null) : null);
						string[] array8 = ((array6 != null && array6.Length >= 2) ? ((array6 != null) ? array6[1]?.Split('|') : null) : null);
						string[] array9 = ((array6 != null && array6.Length >= 3) ? ((array6 != null) ? array6[2]?.Split(':') : null) : null);
						string[] array10 = ((array9 != null && array9.Length >= 2) ? ((array9 != null) ? array9[1] : null) : ((array9 != null) ? array9[0] : null))?.Split('|');
						float result3 = (float.TryParse(((array7 != null) ? array7[0] : null) ?? "0", NumberStyles.Float, new CultureInfo("en-US"), out result3) ? result3 : 0f);
						float result4 = (float.TryParse((array7 != null && array7.Length >= 2) ? ((array7 != null) ? array7[1] : null) : "0", NumberStyles.Float, new CultureInfo("en-US"), out result4) ? result4 : 0f);
						float result5 = (float.TryParse(((array8 != null) ? array8[0] : null) ?? "0", NumberStyles.Float, new CultureInfo("en-US"), out result5) ? result5 : 0f);
						float result6 = (float.TryParse((array8 != null && array8.Length >= 2) ? ((array8 != null) ? array8[1] : null) : (((array8 != null) ? array8[0] : null) ?? "0"), NumberStyles.Float, new CultureInfo("en-US"), out result6) ? result6 : 0f);
						float result7 = (float.TryParse(((array10 != null) ? array10[0] : null) ?? "0", NumberStyles.Float, new CultureInfo("en-US"), out result7) ? result7 : 0f);
						float result8 = (float.TryParse((array10 != null && array10.Length >= 2) ? ((array10 != null) ? array10[1] : null) : (((array10 != null) ? array10[0] : null) ?? "0"), NumberStyles.Float, new CultureInfo("en-US"), out result8) ? result8 : 0f);
						int result9 = (int.TryParse(((array9 != null) ? array9[0] : null) ?? "0", NumberStyles.Float, new CultureInfo("en-US"), out result9) ? result9 : 0);
						((Keyframe)(ref val11))..ctor(result3, result4, result5, result6, result7, result8);
						((Keyframe)(ref val11)).weightedMode = (WeightedMode)result9;
						Keyframe val12 = val11;
						array5[l] = val12;
					}
					return (object)new AnimationCurve(array5);
				},
				ConvertToString = delegate(object input, Type type)
				{
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					//IL_0089: Unknown result type (might be due to invalid IL or missing references)
					//IL_008e: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d0: Expected I4, but got Unknown
					if (type != typeof(AnimationCurve))
					{
						return "";
					}
					Keyframe[] keys = ((AnimationCurve)input).keys;
					if (keys.Length == 0)
					{
						return "";
					}
					if (keys.Length == 1)
					{
						return ((Keyframe)(ref keys[0])).value.ToString(new CultureInfo("en-US"));
					}
					StringBuilder stringBuilder = new StringBuilder();
					Keyframe[] array3 = keys;
					for (int k = 0; k < array3.Length; k++)
					{
						Keyframe val10 = array3[k];
						float time = ((Keyframe)(ref val10)).time;
						float value = ((Keyframe)(ref val10)).value;
						float inTangent = ((Keyframe)(ref val10)).inTangent;
						float outTangent = ((Keyframe)(ref val10)).outTangent;
						float inWeight = ((Keyframe)(ref val10)).inWeight;
						float outWeight = ((Keyframe)(ref val10)).outWeight;
						int num2 = (int)((Keyframe)(ref val10)).weightedMode;
						stringBuilder.Append(time.ToString(new CultureInfo("en-US")) + ":" + value.ToString(new CultureInfo("en-US")));
						if (inTangent != 0f || outTangent != 0f)
						{
							stringBuilder.Append((inTangent == outTangent) ? $";({inTangent})" : $";({inTangent}|{outTangent})");
							if (inWeight != 0f || outWeight != 0f)
							{
								stringBuilder.Append((num2 != 0) ? (";" + num2.ToString(new CultureInfo("en-US")) + ":") : ";");
								stringBuilder.Append((inWeight == outWeight) ? ("[" + inWeight.ToString(new CultureInfo("en-US")) + "]") : ("[" + inWeight.ToString(new CultureInfo("en-US")) + "|" + outWeight.ToString(new CultureInfo("en-US")) + "]"));
							}
							else if (num2 != 0)
							{
								stringBuilder.Append(";" + num2.ToString(new CultureInfo("en-US")));
							}
						}
						stringBuilder.Append(", ");
					}
					return stringBuilder.ToString(0, Math.Max(0, stringBuilder.Length - 2));
				}
			},
			[typeof(string[])] = SimpleConverter(new string[0]),
			[typeof(Battery)] = SimpleConverter<Battery>(new Battery(false, 1f)),
			[typeof(IntWithRarity[])] = new TypeConverter
			{
				ConvertToObject = (string input, Type type) => ((IEnumerable<KeyValuePair<int, int>>)JsonConvert.DeserializeObject<Dictionary<int, int>>(input)).Select((Func<KeyValuePair<int, int>, IntWithRarity>)((KeyValuePair<int, int> x) => new IntWithRarity
				{
					id = x.Key,
					rarity = x.Value
				})).ToArray(),
				ConvertToString = (object input, Type type) => JsonConvert.SerializeObject((object)((IntWithRarity[])input).Select((IntWithRarity x) => new KeyValuePair<int, int>(x.id, x.rarity)).ToDictionary((KeyValuePair<int, int> x) => x.Key, (KeyValuePair<int, int> x) => x.Value))
			},
			[typeof(CompatibleNoun[])] = new TypeConverter
			{
				ConvertToObject = (string input, Type type) => ((IEnumerable<KeyValuePair<string, string>>)JsonConvert.DeserializeObject<Dictionary<string, string>>(input)).Select((Func<KeyValuePair<string, string>, CompatibleNoun>)((KeyValuePair<string, string> PAIR) => new CompatibleNoun
				{
					noun = ((IEnumerable<TerminalKeyword>)Resources.FindObjectsOfTypeAll<TerminalKeyword>()).FirstOrDefault((Func<TerminalKeyword, bool>)((TerminalKeyword X) => MakeFileNameSafe(((Object)X).name) == PAIR.Key)),
					result = ((IEnumerable<TerminalNode>)Resources.FindObjectsOfTypeAll<TerminalNode>()).FirstOrDefault((Func<TerminalNode, bool>)((TerminalNode X) => MakeFileNameSafe(((Object)X).name) == PAIR.Value))
				})).ToArray(),
				ConvertToString = delegate(object input, Type type)
				{
					Dictionary<string, string> NewOptions = new Dictionary<string, string>();
					IEnumerable<CompatibleNoun> enumerable = ((CompatibleNoun[])input).Where((CompatibleNoun x) => (Object)(object)x.noun != (Object)null && !NewOptions.ContainsKey(((Object)x.noun).name));
					foreach (CompatibleNoun item5 in enumerable)
					{
						Dictionary<string, string> dictionary5 = NewOptions;
						string name = ((Object)item5.noun).name;
						TerminalNode result2 = item5.result;
						dictionary5.Add(name, ((result2 != null) ? ((Object)result2).name : null) ?? "");
					}
					return JsonConvert.SerializeObject((object)NewOptions);
				}
			},
			[typeof(TerminalKeyword)] = new TypeConverter
			{
				ConvertToObject = (string input, Type type) => ((IEnumerable<TerminalKeyword>)Resources.FindObjectsOfTypeAll<TerminalKeyword>()).FirstOrDefault((Func<TerminalKeyword, bool>)((TerminalKeyword X) => MakeFileNameSafe(((Object)X).name) == input)),
				ConvertToString = (object input, Type type) => ((Object)(TerminalKeyword)input).name
			},
			[typeof(TerminalNode)] = new TypeConverter
			{
				ConvertToObject = (string input, Type type) => ((IEnumerable<TerminalNode>)Resources.FindObjectsOfTypeAll<TerminalNode>()).FirstOrDefault((Func<TerminalNode, bool>)((TerminalNode X) => MakeFileNameSafe(((Object)X).name) == input)),
				ConvertToString = (object input, Type type) => ((Object)(TerminalNode)input).name
			},
			[typeof(SpawnableEnemyWithRarity[])] = new TypeConverter
			{
				ConvertToObject = delegate(string input, Type type)
				{
					//IL_005d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0062: Unknown result type (might be due to invalid IL or missing references)
					//IL_0069: Unknown result type (might be due to invalid IL or missing references)
					//IL_007f: Expected O, but got Unknown
					List<SpawnableEnemyWithRarity> list5 = new List<SpawnableEnemyWithRarity>();
					foreach (KeyValuePair<string, int> PAIR5 in JsonConvert.DeserializeObject<Dictionary<string, int>>(input))
					{
						EnemyType val9 = ((IEnumerable<EnemyType>)Resources.FindObjectsOfTypeAll<EnemyType>()).FirstOrDefault((Func<EnemyType, bool>)((EnemyType X) => MakeFileNameSafe(X.enemyName) == PAIR5.Key));
						if (!((Object)(object)val9 == (Object)null) && !((Object)(object)val9 == (Object)null))
						{
							list5.Add(new SpawnableEnemyWithRarity
							{
								enemyType = val9,
								rarity = PAIR5.Value
							});
						}
					}
					return list5.ToArray();
				},
				ConvertToString = delegate(object input, Type type)
				{
					Dictionary<string, int> dictionary4 = new Dictionary<string, int>();
					SpawnableEnemyWithRarity[] array2 = (SpawnableEnemyWithRarity[])input;
					foreach (SpawnableEnemyWithRarity val8 in array2)
					{
						string text4 = val8.enemyType?.enemyName;
						if (text4 != null && text4 != null)
						{
							if (dictionary4.ContainsKey(text4))
							{
								dictionary4[text4] += val8.rarity;
							}
							else
							{
								dictionary4.Add(text4, val8.rarity);
							}
						}
					}
					return JsonConvert.SerializeObject((object)dictionary4);
				}
			},
			[typeof(SpawnableItemWithRarity[])] = new TypeConverter
			{
				ConvertToObject = delegate(string input, Type type)
				{
					//IL_005d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0062: Unknown result type (might be due to invalid IL or missing references)
					//IL_0069: Unknown result type (might be due to invalid IL or missing references)
					//IL_007f: Expected O, but got Unknown
					List<SpawnableItemWithRarity> list4 = new List<SpawnableItemWithRarity>();
					foreach (KeyValuePair<string, int> PAIR4 in JsonConvert.DeserializeObject<Dictionary<string, int>>(input))
					{
						Item val7 = ((IEnumerable<Item>)Resources.FindObjectsOfTypeAll<Item>()).FirstOrDefault((Func<Item, bool>)((Item X) => MakeFileNameSafe(X.itemName) == PAIR4.Key));
						if (!((Object)(object)val7 == (Object)null) && !((Object)(object)val7 == (Object)null))
						{
							list4.Add(new SpawnableItemWithRarity
							{
								spawnableItem = val7,
								rarity = PAIR4.Value
							});
						}
					}
					return list4.ToArray();
				},
				ConvertToString = delegate(object input, Type type)
				{
					Dictionary<string, int> dictionary3 = new Dictionary<string, int>();
					SpawnableItemWithRarity[] array = (SpawnableItemWithRarity[])input;
					foreach (SpawnableItemWithRarity val6 in array)
					{
						string text3 = val6.spawnableItem?.itemName;
						if (text3 != null && text3 != null)
						{
							if (dictionary3.ContainsKey(text3))
							{
								dictionary3[text3] += val6.rarity;
							}
							else
							{
								dictionary3.Add(text3, val6.rarity);
							}
						}
					}
					return JsonConvert.SerializeObject((object)dictionary3);
				}
			},
			[typeof(List<SpawnableEnemyWithRarity>)] = new TypeConverter
			{
				ConvertToObject = delegate(string input, Type type)
				{
					//IL_005d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0062: Unknown result type (might be due to invalid IL or missing references)
					//IL_0069: Unknown result type (might be due to invalid IL or missing references)
					//IL_007f: Expected O, but got Unknown
					List<SpawnableEnemyWithRarity> list3 = new List<SpawnableEnemyWithRarity>();
					foreach (KeyValuePair<string, int> PAIR3 in JsonConvert.DeserializeObject<Dictionary<string, int>>(input))
					{
						EnemyType val5 = ((IEnumerable<EnemyType>)Resources.FindObjectsOfTypeAll<EnemyType>()).FirstOrDefault((Func<EnemyType, bool>)((EnemyType X) => MakeFileNameSafe(X.enemyName) == PAIR3.Key));
						if (!((Object)(object)val5 == (Object)null) && !((Object)(object)val5 == (Object)null))
						{
							list3.Add(new SpawnableEnemyWithRarity
							{
								enemyType = val5,
								rarity = PAIR3.Value
							});
						}
					}
					return list3;
				},
				ConvertToString = delegate(object input, Type type)
				{
					Dictionary<string, int> dictionary2 = new Dictionary<string, int>();
					foreach (SpawnableEnemyWithRarity item6 in (List<SpawnableEnemyWithRarity>)input)
					{
						string text2 = item6.enemyType?.enemyName;
						if (text2 != null && text2 != null)
						{
							if (dictionary2.ContainsKey(text2))
							{
								dictionary2[text2] += item6.rarity;
							}
							else
							{
								dictionary2.Add(text2, item6.rarity);
							}
						}
					}
					return JsonConvert.SerializeObject((object)dictionary2);
				}
			},
			[typeof(List<SpawnableItemWithRarity>)] = new TypeConverter
			{
				ConvertToObject = delegate(string input, Type type)
				{
					//IL_005d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0062: Unknown result type (might be due to invalid IL or missing references)
					//IL_0069: Unknown result type (might be due to invalid IL or missing references)
					//IL_007f: Expected O, but got Unknown
					List<SpawnableItemWithRarity> list2 = new List<SpawnableItemWithRarity>();
					foreach (KeyValuePair<string, int> PAIR2 in JsonConvert.DeserializeObject<Dictionary<string, int>>(input))
					{
						Item val4 = ((IEnumerable<Item>)Resources.FindObjectsOfTypeAll<Item>()).FirstOrDefault((Func<Item, bool>)((Item X) => MakeFileNameSafe(X.itemName) == PAIR2.Key));
						if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4 == (Object)null))
						{
							list2.Add(new SpawnableItemWithRarity
							{
								spawnableItem = val4,
								rarity = PAIR2.Value
							});
						}
					}
					return list2;
				},
				ConvertToString = delegate(object input, Type type)
				{
					Dictionary<string, int> dictionary = new Dictionary<string, int>();
					foreach (SpawnableItemWithRarity item7 in (List<SpawnableItemWithRarity>)input)
					{
						string text = item7.spawnableItem?.itemName;
						if (text != null && text != null)
						{
							if (dictionary.ContainsKey(text))
							{
								dictionary[text] += item7.rarity;
							}
							else
							{
								dictionary.Add(text, item7.rarity);
							}
						}
					}
					return JsonConvert.SerializeObject((object)dictionary);
				}
			},
			[typeof(EnemyType)] = new TypeConverter
			{
				ConvertToObject = (string input, Type type) => ((IEnumerable<EnemyType>)Resources.FindObjectsOfTypeAll<EnemyType>()).FirstOrDefault((Func<EnemyType, bool>)((EnemyType X) => MakeFileNameSafe(X.enemyName) == input)),
				ConvertToString = (object input, Type type) => ((EnemyType)input).enemyName
			},
			[typeof(List<ItemGroup>)] = new TypeConverter
			{
				ConvertToObject = delegate(string input, Type type)
				{
					List<ItemGroup> list = new List<ItemGroup>();
					foreach (string item8 in JsonConvert.DeserializeObject<List<string>>(input))
					{
						ItemGroup val3 = ScriptableObject.CreateInstance<ItemGroup>();
						((Object)val3).name = item8;
						list.Add(val3);
					}
					return list;
				},
				ConvertToString = (object input, Type type) => JsonConvert.SerializeObject((object)((List<ItemGroup>)input).Select((ItemGroup x) => ((Object)x).name).ToList())
			},
			[typeof(RandomWeatherWithVariables[])] = new TypeConverter
			{
				ConvertToObject = (string input, Type type) => JsonConvert.DeserializeObject<Dictionary<string, List<int>>>(input).Select(delegate(KeyValuePair<string, List<int>> PAIR)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0005: Unknown result type (might be due to invalid IL or missing references)
					//IL_0019: Unknown result type (might be due to invalid IL or missing references)
					//IL_001a: Unknown result type (might be due to invalid IL or missing references)
					//IL_006a: Expected O, but got I4
					? val = new RandomWeatherWithVariables();
					? val2 = val;
					int num;
					if (!Enum.TryParse<LevelWeatherType>(PAIR.Key, out LevelWeatherType result))
					{
						num = -1;
						val = num;
						num = (int)val;
					}
					else
					{
						val = result;
						num = (int)val;
					}
					((RandomWeatherWithVariables)val2).weatherType = (LevelWeatherType)val;
					((RandomWeatherWithVariables)num).weatherVariable = ((PAIR.Value.Count > 0) ? PAIR.Value[0] : 0);
					((RandomWeatherWithVariables)num).weatherVariable2 = ((PAIR.Value.Count > 1) ? PAIR.Value[1] : 0);
					return (RandomWeatherWithVariables)(object)num;
				}).ToArray(),
				ConvertToString = (object input, Type type) => JsonConvert.SerializeObject((object)((RandomWeatherWithVariables[])input).Select((RandomWeatherWithVariables x) => new KeyValuePair<string, List<int>>(((object)(LevelWeatherType)(ref x.weatherType)).ToString(), new List<int>(2) { x.weatherVariable, x.weatherVariable2 })).ToDictionary((KeyValuePair<string, List<int>> x) => x.Key, (KeyValuePair<string, List<int>> x) => x.Value))
			}
		};

		public static bool AddAllTypes()
		{
			if (AddedTypes)
			{
				return false;
			}
			AddedTypes = true;
			foreach (KeyValuePair<Type, TypeConverter> customTypeConverter in CustomTypeConverters)
			{
				TomlTypeConverter.AddConverter(customTypeConverter.Key, customTypeConverter.Value);
			}
			return true;
		}

		public static string MakeFileNameSafe(string FileName)
		{
			return Regex.Replace(FileName, "[\\/:*?\"<>|]", "");
		}

		public static TypeConverter SimpleConverter<T>(T Default)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			return new TypeConverter
			{
				ConvertToObject = (string input, Type type) => (type != typeof(T)) ? Default : JsonConvert.DeserializeObject<T>(input),
				ConvertToString = (object input, Type type) => JsonConvert.SerializeObject((type != typeof(T)) ? ((object)Default) : input)
			};
		}
	}
	public sealed class SettingChangedEventArgs : EventArgs
	{
		public ConfigEntryBase ChangedSetting { get; }

		public SettingChangedEventArgs(ConfigEntryBase changedSetting)
		{
			ChangedSetting = changedSetting;
			base..ctor();
		}
	}
	public class ConfigEntrySettings
	{
		private static readonly char[] _invalidConfigChars = new char[8] { '=', '\n', '\t', '\\', '"', '\'', '[', ']' };

		public ConfigEntryBase Config;

		public int SectionOrder;

		private readonly string _StringValue;

		public string Description;

		public NetworkedConfigSync SyncType;

		public Type KeyType;

		public Type ValueType;

		public List<object> UsedKeys;

		public List<string> AcceptableKeys;

		public AcceptableValueBase AcceptableValues;

		public bool IncludeAccessedKeys;

		public LU_Direction Rule;

		public string Section { get; }

		public string Key { get; }

		public string StringValue => Config?.GetSerializedValue() ?? _StringValue;

		public ConfigEntrySettings(ConfigEntryBase Config, string Section, string Key, string StringValue = null, int SectionOrder = -1)
		{
			this.Config = Config;
			this.Section = (CheckInvalidConfigChars(Section, "Section") ? Section : null);
			this.SectionOrder = SectionOrder;
			this.Key = (CheckInvalidConfigChars(Key, "Key") ? Key : null);
			_StringValue = StringValue;
			UsedKeys = new List<object>();
			AcceptableKeys = new List<string>();
			IncludeAccessedKeys = false;
			Rule = LU_Direction.None;
			base..ctor();
		}

		public ConfigUtilities.TypeConverterBase GetConverter()
		{
			foreach (ConfigUtilities.TypeConverterBase customDictTypeConverter in ConfigUtilities.CustomDictTypeConverters)
			{
				if (customDictTypeConverter.TypeEnum == ConfigUtilities.TypeConverterEnum.Variable && Rule == LU_Direction.None)
				{
					Type keyType = customDictTypeConverter.KeyType;
					if ((object)keyType != null && keyType.IsAssignableFrom(ValueType))
					{
						return customDictTypeConverter;
					}
				}
				else if (customDictTypeConverter.TypeEnum == ConfigUtilities.TypeConverterEnum.Dictionary && Rule == LU_Direction.DictionaryKey)
				{
					Type keyType2 = customDictTypeConverter.KeyType;
					if ((object)keyType2 != null && keyType2.IsAssignableFrom(KeyType))
					{
						Type valueType = customDictTypeConverter.ValueType;
						if ((object)valueType != null && valueType.IsAssignableFrom(ValueType))
						{
							return customDictTypeConverter;
						}
					}
				}
				else if (customDictTypeConverter.TypeEnum == ConfigUtilities.TypeConverterEnum.List && Rule == LU_Direction.DictionaryValue)
				{
					Type valueType2 = customDictTypeConverter.ValueType;
					if ((object)valueType2 != null && valueType2.IsAssignableFrom(ValueType))
					{
						return customDictTypeConverter;
					}
				}
			}
			return null;
		}

		private static bool CheckInvalidConfigChars(string val, string name)
		{
			if (val == null)
			{
				throw new ArgumentNullException(name);
			}
			if (val != val.Trim())
			{
				throw new ArgumentException("Cannot use whitespace characters at start or end of section and key names", name);
			}
			if (val.Any((char c) => _invalidConfigChars.Contains(c)))
			{
				throw new ArgumentException("Cannot use any of the following characters in section and key names: = \\n \\t \\ \" ' [ ]", name);
			}
			return true;
		}
	}
	public abstract class AcceptableValueBase
	{
		public Type ValueType { get; }

		protected AcceptableValueBase(Type ValueType)
		{
			this.ValueType = ValueType;
			base..ctor();
		}

		public abstract object Clamp(object value);

		public abstract bool IsValid(object value);

		public abstract string ToDescriptionString();
	}
	public class AcceptableValueList<T> : AcceptableValueBase where T : IEquatable<T>
	{
		public virtual T[] AcceptableValues { get; }

		public AcceptableValueList(params T[] AcceptableValues)
		{
			if (AcceptableValues == null)
			{
				throw new ArgumentNullException("AcceptableValues");
			}
			if (AcceptableValues.Length == 0)
			{
				throw new ArgumentException("At least one acceptable value is needed", "AcceptableValues");
			}
			this.AcceptableValues = AcceptableValues;
			base..ctor(typeof(T));
		}

		public override object Clamp(object value)
		{
			return IsValid(value) ? value : ((object)AcceptableValues[0]);
		}

		public override bool IsValid(object value)
		{
			int result;
			if (value is T)
			{
				T v = (T)value;
				result = (AcceptableValues.Any((T x) => x.Equals(v)) ? 1 : 0);
			}
			else
			{
				result = 0;
			}
			return (byte)result != 0;
		}

		public override string ToDescriptionString()
		{
			return "# Acceptable values: " + string.Join(", ", AcceptableValues.Select((T x) => x.ToString()));
		}
	}
	public class AcceptableValueRange<T> : AcceptableValueBase where T : IComparable
	{
		public virtual T MinValue { get; }

		public virtual T MaxValue { get; }

		public AcceptableValueRange(T MinValue, T MaxValue)
		{
			T val = MinValue;
			if (val == null)
			{
				throw new ArgumentNullException("MinValue");
			}
			this.MinValue = val;
			if (MaxValue == null)
			{
				throw new ArgumentNullException("MaxValue");
			}
			if (MinValue.CompareTo(MaxValue) >= 0)
			{
				throw new ArgumentNullException("MinValue has to be lower than MaxValue");
			}
			this.MaxValue = MaxValue;
			base..ctor(typeof(T));
		}

		public override object Clamp(object value)
		{
			return (MinValue.CompareTo(value) > 0) ? ((object)MinValue) : ((MaxValue.CompareTo(value) < 0) ? ((object)MaxValue) : value);
		}

		public override bool IsValid(object value)
		{
			return MinValue.CompareTo(value) <= 0 && MaxValue.CompareTo(value) >= 0;
		}

		public override string ToDescriptionString()
		{
			return $"# Acceptable value range: From {MinValue} to {MaxValue}";
		}
	}
	public abstract class ConfigEntryBase
	{
		public object DefaultValue;

		public object HashValue;

		public string RawValue;

		public ConfigFile ConfigFile { get; }

		public ConfigEntrySettings EntrySettings { get; set; }

		public abstract object BoxedValue { get; set; }

		internal ConfigEntryBase(ConfigFile configFile, ConfigEntrySettings entrySettings, object defaultValue, string rawValue = null)
		{
			entrySettings.Config = this;
			ConfigFile = configFile ?? throw new ArgumentNullException("configFile");
			EntrySettings = entrySettings ?? throw new ArgumentNullException("entrySettings");
			DefaultValue = defaultValue;
			RawValue = rawValue;
			BoxedValue = defaultValue;
		}

		public string GetSerializedValue()
		{
			return (EntrySettings.GetConverter() ?? throw new InvalidOperationException("Cannot convert from type " + ((EntrySettings.KeyType != null && EntrySettings.ValueType != null) ? $"Dictionary<{EntrySettings.KeyType}, {EntrySettings.ValueType}>" : ((EntrySettings.ValueType != null) ? $"List<{EntrySettings.ValueType}>" : $"{EntrySettings.KeyType}")))).ConvertToString(BoxedValue, EntrySettings.KeyType, EntrySettings.ValueType);
		}

		public void SetSerializedValue(string value)
		{
			try
			{
				ConfigUtilities.TypeConverterBase typeConverterBase = EntrySettings.GetConverter() ?? throw new InvalidOperationException("Cannot convert to type " + ((EntrySettings.KeyType != null && EntrySettings.ValueType != null) ? $"Dictionary<{EntrySettings.KeyType}, {EntrySettings.ValueType}>" : ((EntrySettings.ValueType != null) ? $"List<{EntrySettings.ValueType}>" : $"{EntrySettings.KeyType}")));
				BoxedValue = typeConverterBase.ConvertToObject(value, EntrySettings.KeyType, EntrySettings.ValueType);
			}
			catch (Exception ex)
			{
				UtilsMod.MLS.Log((LogLevel)4, (object)("Config value of setting \"" + EntrySettings.Section + "." + EntrySettings.Key + "\" could not be parsed and will be ignored. Reason: " + ex.Message + "; Value: " + value));
			}
		}

		protected T ClampValue<T>(T value)
		{
			return (EntrySettings.AcceptableValues != null) ? ((T)EntrySettings.AcceptableValues.Clamp(value)) : value;
		}

		protected void OnSettingChanged(object sender)
		{
			ConfigFile.OnSettingChanged(sender, this);
		}

		public string FixTypeName(Type Fix)
		{
			return (Fix == null) ? "null" : ((typeof(List<>).Name == Fix.Name) ? ("List<" + FixTypeName(Fix.GenericTypeArguments.ElementAtOrDefault(0)) + ">") : ((typeof(Dictionary<, >).Name == Fix.Name) ? ("Dictionary<" + FixTypeName(Fix.GenericTypeArguments.ElementAtOrDefault(0)) + ", " + FixTypeName(Fix.GenericTypeArguments.ElementAtOrDefault(1)) + ">") : Fix.Name));
		}

		public void WriteDescription(StreamWriter writer)
		{
			if (!string.IsNullOrEmpty(EntrySettings.Description))
			{
				writer.WriteLine("## " + EntrySettings.Description.Replace("\n", "\n## "));
			}
			writer.WriteLine("# Setting type: " + ((EntrySettings.Rule == LU_Direction.DictionaryKey) ? ("Dictionary<" + FixTypeName(EntrySettings.KeyType) + ", " + FixTypeName(EntrySettings.ValueType) + ">") : ((EntrySettings.Rule == LU_Direction.DictionaryValue) ? ("List<" + FixTypeName(EntrySettings.ValueType) + ">") : FixTypeName(EntrySettings.ValueType))));
			writer.WriteLine("# Sync type: " + EntrySettings.SyncType);
			if (RawValue != null)
			{
				writer.WriteLine("# Raw value: " + RawValue);
			}
			bool flag = EntrySettings.IncludeAccessedKeys;
			if (EntrySettings.AcceptableKeys != null && EntrySettings.AcceptableKeys.Count > 0)
			{
				writer.WriteLine("# Acceptable keys: " + string.Join(", ", EntrySettings.AcceptableKeys));
			}
			else if (EntrySettings.KeyType != null && EntrySettings.KeyType.IsEnum)
			{
				writer.WriteLine("# Acceptable keys: " + string.Join(", ", Enum.GetNames(EntrySettings.KeyType)));
			}
			else if (EntrySettings.UsedKeys != null && EntrySettings.UsedKeys.Count > 0)
			{
				flag = true;
			}
			if (flag)
			{
				writer.WriteLine("# Accessed keys: " + string.Join(", ", EntrySettings.UsedKeys));
			}
			if (EntrySettings.AcceptableValues != null)
			{
				writer.WriteLine(EntrySettings.AcceptableValues.ToDescriptionString());
			}
			else if (EntrySettings.ValueType == null || !EntrySettings.ValueType.IsEnum)
			{
				return;
			}
			writer.WriteLine("# Acceptable values: " + string.Join(", ", Enum.GetNames(EntrySettings.ValueType)));
			if (EntrySettings.ValueType.GetCustomAttributes(typeof(FlagsAttribute), inherit: true).Any())
			{
				writer.WriteLine("# Multiple values can be set at the same time by separating them with , (e.g. Debug, Warning)");
			}
		}
	}
	public sealed class ConfigEntry<T> : ConfigEntryBase
	{
		private T _typedValue;

		public T Value
		{
			get
			{
				return _typedValue;
			}
			set
			{
				if (!object.Equals(_typedValue, value = ClampValue(value)))
				{
					_typedValue = value;
					OnSettingChanged(this);
				}
			}
		}

		public override object BoxedValue
		{
			get
			{
				return Value;
			}
			set
			{
				Value = (T)value;
			}
		}

		public event EventHandler SettingChanged;

		internal ConfigEntry(ConfigFile configFile, ConfigEntrySettings entrySettings, object defaultValue, string RawValue = "")
			: base(configFile, entrySettings, defaultValue, RawValue)
		{
			configFile.SettingChanged += delegate(object sender, SettingChangedEventArgs args)
			{
				if (args.ChangedSetting == this)
				{
					this.SettingChanged?.Invoke(sender, args);
				}
			};
		}
	}
	public class ConfigFile
	{
		public ConfigEntry<LoadSettings> ConfigEnabledVar;

		public ConfigEntry<List<string>> LoadSettingsVar;

		private readonly BepInPlugin _ownerMetadata;

		private readonly object _ioLock = new object();

		protected Dictionary<string, ConfigEntryBase> Entries { get; } = new Dictionary<string, ConfigEntryBase>();


		private Dictionary<string, ConfigEntrySettings> OrphanedEntries { get; } = new Dictionary<string, ConfigEntrySettings>();


		public string ConfigFilePath { get; }

		public bool SaveOnConfigSet { get; set; } = true;


		public event EventHandler ConfigReloaded;

		public event EventHandler<SettingChangedEventArgs> SettingChanged;

		public ConfigFile(string configPath, bool saveOnInit, BepInPlugin ownerMetadata = null)
		{
			_ownerMetadata = ownerMetadata;
			if (configPath == null)
			{
				throw new ArgumentNullException("configPath");
			}
			configPath = Path.GetFullPath(configPath);
			ConfigFilePath = configPath;
			if (File.Exists(ConfigFilePath))
			{
				Reload();
			}
			else if (saveOnInit)
			{
				Save();
			}
		}

		public void Reload()
		{
			lock (_ioLock)
			{
				OrphanedEntries.Clear();
				string text = string.Empty;
				string[] array = File.ReadAllLines(ConfigFilePath);
				foreach (string text2 in array)
				{
					string text3 = text2.Trim();
					if (text3.StartsWith("#"))
					{
						continue;
					}
					if (text3.StartsWith("[") && text3.EndsWith("]"))
					{
						string text4 = text3;
						text = text4.Substring(1, text4.Length - 1 - 1);
						continue;
					}
					string[] array2 = text3.Split(new char[1] { '=' }, 2);
					if (array2.Length == 2)
					{
						string text5 = array2[0].Trim();
						string text6 = array2[1].Trim();
						string key = text + "." + text5;
						Entries.TryGetValue(key, out var value);
						if (value != null)
						{
							value.SetSerializedValue(text6);
						}
						else
						{
							OrphanedEntries[key] = new ConfigEntrySettings(null, text, text5, text6);
						}
					}
				}
			}
			OnConfigReloaded();
		}

		public void Save()
		{
			lock (_ioLock)
			{
				string directoryName = Path.GetDirectoryName(ConfigFilePath);
				if (directoryName != null)
				{
					Directory.CreateDirectory(directoryName);
				}
				using StreamWriter streamWriter = new StreamWriter(ConfigFilePath, append: false, Utility.UTF8NoBom);
				if (_ownerMetadata != null)
				{
					streamWriter.WriteLine($"## Settings file was created by plugin {_ownerMetadata.Name} v{_ownerMetadata.Version}");
					streamWriter.WriteLine("## Plugin GUID: " + _ownerMetadata.GUID);
					streamWriter.WriteLine();
				}
				foreach (IGrouping<(int, string), ConfigEntrySettings> item in from x in Entries.Select((KeyValuePair<string, ConfigEntryBase> x) => x.Value.EntrySettings).Concat(OrphanedEntries.Select((KeyValuePair<string, ConfigEntrySettings> x) => x.Value))
					group x by (x.SectionOrder, x.Section) into x
					orderby x.Key.SectionOrder == -1, x.Key.SectionOrder, x.Key.Section
					select x)
				{
					streamWriter.WriteLine("[" + item.Key.Item2 + "]");
					foreach (ConfigEntrySettings item2 in item)
					{
						streamWriter.WriteLine();
						item2.Config?.WriteDescription(streamWriter);
						streamWriter.WriteLine(item2.Key + " = " + item2.StringValue);
					}
					streamWriter.WriteLine();
				}
			}
		}

		public ConfigEntry<T> Bind<T>(ConfigEntrySettings entrySettings, T defaultValue, string RawValue = null)
		{
			lock (_ioLock)
			{
				string key = entrySettings.Section + "." + entrySettings.Key;
				if (Entries.TryGetValue(key, out var value))
				{
					return value as ConfigEntry<T>;
				}
				ConfigEntry<T> configEntry = new ConfigEntry<T>(this, entrySettings, defaultValue, RawValue);
				Entries[key] = configEntry;
				if (OrphanedEntries.TryGetValue(key, out var value2))
				{
					configEntry.SetSerializedValue(value2.StringValue);
					OrphanedEntries.Remove(key);
				}
				if (SaveOnConfigSet)
				{
					Save();
				}
				return configEntry;
			}
		}

		public ConfigEntry<T> Bind<T>(string section, string key, T defaultValue, string configDescription = null, int order = -1, string RawValue = "", LU_Direction Rule = LU_Direction.None, NetworkedConfigSync SyncType = NetworkedConfigSync.Unspecified)
		{
			return Bind(new ConfigEntrySettings(null, section ?? throw new ArgumentNullException("section"), key ?? throw new ArgumentNullException("key"))
			{
				ValueType = typeof(T),
				Description = configDescription,
				SectionOrder = order,
				Rule = Rule,
				SyncType = SyncType
			}, defaultValue, RawValue);
		}

		internal void OnSettingChanged(object sender, ConfigEntryBase changedEntryBase)
		{
			if (changedEntryBase == null)
			{
				throw new ArgumentNullException("changedEntryBase");
			}
			if (SaveOnConfigSet)
			{
				Save();
			}
			if (this.SettingChanged == null)
			{
				return;
			}
			SettingChangedEventArgs e = new SettingChangedEventArgs(changedEntryBase);
			foreach (EventHandler<SettingChangedEventArgs> item in this.SettingChanged.GetInvocationList().Cast<EventHandler<SettingChangedEventArgs>>())
			{
				try
				{
					item(sender, e);
				}
				catch (Exception ex)
				{
					UtilsMod.MLS.Log((LogLevel)2, (object)ex);
				}
			}
		}

		private void OnConfigReloaded()
		{
			if (this.ConfigReloaded == null)
			{
				return;
			}
			foreach (EventHandler item in this.ConfigReloaded.GetInvocationList().Cast<EventHandler>())
			{
				try
				{
					item(this, EventArgs.Empty);
				}
				catch (Exception ex)
				{
					UtilsMod.MLS.Log((LogLevel)2, (object)ex);
				}
			}
		}

		public bool Remove(string section, string key)
		{
			lock (_ioLock)
			{
				return Entries.Remove(section + "." + key);
			}
		}
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			return !_moveNextCalled && (_moveNextCalled = true);
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		return (!EqualityComparer<T>.Default.Equals(_item, (T)value)) ? (-1) : 0;
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return (!EqualityComparer<T>.Default.Equals(_item, item)) ? (-1) : 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}