using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PluginConfig.API;
using PluginConfig.API.Fields;
using PluginConfig.API.Functionals;
using SettingsMenu.Components;
using SettingsMenu.Models;
using TMPro;
using Ultrachaos.Randomizers;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.Events;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.ResourceManagement.ResourceProviders;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("Ultrachaos")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+516431c20606d55a68f1e4d99d6cd58418035ce4")]
[assembly: AssemblyProduct("My first plugin")]
[assembly: AssemblyTitle("Ultrachaos")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.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 Ultrachaos
{
	[BepInPlugin("com.yourname.pluginname", "My first plugin", "2.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static OnClick <0>__Plugin_onClick_LVL;

			public static OnClick <1>__Plugin_onClick_Mapping;

			public static OnClick <2>__Plugin_onClick_Enable_All_Enemies;

			public static OnClick <3>__Plugin_onClick_Disable_All_Enemies;
		}

		private Harmony Harmony = new Harmony("com.yourname.pluginname");

		public static ConfigFile C;

		public static RandomConfig<RandomConfigValue> ChangeMaterials;

		public static RandomConfig<RandomConfigValue> ChangeSounds;

		public static RandomConfig<RandomConfigValue> ChangeEnemies;

		public static RandomConfig<RandomConfigValue> ChangeMeshes;

		public static RandomConfig<RandomConfigValue> ChangeProjectiles;

		public static RandomConfig<RandomConfigValue> ChangeHitscans;

		public static RandomConfig<RandomConfigValue> ChangeMusic;

		public static RandomConfig<RandomConfigValue> ChangeImages;

		public static RandomConfig<RandomConfigValue> ChangeText;

		public static RandomConfig<RandomConfigValue> ChangeItems;

		public static RandomConfig<RandomConfigValue> RandomizeLevels;

		public static RandomConfig<RandomConfigValue> RandomizGrenades;

		public static RandomConfig<RandomConfigValue> RandomizNails;

		public static RandomConfig<RandomConfigValue> RandomizExplosions;

		public static RandomConfig<bool> ChangeAnimator;

		public static RandomConfig<bool> OriginalHealthEID;

		public static ConfigPanel ChaosPanel;

		public static ConfigPanel NormalPanel;

		public static ConfigPanel PlayerPanel;

		public static ConfigPanel EnemyRNGList;

		private static PluginConfigurator config;

		public static List<Action<GameObject>> OnInstantiateMethod = new List<Action<GameObject>>();

		internal static ManualLogSource Logger { get; private set; } = null;


		public static Plugin Instance { get; private set; }

		private void Awake()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin com.yourname.pluginname is loaded!");
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)4;
			Harmony.PatchAll();
			C = ((BaseUnityPlugin)this).Config;
			config = PluginConfigurator.Create("ULTRACHAOS", "com.yourname.pluginname");
			ChaosPanel = new ConfigPanel(config.rootPanel, "C H A O S", "panel.chaos");
			NormalPanel = new ConfigPanel(config.rootPanel, "Normal", "panel.normal");
			PlayerPanel = new ConfigPanel(config.rootPanel, "Player", "panel.player");
			EnemyRNGList = new ConfigPanel(config.rootPanel, "Enemies", "panel.enemies");
			SetupConfigs();
			SceneManager.sceneLoaded += SceneManager_sceneLoaded;
			SoundRandomizer.Init();
			Type icCheatType = typeof(ICheat);
			IEnumerable<Type> enumerable = from t in AppDomain.CurrentDomain.GetAssemblies().SelectMany((Assembly a) => a.GetTypes())
				where icCheatType.IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract
				select t;
			MethodInfo method = typeof(TextRandomizer).GetMethod("CheatName");
			foreach (Type item in enumerable)
			{
				MethodInfo methodInfo = item.GetProperty("LongName")?.GetGetMethod();
				if (methodInfo != null)
				{
					Harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			LevelRandomizer.Init();
			((MonoBehaviour)this).StartCoroutine(EnemyRandomizer.Init());
		}

		public static bool CanChangeObj(GameObject obj)
		{
			return !isConfiggyChild(obj.transform) && !isOptionsChild(obj.transform);
		}

		public static bool isConfiggyChild(Transform obj)
		{
			if (((Object)((Component)obj).gameObject).name.Contains("Configuration"))
			{
				return true;
			}
			if ((Object)(object)obj.parent != (Object)null)
			{
				return isConfiggyChild(obj.parent);
			}
			return false;
		}

		public static bool isOptionsChild(Transform obj)
		{
			if (((Object)((Component)obj).gameObject).name.Contains("OptionsMenu"))
			{
				return true;
			}
			if ((Object)(object)obj.parent != (Object)null)
			{
				return isOptionsChild(obj.parent);
			}
			return false;
		}

		public static bool isPlayerChild(Transform obj)
		{
			if (Object.op_Implicit((Object)(object)((Component)obj).GetComponent<NewMovement>()))
			{
				return true;
			}
			if (((Object)((Component)obj).gameObject).name.Contains("Player"))
			{
				return true;
			}
			if ((Object)(object)obj.parent != (Object)null)
			{
				return isPlayerChild(obj.parent);
			}
			return false;
		}

		public static bool isEnemyChild(Transform obj)
		{
			if (Object.op_Implicit((Object)(object)((Component)obj).GetComponent<EnemyIdentifier>()))
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)((Component)obj).GetComponent<EnemyIdentifierIdentifier>()))
			{
				return true;
			}
			if ((Object)(object)obj.parent != (Object)null)
			{
				return isEnemyChild(obj.parent);
			}
			return false;
		}

		public static bool isFirstRoomChild(Transform obj)
		{
			if (((Object)((Component)obj).gameObject).name.ToLower().Contains("firstroom"))
			{
				return true;
			}
			if ((Object)(object)obj.parent != (Object)null)
			{
				return isFirstRoomChild(obj.parent);
			}
			return false;
		}

		public static bool isFinalRoomChild(Transform obj)
		{
			if (((Object)((Component)obj).gameObject).name.ToLower().Contains("finalroom"))
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)((Component)obj).gameObject.GetComponent<FinalRoom>()))
			{
				return true;
			}
			if ((Object)(object)obj.parent != (Object)null)
			{
				return isFinalRoomChild(obj.parent);
			}
			return false;
		}

		public static void SetupConfigs()
		{
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Expected O, but got Unknown
			ChangeMaterials = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Materials", RandomConfigValue.Disabled);
			ChangeSounds = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Sounds", RandomConfigValue.Disabled);
			ChangeMeshes = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Meshes", RandomConfigValue.Disabled);
			ChangeProjectiles = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Projectiles", RandomConfigValue.Disabled);
			ChangeHitscans = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Hitscans", RandomConfigValue.Disabled);
			ChangeText = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Texts", RandomConfigValue.Disabled);
			RandomizGrenades = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Grenades", RandomConfigValue.Disabled);
			RandomizNails = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Nails", RandomConfigValue.Disabled);
			RandomizExplosions = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Explosions", RandomConfigValue.Disabled);
			ChangeImages = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Images", RandomConfigValue.Disabled);
			ChangeItems = new RandomConfig<RandomConfigValue>(ChaosPanel, "Change Items", RandomConfigValue.Disabled);
			ChangeAnimator = new RandomConfig<bool>(ChaosPanel, "Change Animator", defaultVal: false);
			ChangeEnemies = new RandomConfig<RandomConfigValue>(NormalPanel, "Change Enemies", RandomConfigValue.Disabled);
			OriginalHealthEID = new RandomConfig<bool>(NormalPanel, "Keep original enemys health", defaultVal: false);
			ChangeMusic = new RandomConfig<RandomConfigValue>(NormalPanel, "Change Music", RandomConfigValue.Disabled);
			RandomizeLevels = new RandomConfig<RandomConfigValue>(NormalPanel, "Randomize Levels", RandomConfigValue.Disabled);
			ButtonField val = new ButtonField(NormalPanel, "Go To Random Level", "button.normal.random.level");
			object obj = <>O.<0>__Plugin_onClick_LVL;
			if (obj == null)
			{
				OnClick val2 = Plugin_onClick_LVL;
				<>O.<0>__Plugin_onClick_LVL = val2;
				obj = (object)val2;
			}
			val.onClick += (OnClick)obj;
			ButtonField val3 = new ButtonField(config.rootPanel, "Reset Mapping", "button.reset.mapping");
			object obj2 = <>O.<1>__Plugin_onClick_Mapping;
			if (obj2 == null)
			{
				OnClick val4 = Plugin_onClick_Mapping;
				<>O.<1>__Plugin_onClick_Mapping = val4;
				obj2 = (object)val4;
			}
			val3.onClick += (OnClick)obj2;
			ButtonField val5 = new ButtonField(EnemyRNGList, "Enable All", "button.enemies.enable.all");
			object obj3 = <>O.<2>__Plugin_onClick_Enable_All_Enemies;
			if (obj3 == null)
			{
				OnClick val6 = Plugin_onClick_Enable_All_Enemies;
				<>O.<2>__Plugin_onClick_Enable_All_Enemies = val6;
				obj3 = (object)val6;
			}
			val5.onClick += (OnClick)obj3;
			ButtonField val7 = new ButtonField(EnemyRNGList, "Disable All", "button.enemies.disable.all");
			object obj4 = <>O.<3>__Plugin_onClick_Disable_All_Enemies;
			if (obj4 == null)
			{
				OnClick val8 = Plugin_onClick_Disable_All_Enemies;
				<>O.<3>__Plugin_onClick_Disable_All_Enemies = val8;
				obj4 = (object)val8;
			}
			val7.onClick += (OnClick)obj4;
			PlayerRandomizers.GenerateConfigs();
			ScaleRandomizer.GenerateConfigs();
		}

		private static void Plugin_onClick_Enable_All_Enemies()
		{
			foreach (RandomConfig<bool> value in EnemyRandomizer.CanUse.Values)
			{
				value.Value = true;
			}
		}

		private static void Plugin_onClick_Disable_All_Enemies()
		{
			foreach (RandomConfig<bool> value in EnemyRandomizer.CanUse.Values)
			{
				value.Value = false;
			}
		}

		private static void Plugin_onClick_Mapping()
		{
			EnemyRandomizer.Instance.ResetMappings();
			ExplosionRandomizer.Instance.ResetMappings();
			GrenadeRandomizer.Instance.ResetMappings();
			HitscanRandomizer.Instance.ResetMappings();
			ImageRandomizer.Instance.ResetMappings();
			ItemRandomizer.Instance.ResetMappings();
			LevelRandomizer.Instance.ResetMappings();
			MaterialRandomizer.Instance.ResetMappings();
			MeshRandomizer.Instance.ResetMappings();
			MusicRandomizer.Instance.ResetMappings();
			NailRandomizer.Instance.ResetMappings();
			ProjectileRandomizer.Instance.ResetMappings();
			SoundRandomizer.Instance.ResetMappings();
			TextRandomizer._randomizer.ResetMappings();
		}

		private static void Plugin_onClick_LVL()
		{
			LevelRandomizer.LoadRandomScene();
		}

		public static string GetPrefabName(string objName)
		{
			if (string.IsNullOrEmpty(objName))
			{
				return objName;
			}
			return Regex.Replace(objName, "\\s*\\((Clone|\\d+)\\)$", "");
		}

		public static bool IsGameplayScene()
		{
			string[] source = new string[6] { "Intro", "Bootstrap", "Main Menu", "Level 2-S", "Intermission1", "Intermission2" };
			return !source.Contains(SceneHelper.CurrentScene);
		}

		private void SceneManager_sceneLoaded(Scene arg0, LoadSceneMode arg1)
		{
			((MonoBehaviour)this).StartCoroutine(EnemyRandomizer.Init());
			MusicRandomizer.FillPool();
			LevelRandomizer.Init();
			SoundRandomizer.Init();
			ProjectileRandomizer.Init();
			HitscanRandomizer.Init();
			GrenadeRandomizer.GetGrenades();
			NailRandomizer.GetNails();
			ExplosionRandomizer.GetExplosions();
			if (SceneHelper.CurrentScene == "Main Menu")
			{
				SoundRandomizer.Instance.Initialize();
				MaterialRandomizer.Instance.Initialize();
				ImageRandomizer.Instance.Initialize();
				HitscanRandomizer.Instance.Initialize();
				ProjectileRandomizer.Instance.Initialize();
				MeshRandomizer.Instance.Initialize();
				MusicRandomizer.Instance.Initialize();
			}
			if (IsGameplayScene())
			{
				TextRandomizer.SearchTexts();
				if (ChangeMaterials.Value != 0)
				{
					((MonoBehaviour)this).StartCoroutine(MaterialRandomizer.ApplyChanges());
				}
				((MonoBehaviour)this).StartCoroutine(ItemRandomizer.ApplyChanges());
				if (ChangeImages.Value != 0)
				{
					ImageRandomizer.ApplyChanges();
				}
				if (ChangeSounds.Value != 0)
				{
					SoundRandomizer.Init();
				}
				if (ChangeMeshes.Value != 0)
				{
					MeshRandomizer.Init();
				}
				MusicRandomizer.Init();
				ScaleRandomizer.Init();
			}
		}
	}
	[HarmonyPatch]
	public class InstantiatePatches
	{
		private static void ProcessInstantiatedObject(Object obj)
		{
			if (obj == (Object)null)
			{
				return;
			}
			GameObject val = null;
			GameObject val2 = (GameObject)(object)((obj is GameObject) ? obj : null);
			if (val2 != null)
			{
				val = val2;
			}
			else
			{
				Component val3 = (Component)(object)((obj is Component) ? obj : null);
				if (val3 != null)
				{
					val = val3.gameObject;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			foreach (Action<GameObject> item in Plugin.OnInstantiateMethod)
			{
				item(val);
			}
		}

		[HarmonyPatch(typeof(Object), "Instantiate", new Type[] { typeof(Object) })]
		[HarmonyPostfix]
		private static void InstantiatePostfix1(Object __result)
		{
			ProcessInstantiatedObject(__result);
		}

		[HarmonyPatch(typeof(Object), "Instantiate", new Type[]
		{
			typeof(Object),
			typeof(Transform)
		})]
		[HarmonyPostfix]
		private static void InstantiatePostfix2(Object __result)
		{
			ProcessInstantiatedObject(__result);
		}

		[HarmonyPatch(typeof(Object), "Instantiate", new Type[]
		{
			typeof(Object),
			typeof(Transform),
			typeof(bool)
		})]
		[HarmonyPostfix]
		private static void InstantiatePostfix3(Object __result)
		{
			ProcessInstantiatedObject(__result);
		}

		[HarmonyPatch(typeof(Object), "Instantiate", new Type[]
		{
			typeof(Object),
			typeof(Vector3),
			typeof(Quaternion)
		})]
		[HarmonyPostfix]
		private static void InstantiatePostfix4(Object __result)
		{
			ProcessInstantiatedObject(__result);
		}

		[HarmonyPatch(typeof(Object), "Instantiate", new Type[]
		{
			typeof(Object),
			typeof(Vector3),
			typeof(Quaternion),
			typeof(Transform)
		})]
		[HarmonyPostfix]
		private static void InstantiatePostfix5(Object __result)
		{
			ProcessInstantiatedObject(__result);
		}
	}
	public class RandomConfig<T>
	{
		private ConfigField field;

		public T Value
		{
			get
			{
				return (T)((object)field).GetType().GetProperty("value").GetValue(field);
			}
			set
			{
				((object)field).GetType().GetProperty("value").SetValue(field, value);
			}
		}

		public RandomConfig(ConfigPanel panel, string name, T defaultVal)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			string text = "guid." + ((ConfigField)panel).guid + "." + name;
			if (typeof(T) == typeof(float))
			{
				field = (ConfigField)new FloatField(panel, name, text, (float)(object)defaultVal);
				return;
			}
			if (typeof(T) == typeof(int))
			{
				field = (ConfigField)new IntField(panel, name, text, (int)(object)defaultVal);
				return;
			}
			if (typeof(T) == typeof(bool))
			{
				field = (ConfigField)new BoolField(panel, name, text, (bool)(object)defaultVal);
				return;
			}
			if (typeof(T) == typeof(string))
			{
				field = (ConfigField)new StringField(panel, name, text, (string)(object)defaultVal);
				return;
			}
			if (typeof(T) == typeof(RandomConfigValue))
			{
				field = (ConfigField)(object)new EnumField<RandomConfigValue>(panel, name, text, (RandomConfigValue)(object)defaultVal);
				return;
			}
			throw new Exception($"Unsupported config type: {typeof(T)}");
		}
	}
	public enum RandomConfigValue
	{
		Disabled,
		UniquePerKind,
		UniquePerKindWithDuplicates,
		AlwaysUnique
	}
	internal static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.yourname.pluginname";

		public const string PLUGIN_NAME = "My first plugin";

		public const string PLUGIN_VERSION = "2.0.0";
	}
}
namespace Ultrachaos.Randomizers
{
	[HarmonyPatch]
	public class AnimatorRandomizer
	{
		[HarmonyPatch(typeof(Animator), "SetTrigger", new Type[] { typeof(string) })]
		[HarmonyPrefix]
		public static void TriggerRandomizer(ref string name, Animator __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			if (!Plugin.ChangeAnimator.Value)
			{
				return;
			}
			List<string> list = new List<string>();
			AnimatorControllerParameter[] parameters = __instance.parameters;
			foreach (AnimatorControllerParameter val in parameters)
			{
				if ((int)val.type == 9)
				{
					list.Add(val.name);
				}
			}
			name = list[Random.Range(0, list.Count)];
		}

		[HarmonyPatch(typeof(Animator), "SetInteger", new Type[]
		{
			typeof(string),
			typeof(int)
		})]
		[HarmonyPrefix]
		public static void IntegerRandomizer(ref string name, Animator __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			if (!Plugin.ChangeAnimator.Value)
			{
				return;
			}
			List<string> list = new List<string>();
			AnimatorControllerParameter[] parameters = __instance.parameters;
			foreach (AnimatorControllerParameter val in parameters)
			{
				if ((int)val.type == 3)
				{
					list.Add(val.name);
				}
			}
			name = list[Random.Range(0, list.Count)];
		}

		[HarmonyPatch(typeof(Animator), "SetBool", new Type[]
		{
			typeof(string),
			typeof(bool)
		})]
		[HarmonyPrefix]
		public static void BoolRandomizer(ref string name, Animator __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			if (!Plugin.ChangeAnimator.Value)
			{
				return;
			}
			List<string> list = new List<string>();
			AnimatorControllerParameter[] parameters = __instance.parameters;
			foreach (AnimatorControllerParameter val in parameters)
			{
				if ((int)val.type == 4)
				{
					list.Add(val.name);
				}
			}
			name = list[Random.Range(0, list.Count)];
		}

		[HarmonyPatch(typeof(Animator), "SetFloat", new Type[]
		{
			typeof(string),
			typeof(float)
		})]
		[HarmonyPrefix]
		public static void FloatRandomizer(ref string name, Animator __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			if (!Plugin.ChangeAnimator.Value)
			{
				return;
			}
			List<string> list = new List<string>();
			AnimatorControllerParameter[] parameters = __instance.parameters;
			foreach (AnimatorControllerParameter val in parameters)
			{
				if ((int)val.type == 1)
				{
					list.Add(val.name);
				}
			}
			name = list[Random.Range(0, list.Count)];
		}
	}
	[HarmonyPatch]
	public class EnemyRandomizer : Randomizer<SpawnableObject>
	{
		[HarmonyPatch(typeof(EnemySpawnRadius), "SpawnEnemy")]
		internal class SpawnEnemiesRandom
		{
			private static bool Prefix(EnemySpawnRadius __instance, ref List<GameObject> ___spawnedObjects, ref List<EnemyIdentifier> ___currentEnemies, ref float ___cooldown, ref GoreZone ___gz)
			{
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				if (Plugin.ChangeEnemies.Value == RandomConfigValue.Disabled)
				{
					return true;
				}
				GameObject val = __instance.spawnables[Random.Range(0, __instance.spawnables.Length)];
				EnemyIdentifier val2 = val.GetComponent<EnemyIdentifier>() ?? val.GetComponentInChildren<EnemyIdentifier>();
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.Logger.LogWarning((object)("Spawnable '" + ((Object)val).name + "' has no EnemyIdentifier."));
					return true;
				}
				SpawnableObject val3 = FindBestMatch(val2);
				if ((Object)(object)val3 == (Object)null)
				{
					Plugin.Logger.LogWarning((object)("No match for spawner '" + ((Object)((Component)__instance).gameObject).name + "'"));
					return true;
				}
				List<SpawnableObject> list = Instance.Pool.Where((SpawnableObject x) => CanUse.ContainsKey(x) && CanUse[x].Value).ToList();
				if (list.Count == 0)
				{
					return true;
				}
				SpawnableObject random = Instance.GetRandom(val3, list);
				Vector3 val4 = new Vector3(Random.Range(-1f, 1f), 0f, Random.Range(-1f, 1f));
				Vector3 normalized = ((Vector3)(ref val4)).normalized;
				RaycastHit val5 = default(RaycastHit);
				if (Physics.Raycast(((Component)__instance).transform.position + normalized * Random.Range(__instance.minimumDistance, __instance.maximumDistance), Vector3.down, ref val5, 25f, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))))
				{
					___cooldown = __instance.spawnCooldown;
					GameObject val6 = Object.Instantiate<GameObject>(random.gameObject, ((RaycastHit)(ref val5)).point, Quaternion.identity);
					_replacementInstanceIds.Add(((Object)val6).GetInstanceID());
					val6.transform.SetParent(((Component)___gz).transform, true);
					___spawnedObjects.Add(val6);
					EnemyIdentifier componentInChildren = val6.GetComponentInChildren<EnemyIdentifier>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						___currentEnemies.Add(componentInChildren);
						if (__instance.spawnAsPuppets)
						{
							componentInChildren.puppet = true;
						}
					}
					else
					{
						___currentEnemies.Add(null);
					}
					val6.SetActive(true);
					return false;
				}
				___cooldown = 1f;
				return false;
			}
		}

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

			private object <>2__current;

			public EnemyRandomizer <>4__this;

			private AsyncOperationHandle<IResourceLocator> <initHandle>5__1;

			private List<IResourceLocation> <allLocations>5__2;

			private IEnumerator<IResourceLocator> <>s__3;

			private IResourceLocator <locator>5__4;

			private List<object> <keys>5__5;

			private AsyncOperationHandle<IList<IResourceLocation>> <locHandle>5__6;

			private List<IResourceLocation>.Enumerator <>s__7;

			private IResourceLocation <location>5__8;

			private AsyncOperationHandle<SpawnableObject> <loadHandle>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				case -3:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 3:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<initHandle>5__1 = default(AsyncOperationHandle<IResourceLocator>);
				<allLocations>5__2 = null;
				<>s__3 = null;
				<locator>5__4 = null;
				<keys>5__5 = null;
				<locHandle>5__6 = default(AsyncOperationHandle<IList<IResourceLocation>>);
				<>s__7 = default(List<IResourceLocation>.Enumerator);
				<location>5__8 = null;
				<loadHandle>5__9 = default(AsyncOperationHandle<SpawnableObject>);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Invalid comparison between Unknown and I4
				//IL_0285: Unknown result type (might be due to invalid IL or missing references)
				//IL_028b: Invalid comparison between Unknown and I4
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_016d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0298: Unknown result type (might be due to invalid IL or missing references)
				//IL_029e: Invalid comparison between Unknown and I4
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0253: Unknown result type (might be due to invalid IL or missing references)
				//IL_025a: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (alreadyAddressed)
						{
							return false;
						}
						<initHandle>5__1 = Addressables.InitializeAsync();
						<>2__current = <initHandle>5__1;
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<allLocations>5__2 = new List<IResourceLocation>();
						<>s__3 = Addressables.ResourceLocators.GetEnumerator();
						<>1__state = -3;
						goto IL_017a;
					case 2:
						<>1__state = -3;
						if ((int)<locHandle>5__6.Status == 1)
						{
							<allLocations>5__2.AddRange(<locHandle>5__6.Result);
						}
						Addressables.Release<IList<IResourceLocation>>(<locHandle>5__6);
						<keys>5__5 = null;
						<locHandle>5__6 = default(AsyncOperationHandle<IList<IResourceLocation>>);
						<locator>5__4 = null;
						goto IL_017a;
					case 3:
						{
							<>1__state = -4;
							if ((int)<loadHandle>5__9.Status == 1 && (int)<loadHandle>5__9.Result.spawnableObjectType == 1)
							{
								<>4__this.AddToPool(<loadHandle>5__9.Result);
							}
							<loadHandle>5__9 = default(AsyncOperationHandle<SpawnableObject>);
							<location>5__8 = null;
							break;
						}
						IL_017a:
						while (<>s__3.MoveNext())
						{
							<locator>5__4 = <>s__3.Current;
							<keys>5__5 = <locator>5__4.Keys.ToList();
							if (<keys>5__5.Count == 0)
							{
								continue;
							}
							<locHandle>5__6 = Addressables.LoadResourceLocationsAsync((IList<object>)<keys>5__5, (MergeMode)1, typeof(SpawnableObject));
							<>2__current = <locHandle>5__6;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>s__3 = null;
						<allLocations>5__2 = (from l in <allLocations>5__2
							group l by l.InternalId into g
							select g.First()).ToList();
						Plugin.Logger.LogInfo((object)$"Found {<allLocations>5__2.Count} SpawnableObject locations");
						<>s__7 = <allLocations>5__2.GetEnumerator();
						<>1__state = -4;
						break;
					}
					if (<>s__7.MoveNext())
					{
						<location>5__8 = <>s__7.Current;
						<loadHandle>5__9 = Addressables.LoadAssetAsync<SpawnableObject>(<location>5__8);
						<>2__current = <loadHandle>5__9;
						<>1__state = 3;
						return true;
					}
					<>m__Finally2();
					<>s__7 = default(List<IResourceLocation>.Enumerator);
					alreadyAddressed = true;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>s__7).Dispose();
			}

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

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					_replacementInstanceIds.Clear();
					Plugin.Logger.LogInfo((object)"Getting addressables!!!");
					<>2__current = Instance.GetAllSpawnables();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (Instance.Pool.Count > PrevCount)
					{
						CreateConfigs();
					}
					return false;
				}
			}

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

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

		public static bool SeededRandom = true;

		public static EnemyRandomizer Instance = new EnemyRandomizer();

		private static int PrevCount = 0;

		private static bool _sceneListenerRegistered = false;

		public static Dictionary<SpawnableObject, RandomConfig<bool>> CanUse = new Dictionary<SpawnableObject, RandomConfig<bool>>();

		private static List<string> DefaultBlacklistedEnemies = new List<string> { "Leviathan", "The Corpse of King Minos", "Earthmover" };

		private static bool alreadyAddressed = false;

		private static readonly HashSet<int> _replacementInstanceIds = new HashSet<int>();

		private static bool _isSpawningReplacement = false;

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

		public static void CreateConfigs()
		{
			foreach (SpawnableObject item in Instance.Pool)
			{
				if (!CanUse.ContainsKey(item))
				{
					Plugin.Logger.LogInfo((object)("Creating config for " + item.objectName));
					CanUse.Add(item, new RandomConfig<bool>(Plugin.EnemyRNGList, item.objectName, !DefaultBlacklistedEnemies.Contains(item.objectName)));
				}
			}
		}

		protected override void Log(string message)
		{
			Plugin.Logger.LogInfo((object)message);
		}

		private static string CleanGoName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return string.Empty;
			}
			int num = name.IndexOf('(');
			if (num > 0)
			{
				name = name.Substring(0, num);
			}
			return name.Trim().ToLowerInvariant();
		}

		private static int GetNameSimilarity(string spawnableName, string goName)
		{
			if (string.IsNullOrEmpty(spawnableName) || string.IsNullOrEmpty(goName))
			{
				return 0;
			}
			string text = spawnableName.ToLowerInvariant().Trim();
			string text2 = CleanGoName(goName);
			if (text == text2)
			{
				return int.MaxValue;
			}
			if (text2.Contains(text))
			{
				return text.Length * 2;
			}
			string[] array = text.Split(new char[3] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries);
			int num = 0;
			string[] array2 = array;
			foreach (string value in array2)
			{
				if (text2.Contains(value))
				{
					num++;
				}
			}
			return num;
		}

		private static SpawnableObject FindBestMatch(EnemyIdentifier eid)
		{
			EnemyIdentifier eid2 = eid;
			string goName = ((Object)((Component)eid2).gameObject).name;
			List<(SpawnableObject, int)> list = (from x in Instance.Pool
				where x.enemyType == eid2.enemyType
				select (x, GetNameSimilarity(x.objectName, goName)) into t
				orderby t.score descending
				select t).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			string text = $"{list[0].Item1.objectName} (score {list[0].Item2})";
			string text2 = ((list.Count > 1) ? $", runner-up: {list[1].Item1.objectName} (score {list[1].Item2})" : string.Empty);
			Plugin.Logger.LogInfo((object)("FindBestMatch '" + goName + "' -> " + text + text2));
			return list[0].Item1;
		}

		private static void ApplyRequiredThings(EnemyIdentifier eid, EnemyIdentifier randomedEID)
		{
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Expected O, but got Unknown
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Invalid comparison between Unknown and I4
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			randomedEID.dontCountAsKills = eid.dontCountAsKills;
			randomedEID.destroyOnDeath.AddRange(eid.destroyOnDeath);
			randomedEID.activateOnDeath = eid.activateOnDeath;
			randomedEID.sandified = eid.sandified;
			randomedEID.usingDoor = eid.usingDoor;
			randomedEID.madness = eid.madness;
			randomedEID.ignorePlayer = eid.ignorePlayer;
			randomedEID.ignoredByEnemies = eid.ignoredByEnemies;
			randomedEID.attackEnemies = eid.attackEnemies;
			if (Plugin.OriginalHealthEID.Value)
			{
				randomedEID.health = eid.health;
				Enemy val = FindEnemyComponent(((Component)eid).gameObject);
				Enemy val2 = FindEnemyComponent(((Component)randomedEID).gameObject);
				if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
				{
					val2.health = val.health;
					val2.originalHealth = val.originalHealth;
				}
			}
			BossHealthBar val3 = default(BossHealthBar);
			if (((Component)eid).TryGetComponent<BossHealthBar>(ref val3))
			{
				Plugin.Logger.LogInfo((object)("Replacing name " + val3.bossName));
				BossHealthBar val4 = ((Component)randomedEID).gameObject.AddComponent<BossHealthBar>();
				if (val3.bossName.ToLower().Contains("judge of hell"))
				{
					val4.bossName += ", JUDGE OF HELL";
				}
				else if (val3.bossName.ToLower().Contains("apostate of hate"))
				{
					val4.bossName += ", THE APOSTATE OF HATE";
				}
				else if (val3.bossName.ToLower().Contains("guardian of hell"))
				{
					val4.bossName += ", GUARDIAN OF HELL";
				}
				else if (val3.bossName.ToLower().Contains("prime"))
				{
					val4.bossName += " PRIME";
				}
				float num = randomedEID.health / eid.health;
				val4.healthLayers = val3.healthLayers;
				if (val4.healthLayers != null)
				{
					HealthLayer[] healthLayers = val4.healthLayers;
					foreach (HealthLayer val5 in healthLayers)
					{
						if (!Plugin.OriginalHealthEID.Value)
						{
							val5.health *= num;
						}
					}
				}
				val4.secondaryBar = val3.secondaryBar;
				if (val4.secondaryBar)
				{
					val4.secondaryBarColor = val3.secondaryBarColor;
					val4.secondaryBarValue = val3.secondaryBarValue;
				}
			}
			Enemy val6 = FindEnemyComponent(((Component)eid).gameObject);
			Enemy val7 = FindEnemyComponent(((Component)randomedEID).gameObject);
			if (Object.op_Implicit((Object)(object)val6) && Object.op_Implicit((Object)(object)val7))
			{
				val7.dontDie = val6.dontDie;
			}
			UnityEvent eventtt = eid.onDeath;
			randomedEID.onDeath.AddListener((UnityAction)delegate
			{
				eventtt.Invoke();
			});
			if ((int)randomedEID.enemyType == 12)
			{
				randomedEID.sandified = true;
			}
			Idol component = ((Component)eid).GetComponent<Idol>();
			Idol component2 = ((Component)randomedEID).GetComponent<Idol>();
			if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
			{
				component2.target = component.target;
			}
			else if ((Object)(object)component != (Object)null && (Object)(object)component2 == (Object)null)
			{
				component2 = ((Component)randomedEID).gameObject.AddComponent<Idol>();
				component2.target = component.target;
			}
			Idol[] array = Object.FindObjectsByType<Idol>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (Idol val8 in array)
			{
				if ((Object)(object)val8.target == (Object)(object)eid)
				{
					val8.target = randomedEID;
				}
				if ((Object)(object)val8.overrideTarget == (Object)(object)eid)
				{
					val8.overrideTarget = randomedEID;
				}
			}
		}

		private static Enemy FindEnemyComponent(GameObject obj)
		{
			if ((Object)(object)obj == (Object)null)
			{
				return null;
			}
			Enemy component = obj.GetComponent<Enemy>();
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
			component = obj.GetComponentInChildren<Enemy>(true);
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
			return obj.GetComponentInParent<Enemy>();
		}

		[IteratorStateMachine(typeof(<GetAllSpawnables>d__15))]
		private IEnumerator GetAllSpawnables()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllSpawnables>d__15(0)
			{
				<>4__this = this
			};
		}

		[HarmonyPatch(typeof(EnemyIdentifier), "Start")]
		[HarmonyPrefix]
		public static bool ReplaceEnemy(EnemyIdentifier __instance)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Invalid comparison between Unknown and I4
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Invalid comparison between Unknown and I4
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Invalid comparison between Unknown and I4
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Invalid comparison between Unknown and I4
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.ChangeEnemies.Value == RandomConfigValue.Disabled)
			{
				return true;
			}
			if ((Object)(object)((Component)__instance).transform.parent != (Object)null && ((Object)((Component)((Component)__instance).transform.parent).gameObject).name == "4 - Swordsmachine Hallway")
			{
				return true;
			}
			if (_replacementInstanceIds.Contains(((Object)((Component)__instance).gameObject).GetInstanceID()))
			{
				return true;
			}
			if ((int)__instance.enemyType == 21)
			{
				return true;
			}
			if ((int)__instance.enemyType == 39)
			{
				return true;
			}
			if (__instance.dead)
			{
				return true;
			}
			if (!((Behaviour)__instance).enabled)
			{
				return true;
			}
			SpawnableObject val = FindBestMatch(__instance);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Logger.LogWarning((object)$"No matching SpawnableObject for '{((Object)((Component)__instance).gameObject).name}' (type: {__instance.enemyType}), skipping.");
				return true;
			}
			List<SpawnableObject> list = Instance.Pool.Where((SpawnableObject x) => CanUse.ContainsKey(x) && CanUse[x].Value).ToList();
			if (list.Count == 0)
			{
				return true;
			}
			SpawnableObject random = Instance.GetRandom(val, list);
			if ((Object)(object)random == (Object)null)
			{
				return true;
			}
			GameObject gameObject = random.gameObject;
			Vector3 position = ((Component)__instance).transform.position;
			if ((int)__instance.enemyType == 4)
			{
				position = ((Component)__instance).transform.parent.position;
			}
			GameObject val2 = Object.Instantiate<GameObject>(gameObject, position, gameObject.transform.rotation);
			_replacementInstanceIds.Add(((Object)val2).GetInstanceID());
			Plugin.Logger.LogInfo((object)("Spawned " + ((Object)gameObject).name + " instead of " + ((Object)((Component)__instance).gameObject).name));
			_isSpawningReplacement = false;
			val2.transform.parent = (((int)__instance.enemyType != 4) ? ((Component)__instance).transform.parent : ((Component)__instance).transform.parent.parent);
			EnemyIdentifier val3 = val2.GetComponent<EnemyIdentifier>() ?? val2.GetComponentInChildren<EnemyIdentifier>();
			if ((Object)(object)val3 == (Object)null)
			{
				Object.Destroy((Object)(object)val2);
				return true;
			}
			ActivateArena[] array = Object.FindObjectsByType<ActivateArena>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (ActivateArena val4 in array)
			{
				for (int j = 0; j < val4.enemies.Length; j++)
				{
					if ((Object)(object)val4.enemies[j] == (Object)(object)((Component)__instance).gameObject)
					{
						val4.enemies[j] = val2;
					}
				}
			}
			ApplyRequiredThings(__instance, val3);
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}

		protected override int GetInstanceID(SpawnableObject item)
		{
			return ((Object)item).GetInstanceID();
		}

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.ChangeEnemies.Value;
		}
	}
	public class RandomizerSpawnedEnemy : MonoBehaviour
	{
	}
	[HarmonyPatch]
	public class ExplosionRandomizer : Randomizer<ExplosionController>
	{
		public static ExplosionRandomizer Instance = new ExplosionRandomizer();

		private static bool replacing;

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.RandomizExplosions.Value;
		}

		public static void GetExplosions()
		{
			ExplosionController[] array = Resources.FindObjectsOfTypeAll<ExplosionController>();
			Instance.AddRangeToPool(array);
			Plugin.Logger.LogInfo((object)$"Adding {array.Length} to the pool, pool length of grenade randomizer is now {Instance.Pool.Count}");
		}

		protected override int GetInstanceID(ExplosionController item)
		{
			if ((Object)(object)item == (Object)null || (Object)(object)((Component)item).gameObject == (Object)null || ((Object)((Component)item).gameObject).name == null)
			{
				return 0;
			}
			string text = ((Object)((Component)item).gameObject).name.ToLower().Replace(" (clone)", "").Replace("(clone)", "");
			return text.GetHashCode();
		}

		[HarmonyPatch(typeof(ExplosionController), "Start")]
		[HarmonyPrefix]
		public static bool GrenadeRNG(ExplosionController __instance)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (Instance.GetConfigValue() == RandomConfigValue.Disabled)
			{
				return true;
			}
			if (replacing)
			{
				return true;
			}
			if (((Object)((Component)__instance).gameObject).name.Contains("RNG"))
			{
				return true;
			}
			ExplosionController random = Instance.GetRandom(__instance);
			replacing = true;
			ExplosionController val = Object.Instantiate<ExplosionController>(random, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
			GameObject gameObject = ((Component)val).gameObject;
			((Object)gameObject).name = ((Object)gameObject).name + "RNG";
			replacing = false;
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	[HarmonyPatch]
	public class GrenadeRandomizer : Randomizer<Grenade>
	{
		public static GrenadeRandomizer Instance = new GrenadeRandomizer();

		private static bool replacing;

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.RandomizGrenades.Value;
		}

		public static void GetGrenades()
		{
			Grenade[] array = Resources.FindObjectsOfTypeAll<Grenade>();
			Instance.AddRangeToPool(array);
			Plugin.Logger.LogInfo((object)$"Adding {array.Length} to the pool, pool length of grenade randomizer is now {Instance.Pool.Count}");
		}

		protected override int GetInstanceID(Grenade item)
		{
			string text = ((Object)((Component)item).gameObject).name.ToLower().Replace(" (Clone)", "");
			text = text.Replace("(Clone)", "");
			return text.GetHashCode();
		}

		public static void ApplyThings(Grenade org, Grenade newG)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			newG.enemy = org.enemy;
			newG.originEnemy = org.originEnemy;
			newG.ignoreEnemyType = org.ignoreEnemyType;
			newG.sourceWeapon = org.sourceWeapon;
			newG.hitterWeapon = org.hitterWeapon;
			Rigidbody val = default(Rigidbody);
			Rigidbody val2 = default(Rigidbody);
			if (((Component)newG).gameObject.TryGetComponent<Rigidbody>(ref val) && ((Component)org).gameObject.TryGetComponent<Rigidbody>(ref val2))
			{
				val.velocity = val2.velocity;
				val.angularVelocity = val2.angularVelocity;
				if (org.rocket && !newG.rocket)
				{
					val.AddForce(((Component)org).transform.forward * 70f, (ForceMode)2);
				}
			}
			if (newG.rocket && !org.rocket)
			{
				((Component)newG).transform.forward = ((Component)MonoSingleton<CameraController>.Instance).transform.forward;
			}
		}

		[HarmonyPatch(typeof(Grenade), "Awake")]
		[HarmonyPrefix]
		public static bool GrenadeRNG(Grenade __instance)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (Instance.GetConfigValue() == RandomConfigValue.Disabled)
			{
				return true;
			}
			if (replacing)
			{
				return true;
			}
			Grenade random = Instance.GetRandom(__instance);
			replacing = true;
			Grenade newG = Object.Instantiate<Grenade>(random, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
			replacing = false;
			ApplyThings(__instance, newG);
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	[HarmonyPatch]
	public class HitscanRandomizer : Randomizer<RevolverBeam>
	{
		public static HitscanRandomizer Instance = new HitscanRandomizer();

		public static bool isReplacing = false;

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.ChangeHitscans.Value;
		}

		protected override int GetInstanceID(RevolverBeam item)
		{
			string text = ((Object)((Component)item).gameObject).name.ToLower().Replace(" (Clone)", "");
			text = text.Replace("(Clone)", "");
			return text.GetHashCode();
		}

		public static void Init()
		{
			RevolverBeam[] items = Resources.FindObjectsOfTypeAll<RevolverBeam>();
			Instance.AddRangeToPool(items);
		}

		public static void ApplyCorrectThings(RevolverBeam random, RevolverBeam orig)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			random.beamType = orig.beamType;
			random.ignoreEnemyType = orig.ignoreEnemyType;
			random.quickDraw = orig.quickDraw;
		}

		[HarmonyPatch(typeof(RevolverBeam), "Start")]
		[HarmonyPrefix]
		public static bool Randomize(RevolverBeam __instance)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (Instance.GetConfigValue() == RandomConfigValue.Disabled)
			{
				return true;
			}
			if (((Object)((Component)__instance).gameObject).name.Contains("Randomized"))
			{
				return true;
			}
			if (isReplacing)
			{
				return true;
			}
			RevolverBeam random = Instance.GetRandom(__instance);
			if ((Object)(object)random == (Object)null)
			{
				return true;
			}
			isReplacing = true;
			RevolverBeam val = Object.Instantiate<RevolverBeam>(random, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
			GameObject gameObject = ((Component)val).gameObject;
			((Object)gameObject).name = ((Object)gameObject).name + "Randomized";
			isReplacing = false;
			ApplyCorrectThings(val, __instance);
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	[HarmonyPatch]
	public class ImageRandomizer : Randomizer<Sprite>
	{
		public static readonly ImageRandomizer Instance = new ImageRandomizer();

		protected override int GetInstanceID(Sprite item)
		{
			return ((Object)item).GetInstanceID();
		}

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.ChangeImages.Value;
		}

		public override void Initialize()
		{
			Plugin.OnInstantiateMethod.Add(delegate(GameObject obj)
			{
				Image[] componentsInChildren = obj.GetComponentsInChildren<Image>();
				foreach (Image rend in componentsInChildren)
				{
					ReplaceRenderer(rend);
				}
			});
		}

		public static void ApplyChanges()
		{
			Instance.ChangeMats();
		}

		public void ChangeMats()
		{
			AddRangeToPool(Resources.FindObjectsOfTypeAll<Sprite>());
			Image[] array = Object.FindObjectsByType<Image>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			Plugin.Logger.LogInfo((object)"Randomizing images...");
			Image[] array2 = array;
			foreach (Image val in array2)
			{
				if (((Component)val).gameObject.layer != 19)
				{
					ReplaceRenderer(val);
				}
			}
		}

		public void ReplaceRenderer(Image rend)
		{
			try
			{
				if (!((Object)(object)rend == (Object)null) && Plugin.ChangeImages.Value != 0 && Plugin.CanChangeObj(((Component)rend).gameObject))
				{
					rend.sprite = ReplaceMaterial(rend.sprite);
				}
			}
			catch (Exception)
			{
			}
		}

		public Sprite ReplaceMaterial(Sprite mat)
		{
			try
			{
				AddToPool(mat);
				return GetRandom(mat);
			}
			catch (Exception)
			{
				return mat;
			}
		}
	}
	public class ItemRandomizer : Randomizer<ItemIdentifier>
	{
		[CompilerGenerated]
		private sealed class <ApplyChanges>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Expected O, but got Unknown
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Instance.AddRangeToPool(from x in Resources.FindObjectsOfTypeAll<ItemIdentifier>()
						where ((Component)x).gameObject.scene != SceneManager.GetActiveScene()
						select x);
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Instance.ChangeMats();
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					Instance.ChangeMats();
					return false;
				}
			}

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

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

		public static ItemRandomizer Instance = new ItemRandomizer();

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.ChangeItems.Value;
		}

		protected override int GetInstanceID(ItemIdentifier item)
		{
			if ((Object)(object)item == (Object)null || (Object)(object)((Component)item).gameObject == (Object)null)
			{
				return 0;
			}
			return Plugin.GetPrefabName(((Object)((Component)item).gameObject).name).GetHashCode();
		}

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

		public void ChangeMats()
		{
			if (GetConfigValue() != 0)
			{
				ReplaceItems();
			}
		}

		private void ReplaceItems()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (GetConfigValue() == RandomConfigValue.Disabled)
			{
				return;
			}
			List<ItemIdentifier> list = Object.FindObjectsByType<ItemIdentifier>((FindObjectsInactive)1, (FindObjectsSortMode)0).ToList();
			foreach (ItemIdentifier item in list)
			{
				ItemIdentifier val = Object.Instantiate<ItemIdentifier>(GetRandom(item), ((Component)item).transform.position, ((Component)item).transform.rotation);
				val.pickedUp = item.pickedUp;
				val.infiniteSource = item.infiniteSource;
				val.onPickUp = item.onPickUp;
				val.onPutDown = item.onPutDown;
				val.ipz = item.ipz;
				val.itemType = item.itemType;
				((Component)val).transform.parent = ((Component)item).transform.parent;
				((Component)val).gameObject.SetActive(((Component)item).gameObject.activeSelf);
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
		}
	}
	[HarmonyPatch(typeof(SceneHelper))]
	public class LevelRandomizer : Randomizer<string>
	{
		[CompilerGenerated]
		private sealed class <InitAddressables>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private List<IResourceLocation> <allLocations>5__1;

			private IEnumerator<IResourceLocator> <>s__2;

			private IResourceLocator <locator>5__3;

			private List<object> <keys>5__4;

			private AsyncOperationHandle<IList<IResourceLocation>> <locHandle>5__5;

			private List<IResourceLocation>.Enumerator <>s__6;

			private IResourceLocation <location>5__7;

			private string <sceneName>5__8;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<allLocations>5__1 = null;
				<>s__2 = null;
				<locator>5__3 = null;
				<keys>5__4 = null;
				<locHandle>5__5 = default(AsyncOperationHandle<IList<IResourceLocation>>);
				<>s__6 = default(List<IResourceLocation>.Enumerator);
				<location>5__7 = null;
				<sceneName>5__8 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Invalid comparison between Unknown and I4
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = Addressables.InitializeAsync();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<allLocations>5__1 = new List<IResourceLocation>();
						<>s__2 = Addressables.ResourceLocators.GetEnumerator();
						<>1__state = -3;
						break;
					case 2:
						<>1__state = -3;
						if ((int)<locHandle>5__5.Status == 1)
						{
							<allLocations>5__1.AddRange(<locHandle>5__5.Result);
						}
						Addressables.Release<IList<IResourceLocation>>(<locHandle>5__5);
						<keys>5__4 = null;
						<locHandle>5__5 = default(AsyncOperationHandle<IList<IResourceLocation>>);
						<locator>5__3 = null;
						break;
					}
					while (<>s__2.MoveNext())
					{
						<locator>5__3 = <>s__2.Current;
						<keys>5__4 = <locator>5__3.Keys.ToList();
						if (<keys>5__4.Count == 0)
						{
							continue;
						}
						<locHandle>5__5 = Addressables.LoadResourceLocationsAsync((IList<object>)<keys>5__4, (MergeMode)1, typeof(SceneInstance));
						<>2__current = <locHandle>5__5;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__2 = null;
					<allLocations>5__1 = (from l in <allLocations>5__1
						group l by l.InternalId into g
						select g.First()).ToList();
					Plugin.Logger.LogInfo((object)$"[LevelRandomizer] Found {<allLocations>5__1.Count} scene locations");
					<>s__6 = <allLocations>5__1.GetEnumerator();
					try
					{
						while (<>s__6.MoveNext())
						{
							<location>5__7 = <>s__6.Current;
							<sceneName>5__8 = SceneHelper.SanitizeLevelPath(<location>5__7.InternalId);
							if (!(<sceneName>5__8 == "Main Menu") && !(<sceneName>5__8 == "Bootstrap") && !(<sceneName>5__8 == "Intro"))
							{
								Instance.AddToPool(<sceneName>5__8);
								Plugin.Logger.LogInfo((object)("[LevelRandomizer] Registered: " + <sceneName>5__8));
								<sceneName>5__8 = null;
								<location>5__7 = null;
							}
						}
					}
					finally
					{
						((IDisposable)<>s__6).Dispose();
					}
					<>s__6 = default(List<IResourceLocation>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

		public static LevelRandomizer Instance = new LevelRandomizer();

		public static void Init()
		{
			((MonoBehaviour)Plugin.Instance).StartCoroutine(InitAddressables());
		}

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

		public static void LoadRandomScene()
		{
			SceneHelper.LoadScene(Instance.Pool[Random.Range(0, Instance.Pool.Count)], false);
		}

		[HarmonyPatch(typeof(SceneHelper), "LoadScene")]
		[HarmonyPrefix]
		public static void RandomizeScene(ref string sceneName)
		{
			if (!(sceneName == "Main Menu") && !(sceneName == "Bootstrap") && !(sceneName == "Intro"))
			{
				sceneName = Instance.GetRandom(sceneName);
			}
		}

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.RandomizeLevels.Value;
		}

		protected override int GetInstanceID(string item)
		{
			return item.GetHashCode();
		}
	}
	[HarmonyPatch]
	public class MaterialRandomizer : Randomizer<Material>
	{
		[CompilerGenerated]
		private sealed class <ApplyChanges>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Instance.ChangeMats();
					return false;
				}
			}

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

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

		public static readonly MaterialRandomizer Instance = new MaterialRandomizer();

		protected override int GetInstanceID(Material item)
		{
			return ((Object)item).GetInstanceID();
		}

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.ChangeMaterials.Value;
		}

		public override void Initialize()
		{
			Plugin.OnInstantiateMethod.Add(delegate(GameObject obj)
			{
				Renderer[] componentsInChildren = obj.GetComponentsInChildren<Renderer>();
				foreach (Renderer rend in componentsInChildren)
				{
					ReplaceRenderer(rend);
				}
			});
		}

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

		public void ChangeMats()
		{
			if (Plugin.ChangeMaterials.Value == RandomConfigValue.Disabled)
			{
				return;
			}
			AddRangeToPool(Resources.FindObjectsOfTypeAll<Material>());
			Renderer[] array = Object.FindObjectsByType<Renderer>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (Renderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)((Component)val).gameObject.GetComponent<ParticleSystem>()) && ((Component)val).gameObject.layer != 19)
				{
					ReplaceRenderer(val);
				}
			}
		}

		public void ReplaceRenderer(Renderer rend)
		{
			try
			{
				if ((Object)(object)rend == (Object)null || Plugin.ChangeMaterials.Value == RandomConfigValue.Disabled)
				{
					return;
				}
				rend.SetPropertyBlock((MaterialPropertyBlock)null);
				Material[] sharedMaterials = rend.sharedMaterials;
				for (int i = 0; i < sharedMaterials.Length; i++)
				{
					if ((Object)(object)sharedMaterials[i] != (Object)null)
					{
						sharedMaterials[i] = GetRandom(sharedMaterials[i]);
					}
				}
				rend.sharedMaterials = sharedMaterials;
			}
			catch (Exception)
			{
			}
		}

		public Material ReplaceMaterial(Material mat)
		{
			try
			{
				AddToPool(mat);
				return GetRandom(mat);
			}
			catch (Exception)
			{
				return mat;
			}
		}
	}
	public class MeshRandomizer : Randomizer<Mesh>
	{
		[CompilerGenerated]
		private sealed class <Inititit>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MeshRandomizer <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Instance.ChangeMeshes();
					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 List<Mesh> cachedMeshes;

		public static MeshRandomizer Instance = new MeshRandomizer();

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.ChangeMeshes.Value;
		}

		protected override int GetInstanceID(Mesh item)
		{
			return ((Object)item).GetInstanceID();
		}

		public override void Initialize()
		{
			cachedMeshes = Resources.FindObjectsOfTypeAll<Mesh>().ToList();
			Plugin.OnInstantiateMethod.Add(delegate(GameObject obj)
			{
				MeshFilter[] componentsInChildren = obj.GetComponentsInChildren<MeshFilter>();
				foreach (MeshFilter rend in componentsInChildren)
				{
					ReplaceRenderer(rend, cachedMeshes);
				}
			});
		}

		public static void Init()
		{
			((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.Inititit());
		}

		[IteratorStateMachine(typeof(<Inititit>d__6))]
		public IEnumerator Inititit()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Inititit>d__6(0)
			{
				<>4__this = this
			};
		}

		public void ChangeMeshes()
		{
			if (GetConfigValue() == RandomConfigValue.Disabled)
			{
				return;
			}
			MeshFilter[] array = Object.FindObjectsByType<MeshFilter>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			MeshFilter[] array2 = array;
			foreach (MeshFilter val in array2)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.mesh == (Object)null) && ((Component)val).gameObject.layer != 19 && !((Object)(object)((Component)val).GetComponent<ParticleSystem>() != (Object)null))
				{
					ReplaceRenderer(val, cachedMeshes);
				}
			}
		}

		public void ReplaceRenderer(MeshFilter rend, List<Mesh> pool)
		{
			try
			{
				if (!((Object)(object)rend == (Object)null) && GetConfigValue() != 0)
				{
					rend.mesh = GetRandom(rend.mesh, pool);
				}
			}
			catch (Exception)
			{
			}
		}
	}
	public class MusicRandomizer : Randomizer<AudioClip>
	{
		[CompilerGenerated]
		private sealed class <GetAllMusic>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MusicRandomizer <>4__this;

			private AsyncOperationHandle<IResourceLocator> <initHandle>5__1;

			private List<IResourceLocation> <allLocations>5__2;

			private IEnumerator<IResourceLocator> <>s__3;

			private IResourceLocator <locator>5__4;

			private List<object> <keys>5__5;

			private AsyncOperationHandle<IList<IResourceLocation>> <locHandle>5__6;

			private List<IResourceLocation>.Enumerator <>s__7;

			private IResourceLocation <location>5__8;

			private AsyncOperationHandle<SoundtrackSong> <loadHandle>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				case -3:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 3:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<initHandle>5__1 = default(AsyncOperationHandle<IResourceLocator>);
				<allLocations>5__2 = null;
				<>s__3 = null;
				<locator>5__4 = null;
				<keys>5__5 = null;
				<locHandle>5__6 = default(AsyncOperationHandle<IList<IResourceLocation>>);
				<>s__7 = default(List<IResourceLocation>.Enumerator);
				<location>5__8 = null;
				<loadHandle>5__9 = default(AsyncOperationHandle<SoundtrackSong>);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Invalid comparison between Unknown and I4
				//IL_0270: Unknown result type (might be due to invalid IL or missing references)
				//IL_0276: Invalid comparison between Unknown and I4
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Unknown result type (might be due to invalid IL or missing references)
				//IL_0248: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<initHandle>5__1 = Addressables.InitializeAsync();
						<>2__current = <initHandle>5__1;
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<allLocations>5__2 = new List<IResourceLocation>();
						<>s__3 = Addressables.ResourceLocators.GetEnumerator();
						<>1__state = -3;
						goto IL_0168;
					case 2:
						<>1__state = -3;
						if ((int)<locHandle>5__6.Status == 1)
						{
							<allLocations>5__2.AddRange(<locHandle>5__6.Result);
						}
						Addressables.Release<IList<IResourceLocation>>(<locHandle>5__6);
						<keys>5__5 = null;
						<locHandle>5__6 = default(AsyncOperationHandle<IList<IResourceLocation>>);
						<locator>5__4 = null;
						goto IL_0168;
					case 3:
						{
							<>1__state = -4;
							if ((int)<loadHandle>5__9.Status == 1)
							{
								<>4__this.AddRangeToPool(<loadHandle>5__9.Result.clips);
							}
							<loadHandle>5__9 = default(AsyncOperationHandle<SoundtrackSong>);
							<location>5__8 = null;
							break;
						}
						IL_0168:
						while (<>s__3.MoveNext())
						{
							<locator>5__4 = <>s__3.Current;
							<keys>5__5 = <locator>5__4.Keys.ToList();
							if (<keys>5__5.Count == 0)
							{
								continue;
							}
							<locHandle>5__6 = Addressables.LoadResourceLocationsAsync((IList<object>)<keys>5__5, (MergeMode)1, typeof(SoundtrackSong));
							<>2__current = <locHandle>5__6;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>s__3 = null;
						<allLocations>5__2 = (from l in <allLocations>5__2
							group l by l.InternalId into g
							select g.First()).ToList();
						Plugin.Logger.LogInfo((object)$"Found {<allLocations>5__2.Count} Songs locations");
						<>s__7 = <allLocations>5__2.GetEnumerator();
						<>1__state = -4;
						break;
					}
					if (<>s__7.MoveNext())
					{
						<location>5__8 = <>s__7.Current;
						<loadHandle>5__9 = Addressables.LoadAssetAsync<SoundtrackSong>(<location>5__8);
						<>2__current = <loadHandle>5__9;
						<>1__state = 3;
						return true;
					}
					<>m__Finally2();
					<>s__7 = default(List<IResourceLocation>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>s__7).Dispose();
			}

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

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

			private object <>2__current;

			public MusicRandomizer <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSecondsRealtime(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					ReplaceThings();
					return false;
				}
			}

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

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

		public static MusicRandomizer Instance = new MusicRandomizer();

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.ChangeMusic.Value;
		}

		protected override int GetInstanceID(AudioClip item)
		{
			return ((Object)item).GetInstanceID();
		}

		public static void Init()
		{
			ReplaceThings();
			((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.ReplaceEveryhtingPlease());
		}

		public static void FillPool()
		{
			if (Instance.Pool.Count <= 0)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(Instance.GetAllMusic());
			}
		}

		[IteratorStateMachine(typeof(<ReplaceEveryhtingPlease>d__5))]
		public IEnumerator ReplaceEveryhtingPlease()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ReplaceEveryhtingPlease>d__5(0)
			{
				<>4__this = this
			};
		}

		public static void ReplaceThings()
		{
			MusicManager instance = MonoSingleton<MusicManager>.Instance;
			if ((Object)(object)instance.bossTheme.clip != (Object)null)
			{
				instance.bossTheme.clip = Instance.GetRandom(instance.bossTheme.clip);
			}
			if ((Object)(object)instance.cleanTheme.clip != (Object)null)
			{
				instance.cleanTheme.clip = Instance.GetRandom(instance.cleanTheme.clip);
			}
			if ((Object)(object)instance.battleTheme.clip != (Object)null)
			{
				instance.battleTheme.clip = Instance.GetRandom(instance.battleTheme.clip);
			}
			MusicChanger[] array = Object.FindObjectsByType<MusicChanger>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			MusicChanger[] array2 = array;
			foreach (MusicChanger val in array2)
			{
				val.battle = Instance.GetRandom(val.battle);
				val.boss = Instance.GetRandom(val.boss);
				val.clean = Instance.GetRandom(val.clean);
			}
			HashSet<AudioSource> hashSet = new HashSet<AudioSource>();
			hashSet.Add(instance.bossTheme);
			hashSet.Add(instance.cleanTheme);
			hashSet.Add(instance.battleTheme);
			MusicChanger[] array3 = array;
			foreach (MusicChanger val2 in array3)
			{
				AudioSource component = ((Component)val2).GetComponent<AudioSource>();
				if ((Object)(object)component != (Object)null)
				{
					hashSet.Add(component);
				}
			}
			AudioSource[] array4 = Object.FindObjectsByType<AudioSource>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			AudioSource[] array5 = array4;
			foreach (AudioSource val3 in array5)
			{
				if (!hashSet.Contains(val3) && !((Object)(object)val3.clip == (Object)null) && IsMusic(val3))
				{
					val3.clip = Instance.GetRandom(val3.clip);
				}
			}
		}

		private static bool IsMusic(AudioSource source)
		{
			return (Object)(object)source.outputAudioMixerGroup != (Object)null && ((Object)source.outputAudioMixerGroup.audioMixer).name == "MusicAudio";
		}

		[IteratorStateMachine(typeof(<GetAllMusic>d__8))]
		public IEnumerator GetAllMusic()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllMusic>d__8(0)
			{
				<>4__this = this
			};
		}
	}
	[HarmonyPatch]
	public class NailRandomizer : Randomizer<Nail>
	{
		public static NailRandomizer Instance = new NailRandomizer();

		private static bool replacing;

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.RandomizNails.Value;
		}

		public static void GetNails()
		{
			Nail[] array = Resources.FindObjectsOfTypeAll<Nail>();
			Instance.AddRangeToPool(array);
			Plugin.Logger.LogInfo((object)$"Adding {array.Length} to the pool, pool length of nail randomizer is now {Instance.Pool.Count}");
		}

		protected override int GetInstanceID(Nail item)
		{
			int num = (item.sawblade ? 2 : 4);
			int num2 = (item.heated ? 1 : 3);
			string text = ((Object)((Component)item).gameObject).name.ToLower().Replace(" (Clone)", "");
			text = text.Replace("(Clone)", "");
			return text.GetHashCode() + num + num2;
		}

		public static void ApplyThings(Nail org, Nail newG)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			newG.enemy = org.enemy;
			newG.safeEnemyType = org.safeEnemyType;
			newG.sourceWeapon = org.sourceWeapon;
			Rigidbody val = default(Rigidbody);
			Rigidbody val2 = default(Rigidbody);
			if (((Component)newG).gameObject.TryGetComponent<Rigidbody>(ref val) && ((Component)org).gameObject.TryGetComponent<Rigidbody>(ref val2))
			{
				val.velocity = val2.velocity;
				val.angularVelocity = val2.angularVelocity;
			}
		}

		[HarmonyPatch(typeof(Nail), "Start")]
		[HarmonyPrefix]
		public static bool GrenadeRNG(Nail __instance)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (Instance.GetConfigValue() == RandomConfigValue.Disabled)
			{
				return true;
			}
			if (replacing)
			{
				return true;
			}
			if (((Object)((Component)__instance).gameObject).name.Contains("RNG"))
			{
				return true;
			}
			Nail random = Instance.GetRandom(__instance);
			replacing = true;
			Nail val = Object.Instantiate<Nail>(random, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
			GameObject gameObject = ((Component)val).gameObject;
			((Object)gameObject).name = ((Object)gameObject).name + "RNG";
			replacing = false;
			ApplyThings(__instance, val);
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	[HarmonyPatch]
	public class PlayerRandomizers
	{
		[HarmonyPatch(typeof(NewMovement), "GetHealth")]
		public class CheckPatch
		{
			private static int HealthBefore;

			private static bool Prefix(ref NewMovement __instance, int health)
			{
				HealthBefore = __instance.hp;
				return true;
			}

			private static void Postfix(int health)
			{
				if (HealthBefore + health <= MaxHealth)
				{
					NewMovement instance = MonoSingleton<NewMovement>.Instance;
					instance.hp += health;
				}
				if (MonoSingleton<NewMovement>.Instance.hp > MaxHealth)
				{
					MonoSingleton<NewMovement>.Instance.hp = MaxHealth;
				}
			}
		}

		public static int MaxHealth;

		private static MinMaxConfig WalkSpeedMult;

		private static MinMaxConfig Health;

		public static void GenerateConfigs()
		{
			WalkSpeedMult = new MinMaxConfig("Walk Speed", 1f, Plugin.PlayerPanel);
			Health = new MinMaxConfig("Health", 100f, Plugin.PlayerPanel);
		}

		[HarmonyPatch(typeof(NewMovement), "Start")]
		[HarmonyPostfix]
		public static void ApplyChanges(NewMovement __instance)
		{
			__instance.walkSpeed *= WalkSpeedMult.GetRand;
			MonoSingleton<NewMovement>.Instance.hp = (int)Health.GetRand;
			MaxHealth = MonoSingleton<NewMovement>.Instance.hp;
		}

		[HarmonyPatch(typeof(NewMovement), "Respawn")]
		[HarmonyPostfix]
		private static void HealthChange()
		{
			MonoSingleton<NewMovement>.Instance.hp = (int)Health.GetRand;
			MaxHealth = MonoSingleton<NewMovement>.Instance.hp;
		}
	}
	public class MinMaxConfig
	{
		private RandomConfig<float> _min;

		private RandomConfig<float> _max;

		public float Min => _min.Value;

		public float Max => _max.Value;

		public float GetRand => Random.Range(Min, Max);

		public MinMaxConfig(string name, float defaultVal, ConfigPanel panel)
		{
			_min = new RandomConfig<float>(panel, "Min " + name, defaultVal);
			_max = new RandomConfig<float>(panel, "Max " + name, defaultVal);
		}
	}
	[HarmonyPatch]
	public class ProjectileRandomizer : Randomizer<Projectile>
	{
		public static ProjectileRandomizer Instance = new ProjectileRandomizer();

		public static bool isReplacing = false;

		protected override RandomConfigValue GetConfigValue()
		{
			return Plugin.ChangeProjectiles.Value;
		}

		protected override int GetInstanceID(Projectile item)
		{
			string text = ((Object)((Component)item).gameObject).name.ToLower().Replace(" (Clone)", "");
			text = text.Replace("(Clone)", "");
			return text.GetHashCode();
		}

		public static void Init()
		{
			Projectile[] source = Resources.FindObjectsOfTypeAll<Projectile>();
			source = source.Where((Projectile x) => !x.decorative).ToArray();
			Instance.AddRangeToPool(source);
		}

		public static void ApplyCorrectThings(Projectile random, Projectile orig)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			random.safeEnemyType = orig.safeEnemyType;
			random.playerBullet = orig.playerBullet;
			random.target = orig.target;
			random.targetHandle = orig.targetHandle;
			random.friendly = orig.friendly;
		}

		[HarmonyPatch(typeof(Projectile), "Awake")]
		[HarmonyPrefix]
		public static bool Randomize(Projectile __instance)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (Instance.GetConfigValue() == RandomConfigValue.Disabled)
			{
				return true;
			}
			if (isReplacing)
			{
				return true;
			}
			if (__instance.decorative)
			{
				return true;
			}
			Projectile random = Instance.GetRandom(__instance);
			if ((Object)(object)random == (Object)null)
			{
				return true;
			}
			isReplacing = true;
			Projectile random2 = Object.Instantiate<Projectile>(random, ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
			isReplacing = false;
			ApplyCorrectThings(random2, __instance);
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	public abstract class Randomizer<T> where T : class
	{
		private readonly Dictionary<int, T> _map = new Dictionary<int, T>();

		private readonly HashSet<int> _usedIds = new HashSet<int>();

		public List<T> Pool { get; } = new List<T>();


		protected virtual int NextIndex(int count)
		{
			return Random.Range(0, count);
		}

		protected abstract int GetInstanceID(T item);

		protected abstract RandomConfigValue GetConfigValue();

		protected virtual void Log(string message)
		{
		}

		public void ResetMappings()
		{
			_map.Clear();
			_usedIds.Clear();
		}

		public void AddToPool(T item)
		{
			if (item != null)
			{
				int id = GetInstanceID(item);
				if (Pool.All((T p) => GetInstanceID(p) != id))
				{
					Pool.Add(item);
				}
			}
		}

		public virtual void Initialize()
		{
		}

		public void AddRangeToPool(IEnumerable<T> items)
		{
			foreach (T item in items)
			{
				AddToPool(item);
			}
		}

		public T GetRandom(T original = null, List<T> CPool = null)
		{
			if (CPool == null)
			{
				CPool = Pool;
			}
			if (CPool.Count == 0)
			{
				return original;
			}
			switch (GetConfigValue())
			{
			case RandomConfigValue.Disabled:
				return original;
			case RandomConfigValue.AlwaysUnique:
				return CPool[NextIndex(CPool.Count)];
			case RandomConfigValue.UniquePerKindWithDuplicates:
			{
				int key2 = ((original != null) ? GetInstanceID(original) : 0);
				if (!_map.TryGetValue(key2, out var value2))
				{
					value2 = CPool[NextIndex(CPool.Count)];
					_map[key2] = value2;
				}
				return value2;
			}
			case RandomConfigValue.UniquePerKind:
			{
				int key = ((original != null) ? GetInstanceID(original) : 0);
				if (!_map.TryGetValue(key, out var value))
				{
					List<T> list = CPool.Where((T item) => !_usedIds.Contains(GetInstanceID(item)) && GetInstanceID(item) != key).ToList();
					Log(string.Format("[UniquePerKind] key={0} | pool={1} | usedIds=[{2}] | available={3}", key, CPool.Count, string.Join(",", _usedIds), list.Count));
					if (list.Count == 0)
					{
						list = CPool.Where((T item) => GetInstanceID(item) != key).ToList();
						Log($"[UniquePerKind] key={key} | pool exhausted, falling back to {list.Count} candidates");
					}
					if (list.Count == 0)
					{
						return original;
					}
					value = list[NextIndex(list.Count)];
					_usedIds.Add(GetInstanceID(value));
					_map[key] = value;
					Log(string.Format("[UniquePerKind] key={0} -> assigned id={1} | usedIds now=[{2}]", key, GetInstanceID(value), string.Join(",", _usedIds)));
				}
				else
				{
					Log($"[UniquePerKind] key={key} -> already mapped to id={GetInstanceID(value)} (cache hit)");
				}
				return value;
			}
			default:
				return original;
			}
		}
	}
	public class ScaleRandomizer
	{
		public static MinMaxConfig ScaleMult;

		public static void GenerateConfigs()
		{
			ScaleMult = new MinMaxConfig("Scale Mult", 1f, Plugin.ChaosPanel);
		}

		public static void Init()
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			Transform[] array = Object.FindObjectsByType<Transform>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			Transform[] array2 = array;
			foreach (Transform val in array2)
			{
				if (Plugin.CanChangeObj(((Component)val).gameObject) && !(val is RectTransform) && !Object.op_Implicit((Object)(object)((Component)val).GetComponent<Canvas>()) && !Plugin.isPlayerChild(val) && !Plugin.isFirstRoomChild(val) && !Plugin.isFinalRoomChild(val) && !Plugin.isEnemyChild(val) && !Object.op_Implicit((Object)(object)((Component)val).gameObject.GetComponent<PlayerActivator>()))
				{
					val.localScale *= ScaleMult.GetRand;
				}
			}
		}
	}
	internal class SoundRandomizer : Randomizer<AudioClip>
	{
		[CompilerGenerated]
		private sealed class <GetAllAddressableClips>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SoundRandomizer <>4__this;

			private List<IResourceLocation> <allLocations>5__1;

			private IEnumerator<IResourceLocator> <>s__2;

			private IResourceLocator <locator>5__3;

			private List<object> <keys>5__4;

			private AsyncOperationHandle<IList<IResourceLocation>> <locHandle>5__5;

			private List<IResourceLocation>.Enumerator <>s__6;

			private IResourceLocation <location>5__7;

			private AsyncOperationHandle<AudioClip> <loadHandle>5__8;

			private Exception <ex>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				case -3:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 3:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<allLocations>5__1 = null;
				<>s__2 = null;
				<locator>5__3 = null;
				<keys>5__4 = null;
				<locHandle>5__5 = default(AsyncOperationHandle<IList<IResourceLocation>>);
				<>s__6 = default(List<IResourceLocation>.Enumerator);
				<location>5__7 = null;
				<loadHandle>5__8 = default(AsyncOperationHandle<AudioClip>);
				<ex>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Invalid comparison between Unknown and I4
				//IL_022f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0299: Unknown result type (might be due to invalid IL or missing references)
				//IL_029f: Invalid comparison between Unknown and I4
				//IL_023d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0242: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_025c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = Addressables.InitializeAsync();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<allLocations>5__1 = new List<IResourceLocation>();
						<>s__2 = Addressables.ResourceLocators.GetEnumerator();
						<>1__state = -3;
						goto IL_015c;
					case 2:
						<>1__state = -3;
						if ((int)<locHandle>5__5.Status == 1)
						{
							<allLocations>5__1.AddRange(<locHandle>5__5.Result);
						}
						Addressables.Release<IList<IResourceLocation>>(<locHandle>5__5);
						<keys>5__4 = null;
						<locHandle>5__5 = default(AsyncOperationHandle<IList<IResourceLocation>>);
						<locator>5__3 = null;
						goto IL_015c;
					case 3:
						{
							<>1__state = -4;
							if (<loadHandle>5__8.IsValid())
							{
								if ((int)<loadHandle>5__8.Status == 1)
								{
									<>4__this.AddToPool(<loadHandle>5__8.Result);
								}
								Addressables.Release<AudioClip>(<loadHandle>5__8);
							}
							<loadHandle>5__8 = default(AsyncOperationHandle<AudioClip>);
							<location>5__7 = null;
							break;
						}
						IL_015c:
						while (<>s__2.MoveNext())
						{
							<locator>5__3 = <>s__2.Current;
							<keys>5__4 = <locator>5__3.Keys.ToList();
							if (<keys>5__4.Count == 0)
							{
								continue;
							}
							<locHandle>5__5 = Addressables.LoadResourceLocationsAsync((IList<object>)<keys>5__4, (MergeMode)1, typeof(AudioClip));
							<>2__current = <locHandle>5__5;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>s__2 = null;
						<allLocations>5__1 = (from l in <allLocations>5__1
							group l by l.InternalId into g
							select g.First()).ToList();
						Plugin.Logger.LogInfo((object)$"[SoundRandomizer] Addressable clip locations: {<allLocations>5__1.Count}");
						<>s__6 = <allLocations>5__1.GetEnumerator();
						<>1__state = -4;
						break;
					}
					while (<>s__6.MoveNext())
					{
						<location>5__7 = <>s__6.Current;
						<loadHandle>5__8 = default(AsyncOperationHandle<AudioClip>);
						try
						{
							<loadHandle>5__8 = Addressables.LoadAssetAsync<AudioClip>(<location>5__7);
						}
						catch (Exception ex)
						{
							<ex>5__9 = ex;
							continue;
						}
						<>2__current = <loadHandle>5__8;
						<>1__state = 3;
						return true;
					}
					<>m__Finally2();
					<>s__6 = default(List<IResourceLocation>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>s__6).Dispose();
			}

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

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

			private object <>2__current;

			public SoundRandomizer <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Expected O, but got Unknown
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.AddRangeToPool(Resources.FindObjectsOfTypeAll<AudioClip>());
					Plugin.Logger.LogInfo((object)$"[SoundRandomizer] Resources clips: {<>4__this.Pool.Count}");
					<>2__current = <>4__this.GetAllAddressableClips();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.ResetMappings();
					Plugin.Logger.LogInfo((object)$"[SoundRandomizer] Total clips: {<>4__this.Pool.Count}");
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>4__this.RandomizeAllExistingAudioSources();
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>4__this.RandomizeAllExistingAudioSourc