using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using BillionDifficulty.EnemyPatches;
using Configgy;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using ULTRAKILL.Cheats;
using ULTRAKILL.Enemy;
using ULTRAKILL.Portal;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
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: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("BillionDifficulty")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("2.1.1.0")]
[assembly: AssemblyInformationalVersion("2.1.1+fb660c27184355245c5aadd8dd1e4239dc6cf11f")]
[assembly: AssemblyProduct("Billion Difficulty")]
[assembly: AssemblyTitle("BillionDifficulty")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.1.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BillionDifficulty
{
	public class Util
	{
		public static bool IsDifficulty(int difficulty)
		{
			return MonoSingleton<PrefsManager>.Instance.GetInt("difficulty", 0) == difficulty;
		}

		public static int GetDifficulty()
		{
			return MonoSingleton<PrefsManager>.Instance.GetInt("difficulty", 0);
		}

		public static bool IsHardMode()
		{
			return ((ConfigValueElement<bool>)(object)Plugin.IsBrilliantBillion).Value && IsDifficulty(19);
		}

		public static T[] AddToArray<T>(ref T[] array, T element, int index = -1)
		{
			if (index == -1)
			{
				index = array.Length;
			}
			List<T> list = array.ToList();
			list.Insert(index, element);
			array = list.ToArray();
			return array;
		}

		public static T[] AddToArray<T>(ref T[] array, T[] elements, int index = -1)
		{
			if (index == -1)
			{
				index = array.Length;
			}
			int num = 0;
			int num2 = index;
			List<T> list = array.ToList();
			while (num < elements.Length)
			{
				list.Insert(num2, elements[num]);
				num++;
				num2++;
			}
			array = list.ToArray();
			return array;
		}

		public static Texture2D LoadEmbeddedTexture(string resourceName)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			using Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
			if (stream == null)
			{
				Plugin.Logger.LogError((object)("Embedded resource '" + resourceName + "' not found"));
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			Texture2D val = new Texture2D(2, 2);
			if (ImageConversion.LoadImage(val, array))
			{
				return val;
			}
			Plugin.Logger.LogError((object)"Failed to load embedded texture");
			return null;
		}
	}
	[BepInPlugin("billy.billiondifficulty", "Billion Difficulty", "2.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("ULTRAKILL.exe")]
	public class Plugin : BaseUnityPlugin
	{
		private ConfigBuilder config;

		[Configgable("", "Brilliant Billion mode", 0, "A very difficult mode intended to make the main campaign a lot harder (doesn't properly update enemies that are already spawned)")]
		public static ConfigToggle IsBrilliantBillion = new ConfigToggle(false);

		public static bool StayedOnHardMode = false;

		public const int BlueFilthRarity = 250;

		private static readonly Harmony Harmony = new Harmony("billy.billiondifficulty");

		internal static ManualLogSource Logger;

		private static bool loadedAssets = false;

		public static Texture2D blueFilthTexture = Util.LoadEmbeddedTexture("BillionDifficulty.assets.zombie_MeleeHusk_MouthOpen_Diffuse.png");

		public static Texture2D blueFilthBiteTexture = Util.LoadEmbeddedTexture("BillionDifficulty.assets.zombie_MeleeHusk_MouthClosed_Diffuse.png");

		public static Dictionary<string, GameObject> Prefabs = new Dictionary<string, GameObject>
		{
			["ProjectileExplosiveHH"] = null,
			["ProjectileHoming"] = null,
			["Projectile"] = null,
			["GasolineProjectile"] = null,
			["ExplosionSuper"] = null,
			["Explosion"] = null,
			["PumpChargeSound"] = null,
			["MirrorReaperGroundWave"] = null,
			["ProjectileHomingAcid"] = null,
			["ProjectileHomingExplosive"] = null,
			["ProjectileMinosPrimeSnake"] = null,
			["ExplosionSisyphusPrimeCharged"] = null,
			["BlackHoleEnemy"] = null,
			["VirtueInsignia"] = null,
			["GeryonForwardArrowBeam"] = null,
			["PhysicalShockwave"] = null,
			["GoopLarge"] = null,
			["GoopLargeLong"] = null
		};

		public static AudioClip PumpCharge = null;

		public void Awake()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			Harmony.PatchAll();
			Logger.LogInfo((object)"Plugin BillionDifficulty is loaded! WOAHHHH");
			SceneManager.activeSceneChanged += SceneManagerActiveSceneChanged;
			GetAssets();
			config = new ConfigBuilder("billy.billiondifficulty", "Billion Difficulty");
			ConfigToggle isBrilliantBillion = IsBrilliantBillion;
			((ConfigValueElement<bool>)(object)isBrilliantBillion).OnValueChanged = (Action<bool>)Delegate.Combine(((ConfigValueElement<bool>)(object)isBrilliantBillion).OnValueChanged, new Action<bool>(HardModeValueChanged));
			config.BuildAll();
		}

		public void SceneManagerActiveSceneChanged(Scene arg0, Scene arg1)
		{
			if (SceneHelper.CurrentScene == "Main Menu")
			{
				AddDifficultyButton();
			}
			StayedOnHardMode = Util.IsHardMode();
		}

		public static void HardModeValueChanged(bool v)
		{
			string text = (v ? "BRILLIANT BILLION" : "BILLION");
			StayedOnHardMode = false;
			if (SceneHelper.CurrentScene != "Main Menu")
			{
				text = "BILLION";
			}
			DifficultyTitle[] array = Object.FindObjectsByType<DifficultyTitle>((FindObjectsSortMode)0);
			foreach (DifficultyTitle val in array)
			{
				val.Check();
			}
			PresenceController val2 = Object.FindAnyObjectByType<PresenceController>();
			if ((Object)(object)val2 != (Object)null && val2.diffNames.Length >= 20 && !(text == val2.diffNames[19]))
			{
				val2.diffNames[19] = text;
				DiscordController val3 = Object.FindAnyObjectByType<DiscordController>();
				if (val3 != null)
				{
					val3.FetchSceneActivity(SceneHelper.CurrentScene);
				}
				SteamController val4 = Object.FindAnyObjectByType<SteamController>();
				if (val4 != null)
				{
					val4.FetchSceneActivity(SceneHelper.CurrentScene);
				}
			}
		}

		public static T Ass<T>(string path)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return Addressables.LoadAssetAsync<T>((object)path).WaitForCompletion();
		}

		public static void GetAssets()
		{
			if (!loadedAssets)
			{
				Prefabs["ProjectileExplosiveHH"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Explosive HH.prefab");
				Prefabs["ProjectileHoming"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Homing.prefab");
				Prefabs["Projectile"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile.prefab");
				Prefabs["GasolineProjectile"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/GasolineProjectile.prefab");
				Prefabs["ExplosionSuper"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Super.prefab");
				Prefabs["Explosion"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion.prefab");
				Prefabs["PumpChargeSound"] = Ass<GameObject>("Assets/Particles/SoundBubbles/PumpChargeSound.prefab");
				PumpCharge = Ass<AudioClip>("Assets/Sounds/Weapons/pumpCharge.wav");
				Prefabs["MirrorReaperGroundWave"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/MirrorReaperGroundWave.prefab");
				Prefabs["ProjectileHomingAcid"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Homing Acid.prefab");
				((Component)Prefabs["ProjectileHomingAcid"].transform.Find("GoopCloud")).gameObject.AddComponent<RemoveOnRespawn>();
				((Component)Prefabs["ProjectileHomingAcid"].transform.Find("GoopCloud")).GetComponent<RemoveOnTime>().time = 10f;
				Prefabs["ProjectileHomingExplosive"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Homing Explosive.prefab");
				Prefabs["ProjectileMinosPrimeSnake"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/Projectile Minos Prime Snake.prefab");
				Prefabs["ExplosionSisyphusPrimeCharged"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sisyphus Prime Charged.prefab");
				Prefabs["BlackHoleEnemy"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/Black Hole Enemy.prefab");
				Prefabs["VirtueInsignia"] = Ass<GameObject>("Virtue Insignia");
				Prefabs["GeryonForwardArrowBeam"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/GeryonForwardArrowBeam.prefab");
				Prefabs["PhysicalShockwave"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/PhysicalShockwave.prefab");
				Prefabs["GoopLarge"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/GoopLarge.prefab");
				Prefabs["GoopLargeLong"] = Ass<GameObject>("Assets/Prefabs/Attacks and Projectiles/GoopLargeLong.prefab");
				loadedAssets = true;
			}
		}

		public Transform FindCanvas()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			return (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
				where ((Object)obj).name == "Canvas"
				select obj).First().transform;
		}

		public void AddDifficultyButton()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			Transform val = FindCanvas();
			Transform val2 = val.Find("Difficulty Select (1)").Find("Interactables");
			Transform transform = Object.Instantiate<GameObject>(((Component)val2.Find("Brutal")).gameObject, val2).transform;
			DifficultySelectButton component = ((Component)transform).GetComponent<DifficultySelectButton>();
			component.difficulty = 19;
			transform.position += new Vector3(700f, 82.5f);
			TextMeshProUGUI component2 = ((Component)transform.Find("Name")).GetComponent<TextMeshProUGUI>();
			((TMP_Text)component2).text = "BILLION";
			((Graphic)component2).color = Color.white;
			Button component3 = ((Component)component).GetComponent<Button>();
			((Selectable)component3).interactable = true;
			Transform val3 = val2.Find("Brutal Info");
			Transform difficultyInfo = Object.Instantiate<GameObject>(((Component)val3).gameObject, val3.parent).transform;
			Transform val4 = difficultyInfo.Find("Text");
			((Component)difficultyInfo.Find("Text")).GetComponent<TMP_Text>().text = "<color=white>A step up from the brutal difficulty. Faster enemies, changed attacks. Designed to make the game harder while not being annoying.</color>\n\n<color=purple>Requires quick reflexes, knowledge of your arsenal and the enemies.</color>";
			TMP_Text component4 = (TMP_Text)(object)((Component)difficultyInfo.Find("Title (1)")).GetComponent<TextMeshProUGUI>();
			component4.fontSize = 46f;
			component4.text = "--BILLION--";
			EventTrigger component5 = ((Component)component).GetComponent<EventTrigger>();
			component5.triggers.Clear();
			Entry val5 = new Entry();
			val5.eventID = (EventTriggerType)0;
			((UnityEvent<BaseEventData>)(object)val5.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				((Component)difficultyInfo).gameObject.SetActive(true);
			});
			component5.triggers.Add(val5);
			Entry val6 = new Entry();
			val6.eventID = (EventTriggerType)1;
			((UnityEvent<BaseEventData>)(object)val6.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				((Component)difficultyInfo).gameObject.SetActive(false);
			});
			component5.triggers.Add(val6);
			Entry val7 = new Entry();
			val7.eventID = (EventTriggerType)4;
			((UnityEvent<BaseEventData>)(object)val7.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				((Component)difficultyInfo).gameObject.SetActive(false);
			});
			component5.triggers.Add(val7);
		}

		public static GameObject CreateVirtueInsignia(float scaleMult, float windUpSpeedMult, float explosionLength, Vector3 targetPosition, Vector3 lookAtPosition, EnemyTarget enemyTarget, Enemy enemy, float totalDamageMult, float lightIntensityMultiplier = 1f)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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)
			GameObject val = Object.Instantiate<GameObject>(Prefabs["VirtueInsignia"], targetPosition, Quaternion.identity);
			val.SetActive(false);
			Transform transform = val.transform;
			transform.localScale *= scaleMult;
			VirtueInsignia component = val.GetComponent<VirtueInsignia>();
			component.noTracking = true;
			component.target = enemyTarget;
			component.parentEnemy = enemy;
			component.hadParent = true;
			component.windUpSpeedMultiplier = windUpSpeedMult;
			component.explosionLength = explosionLength;
			component.damage = Mathf.RoundToInt((float)component.damage * totalDamageMult);
			Light[] componentsInChildren = val.GetComponentsInChildren<Light>(true);
			foreach (Light val2 in componentsInChildren)
			{
				val2.intensity *= lightIntensityMultiplier;
			}
			val.transform.LookAt(lookAtPosition);
			val.transform.Rotate(-90f, 0f, 180f);
			val.SetActive(true);
			return val;
		}

		public static void SetEnemyWeakness(string name, float value, EnemyIdentifier eid)
		{
			int num = Array.IndexOf(eid.weaknesses, name);
			if (num != -1)
			{
				eid.weaknessMultipliers[num] = value;
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "BillionDifficulty";

		public const string PLUGIN_NAME = "Billion Difficulty";

		public const string PLUGIN_VERSION = "2.1.1";
	}
}
namespace BillionDifficulty.SetupPatches
{
	[HarmonyPatch(typeof(GameProgressSaver), "GetProgress")]
	public class GetProgressPatch
	{
		public static bool Prefix(int difficulty, ref int __result)
		{
			int num = 1;
			int[] array = new int[7] { 0, 1, 2, 3, 4, 5, 19 };
			int i = ((ReadOnlySpan<int>)array).IndexOf(difficulty);
			if (i == -1)
			{
				i = 0;
			}
			for (; i < array.Length; i++)
			{
				GameProgressData gameProgress = GameProgressSaver.GetGameProgress(array[i]);
				if (gameProgress != null && gameProgress.difficulty == array[i] && gameProgress.levelNum > num)
				{
					num = gameProgress.levelNum;
				}
			}
			__result = num;
			return false;
		}
	}
	[HarmonyPatch(typeof(GameProgressSaver), "GetPrime")]
	public class GetPrimePatch
	{
		public static bool Prefix(ref int difficulty, ref int level, ref int __result)
		{
			if (SceneHelper.IsPlayingCustom)
			{
				__result = 0;
				return false;
			}
			level--;
			int num = 0;
			int[] array = new int[7] { 0, 1, 2, 3, 4, 5, 19 };
			int i = ((ReadOnlySpan<int>)array).IndexOf(difficulty);
			if (i == -1)
			{
				i = 0;
			}
			for (; i < array.Length; i++)
			{
				GameProgressData gameProgress = GameProgressSaver.GetGameProgress(array[i]);
				if (gameProgress != null && gameProgress.difficulty == array[i] && gameProgress.primeLevels != null && gameProgress.primeLevels.Length > level && gameProgress.primeLevels[level] > num)
				{
					Debug.Log((object)("Highest: . Data: " + gameProgress.primeLevels[level]));
					if (gameProgress.primeLevels[level] >= 2)
					{
						__result = 2;
						return false;
					}
					num = gameProgress.primeLevels[level];
				}
			}
			__result = num;
			return false;
		}
	}
	[HarmonyPatch(typeof(GameProgressSaver), "GetEncoreProgress")]
	public class GetEncoreProgressPatch
	{
		public static bool Prefix(int difficulty, ref int __result)
		{
			int num = 0;
			int[] array = new int[7] { 0, 1, 2, 3, 4, 5, 19 };
			int i = ((ReadOnlySpan<int>)array).IndexOf(difficulty);
			if (i == -1)
			{
				i = 0;
			}
			for (; i < array.Length; i++)
			{
				GameProgressData gameProgress = GameProgressSaver.GetGameProgress(array[i]);
				if (gameProgress != null && gameProgress.difficulty == array[i] && gameProgress.encores > num)
				{
					num = gameProgress.encores;
				}
			}
			__result = num;
			return false;
		}
	}
	[HarmonyPatch(typeof(GameProgressSaver), "DifficultySavePath")]
	public class DifficultySavePathPatch
	{
		public static void Postfix(int diff, ref object __result)
		{
			if (diff == 19)
			{
				__result = Path.Combine(GameProgressSaver.BaseSavePath, $"Slot{GameProgressSaver.currentSlot + 1}", "difficulty19progress.bepis");
			}
		}
	}
	[HarmonyPatch(typeof(GameProgressSaver), "LevelProgressPath")]
	public class LevelProgressPathPatch
	{
		public static void Postfix(int lvl, ref string __result)
		{
			if (Util.IsDifficulty(19))
			{
				string[] array = Path.GetFileName(__result).Split(".");
				if (array.Length != 0 && !__result.Contains("difficulty19"))
				{
					array[0] = "difficulty19" + array[0];
					__result = Path.Join(Path.GetDirectoryName(__result).AsSpan(), string.Join(".", array).AsSpan());
				}
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class CGPathPatch
	{
		public static bool Prefix(ref string __result)
		{
			if (Util.GetDifficulty() != 19)
			{
				return true;
			}
			__result = Path.Combine(GameProgressSaver.SavePath, "cybergrindhighscore19.bepis");
			return false;
		}
	}
	[HarmonyPatch(typeof(GameProgressSaver), "GetDirectorySlotData")]
	public class GetDirectorySlotDataPatch
	{
		public static bool Prefix(string path, ref object __result)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			if (!Util.IsDifficulty(19))
			{
				return true;
			}
			Debug.Log((object)("Generating SlotData for " + path));
			int num = 0;
			int num2 = 0;
			object obj = GameProgressSaver.ReadFile(Path.Combine(path, "difficulty19progress.bepis"));
			GameProgressData val = (GameProgressData)((obj is GameProgressData) ? obj : null);
			if (val != null && (val.levelNum > num || (val.levelNum == num && val.difficulty > num2)))
			{
				num = val.levelNum;
				num2 = val.difficulty;
			}
			__result = (object)new SlotData
			{
				exists = true,
				highestDifficulty = num2,
				highestLvlNumber = num
			};
			return false;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class RankDataConstructorPatch
	{
		public static bool Prefix(StatsManager sman, RankData __instance)
		{
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			int difficulty = Util.GetDifficulty();
			__instance.levelNumber = sman.levelNumber;
			RankData rank = GameProgressSaver.GetRank(true, -1);
			if (rank != null)
			{
				__instance.ranks = rank.ranks;
				if (rank.majorAssists != null)
				{
					__instance.majorAssists = rank.majorAssists;
				}
				else
				{
					__instance.majorAssists = new bool[20];
				}
				if (rank.stats != null)
				{
					__instance.stats = rank.stats;
				}
				else
				{
					__instance.stats = (RankScoreData[])(object)new RankScoreData[20];
				}
				if ((sman.rankScore >= rank.ranks[difficulty] && (rank.majorAssists == null || (!sman.majorUsed && rank.majorAssists[difficulty]))) || sman.rankScore > rank.ranks[difficulty] || rank.levelNumber != __instance.levelNumber)
				{
					__instance.majorAssists[difficulty] = sman.majorUsed;
					__instance.ranks[difficulty] = sman.rankScore;
					if (__instance.stats[difficulty] == null)
					{
						__instance.stats[difficulty] = new RankScoreData();
					}
					__instance.stats[difficulty].kills = sman.kills;
					__instance.stats[difficulty].style = sman.stylePoints;
					__instance.stats[difficulty].time = sman.seconds;
				}
				__instance.secretsAmount = sman.secretObjects.Length;
				__instance.secretsFound = new bool[__instance.secretsAmount];
				for (int i = 0; i < __instance.secretsAmount && i < rank.secretsFound.Length; i++)
				{
					if ((Object)(object)sman.secretObjects[i] == (Object)null || rank.secretsFound[i])
					{
						__instance.secretsFound[i] = true;
					}
				}
				__instance.challenge = rank.challenge;
				return false;
			}
			__instance.ranks = new int[20];
			__instance.stats = (RankScoreData[])(object)new RankScoreData[20];
			if (__instance.stats[difficulty] == null)
			{
				__instance.stats[difficulty] = new RankScoreData();
			}
			__instance.majorAssists = new bool[20];
			for (int j = 0; j < __instance.ranks.Length; j++)
			{
				__instance.ranks[j] = -1;
			}
			__instance.ranks[difficulty] = sman.rankScore;
			__instance.majorAssists[difficulty] = sman.majorUsed;
			__instance.stats[difficulty].kills = sman.kills;
			__instance.stats[difficulty].style = sman.stylePoints;
			__instance.stats[difficulty].time = sman.seconds;
			__instance.secretsAmount = sman.secretObjects.Length;
			__instance.secretsFound = new bool[__instance.secretsAmount];
			for (int k = 0; k < __instance.secretsAmount; k++)
			{
				if ((Object)(object)sman.secretObjects[k] == (Object)null)
				{
					__instance.secretsFound[k] = true;
				}
			}
			return false;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class GetRankDataPatch
	{
		public static bool Prefix(ref string path, int lvl, bool returnNull, ref RankData __result)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (!Util.IsDifficulty(19))
			{
				return true;
			}
			GameProgressSaver.PrepareFs();
			string resolveCurrentLevelPath = GameProgressSaver.resolveCurrentLevelPath;
			string text = GameProgressSaver.LevelProgressPath(lvl);
			if (text == "")
			{
				return false;
			}
			path = ((lvl < 0) ? resolveCurrentLevelPath : text);
			object obj = GameProgressSaver.ReadFile(path);
			RankData val = (RankData)((obj is RankData) ? obj : null);
			if (val == null)
			{
				val = (returnNull ? ((RankData)null) : new RankData(MonoSingleton<StatsManager>.Instance));
				if (val == null)
				{
					__result = null;
					return false;
				}
			}
			if (val.ranks.Length < 20)
			{
				Array.Resize(ref val.ranks, 20);
				val.ranks[19] = -1;
			}
			if (val.majorAssists.Length < 20)
			{
				Array.Resize(ref val.majorAssists, 20);
			}
			if (val.secretsFound.Length < 20)
			{
				Array.Resize(ref val.secretsFound, 20);
			}
			if (val.stats.Length < 20)
			{
				Array.Resize(ref val.stats, 20);
			}
			__result = val;
			return false;
		}
	}
	[HarmonyPatch(typeof(GameProgressSaver), "GetCyberRankData")]
	public class GetCyberRankDataPatch
	{
		public static bool Prefix(ref CyberRankData __result)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			if (Util.GetDifficulty() != 19)
			{
				return true;
			}
			string cyberGrindHighScorePath = GameProgressSaver.cyberGrindHighScorePath;
			object obj = GameProgressSaver.ReadFile(cyberGrindHighScorePath);
			CyberRankData val = (CyberRankData)((obj is CyberRankData) ? obj : null);
			if (val == null)
			{
				val = new CyberRankData();
			}
			if (val.preciseWavesByDifficulty == null)
			{
				val.preciseWavesByDifficulty = new float[20];
			}
			else if (val.preciseWavesByDifficulty.Length < 20)
			{
				Array.Resize(ref val.preciseWavesByDifficulty, 20);
			}
			if (val.style == null)
			{
				val.style = new int[20];
			}
			else if (val.style.Length < 20)
			{
				Array.Resize(ref val.style, 20);
			}
			if (val.kills == null)
			{
				val.kills = new int[20];
			}
			else if (val.kills.Length < 20)
			{
				Array.Resize(ref val.kills, 20);
			}
			if (val.time == null)
			{
				val.time = new float[20];
			}
			else if (val.time.Length < 20)
			{
				Array.Resize(ref val.time, 20);
			}
			__result = val;
			return false;
		}
	}
	[HarmonyPatch(typeof(PrefsManager), "EnsureValid")]
	public class EnsureValidPatch
	{
		public static bool Prefix(ref object __result, string key, object value)
		{
			if (key != "difficulty" || (int)value != 19)
			{
				return true;
			}
			__result = 19;
			return false;
		}
	}
	[HarmonyPatch(typeof(DifficultyTitle), "Check")]
	public class DifficultyTitlePatch
	{
		public static void Postfix(DifficultyTitle __instance)
		{
			if (!Util.IsDifficulty(19))
			{
				return;
			}
			bool flag = Util.IsHardMode() && (Plugin.StayedOnHardMode || SceneHelper.CurrentScene == "Main Menu");
			bool flag2 = Util.IsHardMode() && !Plugin.StayedOnHardMode;
			string text = "BILLION";
			if (flag)
			{
				text = "BRILLIANT BILLION";
			}
			else if (flag2)
			{
				text = "BILLION*";
			}
			__instance.txt2.text = (__instance.lines ? ("-- " + text + " --") : text);
			FinalRank[] array = Object.FindObjectsByType<FinalRank>((FindObjectsSortMode)0);
			if (array == null || array.Length == 0)
			{
				return;
			}
			FinalRank val = array[0];
			Transform val2 = ((Component)val).transform.Find("Title");
			string text2 = ((TMP_Text)((Component)val2.Find("Text")).GetComponent<TextMeshProUGUI>()).text;
			string arg;
			if (text2.StartsWith("8-4:"))
			{
				arg = "ffaaaa";
			}
			else if (text2.StartsWith("P-1:"))
			{
				arg = "aaffff";
			}
			else if (text2.StartsWith("P-2:"))
			{
				arg = "ffccaa";
			}
			else if (text2.StartsWith("0-E:"))
			{
				arg = "aaccff";
			}
			else if (text2.StartsWith("1-E:"))
			{
				arg = "aaaaaa";
			}
			else if (text2.StartsWith("2-E:"))
			{
				arg = "ffbb99";
			}
			else if (text2.StartsWith("3-E:"))
			{
				arg = "ccffaa";
			}
			else
			{
				if (!text2.StartsWith("9-2:") && !text2.StartsWith("P-") && !text2.Contains("-E"))
				{
					return;
				}
				arg = "ffffff";
			}
			string text3 = $"<color=#{arg}>BILLION</color>S MUST HAVE FUN";
			if (flag)
			{
				text3 = $"<color=#{arg}>BRILLIANT</color> BILLION";
			}
			else if (flag2)
			{
				text3 = $"<color=#{arg}>BILLION</color>S MUST HAVE FUN*";
			}
			__instance.txt2.text = (__instance.lines ? ("-- " + text3 + " --") : text3);
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class CanSubmitScoresPatch
	{
		public static bool Prefix(ref bool __result)
		{
			if (!Util.IsDifficulty(19))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(StatsManager), "SendInfo")]
	public class SendInfoPatch
	{
		public static void Postfix()
		{
			Plugin.Logger.LogWarning((object)("Score submitted: " + LeaderboardController.CanSubmitScores));
		}
	}
	[HarmonyPatch(typeof(FinalCyberRank), "GameOver")]
	public class CyberGameOverPatch
	{
		public static void Postfix()
		{
			if (Util.IsDifficulty(19))
			{
				Plugin.Logger.LogWarning((object)("Score submitted: " + LeaderboardController.CanSubmitScores));
			}
		}
	}
	[HarmonyPatch(typeof(PresenceController), "Start")]
	public class PresenceControllerPatch
	{
		public static void Prefix(PresenceController __instance)
		{
			if (__instance.diffNames.Length < 20)
			{
				Array.Resize(ref __instance.diffNames, 20);
			}
			__instance.diffNames[19] = (Util.IsHardMode() ? "BRILLIANT BILLION" : "BILLION");
		}
	}
}
namespace BillionDifficulty.GenaralPatches
{
	[HarmonyPatch(typeof(ZombieMelee), "Start")]
	public class BlueFilthPatch
	{
		public static void Postfix(ZombieMelee __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			if (__instance.difficulty == 19 && (int)__instance.eid.enemyType == 3 && Random.Range(0, 250) == 0)
			{
				Material val = Object.Instantiate<Material>(__instance.originalMaterial);
				Material val2 = Object.Instantiate<Material>(__instance.biteMaterial);
				val.mainTexture = (Texture)(object)Plugin.blueFilthTexture;
				val2.mainTexture = (Texture)(object)Plugin.blueFilthBiteTexture;
				__instance.originalMaterial = val;
				__instance.biteMaterial = val2;
				SkinnedMeshRenderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<SkinnedMeshRenderer>();
				foreach (SkinnedMeshRenderer val3 in componentsInChildren)
				{
					((Renderer)val3).material = val;
					MaterialPropertyBlock val4 = new MaterialPropertyBlock();
					((Renderer)val3).GetPropertyBlock(val4);
					val4.SetTexture("_MainTex", (Texture)(object)Plugin.blueFilthTexture);
					((Renderer)val3).SetPropertyBlock(val4);
				}
			}
		}
	}
	[HarmonyPatch(typeof(EndlessGrid))]
	public class EndlessGridPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(EndlessGrid), "NextWave")]
		public static void NextWavePrefix()
		{
			if (Util.IsDifficulty(19))
			{
				EndlessGridPatch.DestroyAllOfType<SandificationZone>();
				EndlessGridPatch.DestroyAllOfType<SlowDownOverTime>();
				EndlessGridPatch.DestroyAllOfType<SlowDownOverTimeEase>();
			}
		}

		public static void DestroyAllOfType<T>() where T : Component
		{
			T[] array = Object.FindObjectsByType<T>((FindObjectsSortMode)0);
			T[] array2 = array;
			foreach (T val in array2)
			{
				Object.Destroy((Object)(object)((Component)((Component)val).transform.root).gameObject);
			}
		}
	}
	[HarmonyPatch(typeof(Projectile), "Explode")]
	public class ExplosionPatch
	{
		public static bool Prefix(Projectile __instance)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			if (!Util.IsDifficulty(19))
			{
				return true;
			}
			if (!__instance.active)
			{
				return false;
			}
			ShockwaveOnExplode component = ((Component)__instance).GetComponent<ShockwaveOnExplode>();
			if ((Object)(object)component != (Object)null)
			{
				component.SpawnShockwave(((Component)__instance).transform.position);
			}
			__instance.active = false;
			if (__instance.keepTrail)
			{
				__instance.KeepTrail();
			}
			GameObject val = Object.Instantiate<GameObject>(__instance.explosionEffect, ((Component)__instance).transform.position - __instance.rb.velocity * 0.02f, ((Component)__instance).transform.rotation);
			Explosion[] componentsInChildren = val.GetComponentsInChildren<Explosion>();
			foreach (Explosion val2 in componentsInChildren)
			{
				val2.sourceWeapon = __instance.sourceWeapon ?? val2.sourceWeapon;
				if (__instance.bigExplosion)
				{
					val2.maxSize *= 1.5f;
				}
				if (val2.damage != 0)
				{
					val2.damage = Mathf.RoundToInt(__instance.damage);
				}
				val2.enemy = true;
				if (__instance.difficulty != 19)
				{
					continue;
				}
				BillionExplosionController component2 = ((Component)val2).GetComponent<BillionExplosionController>();
				if ((Object)(object)component2 != (Object)null)
				{
					val2.maxSize *= component2.maxSizeMultiplier;
					val2.speed *= component2.speedMultiplier;
					val2.enemyDamageMultiplier *= component2.enemyDamageMultiplier;
					if (component2.damage == -1)
					{
						val2.damage = Mathf.RoundToInt(component2.damageMultiplier * (float)val2.damage);
					}
					else
					{
						val2.damage = component2.damage;
					}
				}
			}
			MonoSingleton<StainVoxelManager>.Instance.TryIgniteAt(((Component)__instance).transform.position, 3);
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	[HarmonyPatch(typeof(StyleCalculator), "AddPoints")]
	public class FriendlyFirePatch
	{
		public static void Prefix(ref int points, string pointName, EnemyIdentifier eid, GameObject sourceWeapon)
		{
			if (pointName == "ultrakill.friendlyfire" && Util.IsDifficulty(19))
			{
				points = Mathf.RoundToInt((float)points * 0.2f);
			}
		}
	}
	[HarmonyPatch(typeof(NewMovement))]
	public class NewMovementPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(NewMovement), "GetHurt")]
		public static bool GetHurtPrefix(NewMovement __instance, out float __state)
		{
			__state = __instance.antiHp;
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(NewMovement), "GetHurt")]
		public static void GetHurtPostfix(NewMovement __instance, float __state)
		{
			if (__instance.difficulty == 19)
			{
				float num = __instance.antiHp - __state;
				if (num > 0f)
				{
					num *= 1.4285715f;
					__instance.antiHp = __state + num;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(NewMovement), "Respawn")]
		public static void RespawnPostfix(NewMovement __instance)
		{
			if (__instance.difficulty == 19)
			{
				StreetcleanerAfterburn[] array = Object.FindObjectsByType<StreetcleanerAfterburn>((FindObjectsSortMode)0);
				StreetcleanerAfterburn[] array2 = array;
				foreach (StreetcleanerAfterburn streetcleanerAfterburn in array2)
				{
					streetcleanerAfterburn.ticks = streetcleanerAfterburn.tickCount;
				}
				RemoveOnRespawn[] array3 = Object.FindObjectsByType<RemoveOnRespawn>((FindObjectsSortMode)0);
				RemoveOnRespawn[] array4 = array3;
				foreach (RemoveOnRespawn removeOnRespawn in array4)
				{
					Object.Destroy((Object)(object)((Component)removeOnRespawn).gameObject);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Punch), "ParriedProjectileBeam")]
	public class PunchPatch
	{
		public static bool Prefix(ContinuousBeam beam)
		{
			if (!Util.IsDifficulty(19))
			{
				return true;
			}
			if ((Object)(object)beam == (Object)null)
			{
				return false;
			}
			if (beam.enemy)
			{
				beam.parryMultiplier = 2.5f;
			}
			beam.enemy = false;
			beam.canHitPlayer = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(EnemyIdentifier), "Start")]
	public class RadiancePatch
	{
		public static void Postfix(EnemyIdentifier __instance)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			if (!Util.IsDifficulty(19))
			{
				return;
			}
			EnemyType enemyType = __instance.enemyType;
			EnemyType val = enemyType;
			if ((int)val <= 19)
			{
				if ((int)val == 3)
				{
					if (Util.IsHardMode())
					{
						__instance.healthBuffModifier = 1.6666666f;
					}
					return;
				}
				if ((int)val == 9)
				{
					goto IL_006d;
				}
				if ((int)val == 19)
				{
					goto IL_007a;
				}
			}
			else if ((int)val <= 26)
			{
				if ((int)val == 20)
				{
					goto IL_006d;
				}
				if ((int)val == 26)
				{
					goto IL_007a;
				}
			}
			else if ((int)val == 38 || (int)val == 40)
			{
				goto IL_007a;
			}
			__instance.speedBuffModifier = 1.25f;
			return;
			IL_006d:
			__instance.speedBuffModifier = 1.1f;
			return;
			IL_007a:
			__instance.speedBuffModifier = 1.15f;
		}
	}
	[HarmonyPatch(typeof(EnemyIdentifier), "SpeedBuff", new Type[] { typeof(float) })]
	public class RadianceSpeedPatch
	{
		public static bool Prefix(float modifier, EnemyIdentifier __instance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Invalid comparison between Unknown and I4
			if (__instance.difficulty != 19)
			{
				return true;
			}
			__instance.speedBuffRequests++;
			EnemyType enemyType = __instance.enemyType;
			EnemyType val = enemyType;
			if ((int)val <= 20)
			{
				if ((int)val != 9)
				{
					if ((int)val == 19)
					{
						goto IL_0069;
					}
					if ((int)val != 20)
					{
						goto IL_0076;
					}
				}
				__instance.speedBuffModifier = 1.1f;
				goto IL_0083;
			}
			if ((int)val == 26 || (int)val == 38 || (int)val == 40)
			{
				goto IL_0069;
			}
			goto IL_0076;
			IL_0083:
			__instance.UpdateBuffs(false, true);
			return false;
			IL_0076:
			__instance.speedBuffModifier = 1.25f;
			goto IL_0083;
			IL_0069:
			__instance.speedBuffModifier = 1.15f;
			goto IL_0083;
		}
	}
	[HarmonyPatch(typeof(EnemyIdentifier), "HealthBuff", new Type[] { typeof(float) })]
	public class RadianceHealthPatch
	{
		public static bool Prefix(float modifier, EnemyIdentifier __instance)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			if (!Util.IsHardMode())
			{
				return true;
			}
			__instance.healthBuffRequests++;
			if ((int)__instance.enemyType == 3)
			{
				__instance.healthBuffModifier = 1.6666666f;
			}
			__instance.UpdateBuffs(false, true);
			return false;
		}
	}
	[HarmonyPatch(typeof(StyleHUD))]
	public class StyleHUDPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(StyleHUD), "Start")]
		public static void StartPostfix(StyleHUD __instance)
		{
			if (!__instance.idNameDict.ContainsKey("billion.blue"))
			{
				__instance.idNameDict.Add("billion.blue", "<color=#00ffffff>I'M BLUE</color>");
			}
		}
	}
}
namespace BillionDifficulty.EnemyPatches
{
	[HarmonyPatch(typeof(CancerousRodent))]
	public class CancerousRodentPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(CancerousRodent), "Start")]
		public static void StartPostfix(CancerousRodent __instance)
		{
			if (Util.IsDifficulty(19))
			{
				__instance.projectileAmount = 5;
				if (Util.IsHardMode())
				{
					__instance.projectileAmount = 7;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CancerousRodent), "Update")]
		public static void UpdatePostfix(CancerousRodent __instance)
		{
			if (!Util.IsDifficulty(19))
			{
				return;
			}
			if (__instance.coolDown != 0f)
			{
				if (!Util.IsHardMode())
				{
					__instance.coolDown -= 1f * Time.deltaTime;
				}
				else
				{
					__instance.coolDown -= 2f * Time.deltaTime;
				}
			}
			if (__instance.coolDown < 0f)
			{
				__instance.coolDown = 0f;
			}
		}
	}
	[HarmonyPatch(typeof(Spin))]
	public class SpinPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Spin), "Start")]
		public static void StartPrefix(Spin __instance)
		{
			if (Object.op_Implicit((Object)(object)__instance.eid) && __instance.eid.difficultyOverride >= 0)
			{
				__instance.difficulty = __instance.eid.difficultyOverride;
			}
			else
			{
				__instance.difficulty = Util.GetDifficulty();
			}
			if (__instance.difficulty == 19 && ((Object)((Component)__instance).transform).name == "LaserRing" && __instance.difficultyVariance)
			{
				if (!Util.IsHardMode())
				{
					__instance.difficultySpeedMultiplier *= 1.3f;
				}
				else
				{
					__instance.difficultySpeedMultiplier *= 1.5f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Countdown), "GetCountdownLength")]
	public class CountdownPatch
	{
		public static bool Prefix(Countdown __instance, ref float __result)
		{
			if (!__instance.changePerDifficulty)
			{
				__result = __instance.countdownLength;
				return false;
			}
			if (__instance.difficulty == 19)
			{
				__result = __instance.countdownLengthPerDifficulty[4];
				return false;
			}
			__result = __instance.countdownLengthPerDifficulty[__instance.difficulty];
			return false;
		}
	}
	[HarmonyPatch(typeof(DifficultyDependantObject), "Awake")]
	public class DifficultyDependantObjectPatch
	{
		public static bool Prefix(ref DifficultyDependantObject __instance)
		{
			if (!Util.IsDifficulty(19))
			{
				return true;
			}
			__instance.veryHard = true;
			UnityEvent onRightDifficulty = __instance.onRightDifficulty;
			if (onRightDifficulty == null)
			{
				return false;
			}
			onRightDifficulty.Invoke();
			return false;
		}
	}
	[HarmonyPatch(typeof(FleshPrison))]
	public class FleshPrisonPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(FleshPrison), "SpawnInsignia")]
		public static bool SpawnInsigniaPrefix(FleshPrison __instance)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.eid.target == null)
			{
				return false;
			}
			__instance.inAction = false;
			GameObject val = Object.Instantiate<GameObject>(__instance.insignia, __instance.eid.target.position, Quaternion.identity);
			if (__instance.altVersion)
			{
				Vector3 velocity = __instance.eid.target.GetVelocity();
				velocity.y = 0f;
				if (((Vector3)(ref velocity)).magnitude > 0f)
				{
					val.transform.LookAt(__instance.eid.target.position + velocity);
				}
				else
				{
					val.transform.Rotate(Vector3.up * Random.Range(0f, 360f), (Space)1);
				}
				val.transform.Rotate(Vector3.right * 90f, (Space)1);
			}
			VirtueInsignia val2 = default(VirtueInsignia);
			if (val.TryGetComponent<VirtueInsignia>(ref val2))
			{
				val2.predictive = true;
				val2.noTracking = true;
				val2.otherParent = ((Component)__instance).transform;
				val2.charges = ((__instance.stat.health > __instance.maxHealth / 2f) ? 2 : 3);
				VirtueInsignia obj = val2;
				obj.charges += 3;
				val2.windUpSpeedMultiplier = 0.5f;
				VirtueInsignia obj2 = val2;
				obj2.windUpSpeedMultiplier *= __instance.eid.totalSpeedModifier;
				val2.damage = Mathf.RoundToInt((float)val2.damage * __instance.eid.totalDamageModifier);
				val2.target = __instance.eid.target;
				val2.predictiveVersion = null;
				Light val3 = val.AddComponent<Light>();
				val3.range = 30f;
				val3.intensity = 50f;
			}
			float num = 8f;
			switch (__instance.difficulty)
			{
			case 0:
				num = 5f;
				break;
			case 1:
				num = 7f;
				break;
			case 2:
			case 3:
			case 4:
			case 5:
			case 19:
				num = 8f;
				break;
			}
			if (Util.IsHardMode())
			{
				num = 12f;
			}
			val.transform.localScale = new Vector3(num, 2f, num);
			val.transform.SetParent(((Component)GoreZone.ResolveGoreZone(((Component)__instance).transform)).transform, true);
			if (__instance.fleshDroneCooldown < 1f)
			{
				__instance.fleshDroneCooldown = 1f;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(FleshPrison), "ProjectileBurstUpdate")]
		public static bool ProjectileBurstUpdatePrefix(FleshPrison __instance)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			__instance.homingProjectileCooldown = Mathf.MoveTowards(__instance.homingProjectileCooldown, 0f, Time.deltaTime * (Mathf.Abs(__instance.rotationSpeed) / 10f) * __instance.eid.totalSpeedModifier);
			if (__instance.homingProjectileCooldown <= 0f)
			{
				GameObject val = Object.Instantiate<GameObject>(__instance.homingProjectile, __instance.rotationBone.position + __instance.rotationBone.up * 8f, __instance.rotationBone.rotation);
				Projectile component = val.GetComponent<Projectile>();
				component.target = __instance.eid.target;
				component.safeEnemyType = (EnemyType)(__instance.altVersion ? 30 : 17);
				switch (__instance.difficulty)
				{
				case 0:
					component.turningSpeedMultiplier = 0.4f;
					break;
				case 1:
					component.turningSpeedMultiplier = 0.45f;
					break;
				case 2:
				case 3:
					component.turningSpeedMultiplier = 0.5f;
					break;
				case 4:
				case 5:
				case 19:
					component.turningSpeedMultiplier = 0.66f;
					break;
				}
				if (__instance.altVersion)
				{
					component.turnSpeed *= 4f;
					component.turningSpeedMultiplier *= 4f;
					component.predictiveHomingMultiplier = 1.25f;
					Rigidbody val2 = default(Rigidbody);
					if (val.TryGetComponent<Rigidbody>(ref val2))
					{
						val2.AddForce(Vector3.up * 50f, (ForceMode)2);
					}
				}
				component.damage *= __instance.eid.totalDamageModifier;
				__instance.homingProjectileCooldown = 1f;
				__instance.currentProjectile++;
				val.transform.SetParent(((Component)__instance).transform, true);
			}
			if (__instance.currentProjectile >= __instance.projectileAmount)
			{
				__instance.inAction = false;
				Animator anim = __instance.anim;
				if ((Object)(object)anim != (Object)null)
				{
					anim.SetBool("Shooting", false);
				}
				__instance.rotationSpeedTarget = ((__instance.rotationSpeed >= 0f) ? 45 : (-45));
				if (__instance.fleshDroneCooldown < 1f)
				{
					__instance.fleshDroneCooldown = 1f;
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(FleshPrison), "SpawnFleshDrones")]
		public static bool SpawnFleshDronesPrefix(FleshPrison __instance)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.eid.target == null)
			{
				return false;
			}
			float num = 360f / (float)__instance.droneAmount;
			if (__instance.currentDrone == 0)
			{
				__instance.targeter = new GameObject("Targeter");
				__instance.targeter.transform.position = __instance.rotationBone.position;
				Vector3 val = (__instance.altVersion ? Vector3.up : (new Vector3(__instance.eid.target.position.x, __instance.targeter.transform.position.y, __instance.eid.target.position.z) - __instance.targeter.transform.position));
				Quaternion rotation = (__instance.altVersion ? Quaternion.LookRotation(((Vector3)(ref val)).normalized) : Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up));
				__instance.targeter.transform.rotation = rotation;
				__instance.targeter.transform.Rotate(Vector3.forward * num / 2f);
			}
			if (__instance.currentDrone < __instance.droneAmount)
			{
				__instance.secondaryBarValue = (float)__instance.currentDrone / (float)__instance.droneAmount;
				GameObject val2 = ((Util.IsHardMode() && (!Util.IsHardMode() || !__instance.altVersion)) ? __instance.skullDrone : ((__instance.currentDrone % 2 == 0) ? __instance.skullDrone : __instance.fleshDrone));
				GameObject val3 = Object.Instantiate<GameObject>(val2, __instance.targeter.transform.position + __instance.targeter.transform.up * (float)(__instance.altVersion ? 50 : 20), __instance.targeter.transform.rotation);
				val3.transform.SetParent(((Component)__instance).transform, true);
				EnemyIdentifier val4 = default(EnemyIdentifier);
				if (val3.TryGetComponent<EnemyIdentifier>(ref val4))
				{
					val4.dontCountAsKills = true;
					val4.damageBuff = __instance.eid.damageBuff;
					val4.healthBuff = __instance.eid.healthBuff;
					val4.speedBuff = __instance.eid.speedBuff;
				}
				DroneFlesh item = default(DroneFlesh);
				if (val3.TryGetComponent<DroneFlesh>(ref item))
				{
					__instance.currentDrones.Add(item);
				}
				__instance.targeter.transform.Rotate(Vector3.forward * num);
				__instance.currentDrone++;
				((MonoBehaviour)__instance).Invoke("SpawnFleshDrones", 0.1f / __instance.eid.totalSpeedModifier);
				return false;
			}
			__instance.inAction = false;
			__instance.rotationSpeedTarget = ((Random.Range(0, 2) == 0) ? 45 : (-45));
			__instance.aud.Stop();
			__instance.shakingCamera = false;
			__instance.currentDrone = 0;
			Object.Destroy((Object)(object)__instance.targeter);
			__instance.fleshDroneCooldown = (__instance.altVersion ? 30 : 25);
			__instance.healing = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(GabrielBase))]
	public class GabrielBasePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(GabrielBase), "UpdateSpeed")]
		public static void UpdateSpeedPostfix(GabrielBase __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1.15f : 1.35f);
				__instance.anim.speed = num * __instance.eid.totalSpeedModifier;
				__instance.defaultAnimSpeed = __instance.anim.speed;
			}
		}
	}
	[HarmonyPatch(typeof(Gabriel))]
	public class GabrielPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Gabriel), "SpearCombo")]
		public static bool SpearComboPrefix(Gabriel __instance)
		{
			if (__instance.difficulty != 19)
			{
				return true;
			}
			switch (__instance.difficulty)
			{
			case 0:
				__instance.gabe.forwardSpeed = 60f;
				break;
			case 1:
				__instance.gabe.forwardSpeed = 75f;
				break;
			case 2:
			case 3:
			case 4:
			case 5:
			case 19:
				__instance.gabe.forwardSpeed = 150f;
				break;
			}
			GabrielBase gabe = __instance.gabe;
			gabe.forwardSpeed *= __instance.eid.totalSpeedModifier;
			__instance.spearAttacks = 1;
			if (__instance.gabe.enraged)
			{
				__instance.spearAttacks++;
			}
			if (__instance.gabe.secondPhase)
			{
				__instance.spearAttacks++;
			}
			__instance.SpawnRightHandWeapon((GabrielWeaponType)3);
			__instance.gabe.inAction = true;
			__instance.anim.Play("SpearReady");
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Gabriel), "SpearAttack")]
		public static bool SpearAttackPrefix(Gabriel __instance)
		{
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.gabe.juggled)
			{
				return false;
			}
			if (__instance.target == null)
			{
				__instance.spearAttacks = 0;
			}
			if (__instance.spearAttacks == 0)
			{
				__instance.SpearThrow();
				return false;
			}
			__instance.gabe.spearing = true;
			__instance.gabe.goForward = false;
			__instance.spearAttacks--;
			float num = 1.5f;
			switch (__instance.difficulty)
			{
			case 0:
			case 1:
				num = 2f;
				break;
			case 2:
				num = 1.5f;
				break;
			case 3:
			case 4:
			case 5:
				num = 0.75f;
				break;
			case 19:
				num = 0.6f;
				break;
			}
			if (Util.IsHardMode())
			{
				num = 0.5f;
			}
			((MonoBehaviour)__instance).Invoke("SpearAttack", num / __instance.eid.totalSpeedModifier);
			num = 0.75f;
			switch (__instance.difficulty)
			{
			case 0:
			case 1:
				num = 1f;
				break;
			case 2:
				num = 0.75f;
				break;
			case 3:
			case 4:
			case 5:
				num = 0.5f;
				break;
			case 19:
				num = 0.4f;
				break;
			}
			if (Util.IsHardMode())
			{
				num = 0.3f;
			}
			Vector3 val = __instance.target.headPosition;
			bool flag = false;
			RaycastHit val2 = default(RaycastHit);
			if (!Physics.Raycast(__instance.target.headPosition, Vector3.up, ref val2, 17f, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1)), (QueryTriggerInteraction)1))
			{
				val = __instance.target.headPosition + Vector3.up * 15f;
				flag = true;
			}
			else if (!Physics.Raycast(__instance.target.headPosition, Vector3.down, ref val2, 17f, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1)), (QueryTriggerInteraction)1))
			{
				val = ((Component)__instance).transform.position + Vector3.down * 15f;
				flag = true;
			}
			if (!flag || (__instance.difficulty >= 4 && __instance.gabe.enraged && Random.Range(0f, 1f) > 0.5f))
			{
				__instance.anim.Play("SpearStinger");
				__instance.gabe.Teleport(false, true, true, true, false);
				__instance.gabe.FollowTarget();
				((MonoBehaviour)__instance).Invoke("SpearFlash", num / 2f / __instance.eid.totalSpeedModifier);
				((MonoBehaviour)__instance).Invoke("SpearGoHorizontal", num / __instance.eid.totalSpeedModifier);
				return false;
			}
			__instance.gabe.TeleportTo(val);
			__instance.gabe.LookAtTarget(0);
			Animator anim = __instance.anim;
			if ((Object)(object)anim != (Object)null)
			{
				anim.Play("SpearDown");
			}
			((MonoBehaviour)__instance).Invoke("SpearFlash", num / 2f / __instance.eid.totalSpeedModifier);
			((MonoBehaviour)__instance).Invoke("SpearGo", num / __instance.eid.totalSpeedModifier);
			return false;
		}
	}
	[HarmonyPatch(typeof(Geryon))]
	public class GeryonPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Geryon), "UpdateDifficulty")]
		public static void UpdateDifficultyPostfix(Geryon __instance)
		{
			if (__instance.difficulty == 19)
			{
				__instance.anim.speed = 1.3f;
				__instance.maximumHeat = 9f;
				if (Util.IsHardMode())
				{
					__instance.anim.speed = 1.45f;
				}
				if (__instance.secondPhase)
				{
					Animator anim = __instance.anim;
					anim.speed *= 1.25f;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Geryon), "Stun")]
		public static void StunPrefix(Geryon __instance)
		{
			if (__instance.difficulty == 19)
			{
				__instance.stunTime = 5f;
				if (Util.IsHardMode())
				{
					__instance.stunTime = 4f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(LeviathanHead))]
	public class LeviathanHeadPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(LeviathanHead), "SetSpeed")]
		public static void SetSpeedPostfix(LeviathanHead __instance)
		{
			if (__instance.lcon.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1.6f : 2.1f);
				__instance.anim.speed = num * __instance.lcon.eid.totalSpeedModifier;
			}
		}
	}
	[HarmonyPatch(typeof(LeviathanTail))]
	public class LeviathanTailPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(LeviathanTail), "GetAnimSpeed")]
		public static void GetAnimSpeedPostfix(LeviathanTail __instance, ref float __result)
		{
			if (__instance.lcon.difficulty == 19)
			{
				__result = 2f;
				if (Util.IsHardMode())
				{
					__result = 2.6f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Projectile), "Start")]
	public class LeviathanProjectilePatch
	{
		[HarmonyPrefix]
		public static void Prefix(Projectile __instance)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if (Util.IsHardMode() && (int)__instance.safeEnemyType == 27 && SceneHelper.CurrentScene == "Level 5-4")
			{
				__instance.enemyDamageMultiplier = 0f;
			}
		}
	}
	[HarmonyPatch(typeof(Mandalore))]
	public class MandalorePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mandalore), "Update")]
		public static void UpdatePostfix(Mandalore __instance)
		{
			if (Util.IsDifficulty(19))
			{
				if (!Util.IsHardMode())
				{
					__instance.cooldown -= 1f * Time.deltaTime;
				}
				else
				{
					__instance.cooldown -= 1.5f * Time.deltaTime;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mandalore), "Start")]
		public static void StartPostfix(Mandalore __instance)
		{
			__instance.fullAutoProjectile.GetComponentInChildren<Projectile>().enemyDamageMultiplier = 0f;
			__instance.fullerAutoProjectile.GetComponentInChildren<Projectile>().enemyDamageMultiplier = 0f;
		}
	}
	[HarmonyPatch(typeof(MinosBoss))]
	public class MinosPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(MinosBoss), "SetSpeed")]
		public static void SetSpeedPostfix(MinosBoss __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1.6f : 2f);
				__instance.anim.speed = num * __instance.eid.totalSpeedModifier;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MinosBoss), "SpawnBlackHole")]
		public static void SpawnBlackHolePostfix(MinosBoss __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1.8f : 2.3f);
				BlackHoleProjectile currentBlackHole = __instance.currentBlackHole;
				currentBlackHole.speed *= num;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MinosBoss), "Update")]
		public static bool UpdatePrefix(MinosBoss __instance)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.dead)
			{
				AnimatorStateInfo currentAnimatorStateInfo = __instance.anim.GetCurrentAnimatorStateInfo(0);
				if (!((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsName("Death"))
				{
					__instance.anim.Play("Death");
				}
			}
			if ((Object)(object)__instance.currentBlackHole == (Object)null && __instance.blackHoleCooldown > 0f && (__instance.phase < 2 || __instance.difficulty > 2))
			{
				__instance.blackHoleCooldown = Mathf.MoveTowards(__instance.blackHoleCooldown, 0f, Time.deltaTime * __instance.eid.totalSpeedModifier);
			}
			if (Object.op_Implicit((Object)(object)__instance.stat) && __instance.stat.health < __instance.originalHealth / 2f && __instance.phase < 2 && !__instance.anim.IsInTransition(0))
			{
				__instance.inPhaseChange = true;
				__instance.PhaseChange(2);
			}
			if (__instance.eid.target == null)
			{
				return false;
			}
			if (__instance.inAction || __instance.inPhaseChange)
			{
				return false;
			}
			if ((Object)(object)__instance.currentBlackHole == (Object)null && __instance.blackHoleCooldown == 0f && __instance.difficulty >= 2 && (__instance.phase < 2 || __instance.difficulty > 2))
			{
				__instance.BlackHole();
				return false;
			}
			if (__instance.cooldown > 0f)
			{
				__instance.cooldown = Mathf.MoveTowards(__instance.cooldown, 0f, Time.deltaTime * __instance.anim.speed);
				return false;
			}
			if (__instance.anim.IsInTransition(0))
			{
				return false;
			}
			if (__instance.phase == 1 && __instance.difficulty < 4)
			{
				__instance.cooldown = ((__instance.difficulty >= 4) ? 1f : 2f);
			}
			else if (__instance.phase == 2 || __instance.difficulty >= 4)
			{
				if ((__instance.difficulty == 4 && __instance.punchesSinceBreak < 2) || __instance.difficulty == 5 || __instance.difficulty == 19)
				{
					__instance.punchesSinceBreak++;
					__instance.cooldown = 0f;
				}
				else
				{
					__instance.punchesSinceBreak = 0;
					__instance.cooldown = 3f;
				}
			}
			else
			{
				__instance.cooldown = 0f;
			}
			if (__instance.onRight)
			{
				if (__instance.onMiddle && Random.Range(0f, 1f) > 0.5f)
				{
					__instance.SlamMiddle();
					return false;
				}
				__instance.SlamRight();
				return false;
			}
			if (__instance.onLeft)
			{
				if (__instance.onMiddle && Random.Range(0f, 1f) > 0.5f)
				{
					__instance.SlamMiddle();
					return false;
				}
				__instance.SlamLeft();
				return false;
			}
			__instance.SlamMiddle();
			return false;
		}
	}
	[HarmonyPatch(typeof(MinosArm))]
	public class MinosArmPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(MinosArm), "SetSpeed")]
		public static void SetSpeedPostfix(MinosArm __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1.375f : 1.6f);
				__instance.maxSlams = 99;
				__instance.originalAnimSpeed = num * __instance.eid.totalSpeedModifier;
				__instance.anim.speed = __instance.originalAnimSpeed * (1f + __instance.speedState / 4f);
			}
		}
	}
	[HarmonyPatch(typeof(MinosPrime))]
	public class MinosPrimePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(MinosPrime), "SetSpeed")]
		public static void SetSpeedPostfix(MinosPrime __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1.35f : 1.6f);
				__instance.anim.speed = num * __instance.eid.totalSpeedModifier;
			}
		}
	}
	[HarmonyPatch(typeof(Minotaur))]
	public class MinotaurPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Minotaur), "GetSpeed")]
		public static bool GetSpeedPrefix(int difficulty, Minotaur __instance, ref EnemyMovementData __result)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (difficulty != 19)
			{
				return true;
			}
			float num = 1.4f;
			if (Util.IsHardMode())
			{
				num = 1.65f;
			}
			__result = new EnemyMovementData
			{
				speed = 50f * num,
				angularSpeed = 12000f,
				acceleration = 100f
			};
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Minotaur), "SetSpeed")]
		public static void SetSpeedPostfix(Minotaur __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = 1.4f;
				if (Util.IsHardMode())
				{
					num = 1.65f;
				}
				__instance.anim.speed = num * __instance.eid.totalSpeedModifier;
				__instance.nma.speed = 50f * __instance.anim.speed;
			}
		}
	}
	[HarmonyPatch(typeof(MinotaurChase))]
	public class MinotaurChasePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(MinotaurChase), "SetSpeed")]
		public static void SetSpeedPostfix(MinotaurChase __instance)
		{
			if (__instance.difficulty == 19)
			{
				__instance.movementSpeed = ((!Util.IsHardMode()) ? 40f : 50f) * __instance.eid.totalSpeedModifier;
				__instance.anim.speed = ((!Util.IsHardMode()) ? 1.4f : 1.65f) * __instance.eid.totalSpeedModifier;
			}
		}
	}
	[HarmonyPatch(typeof(SisyphusPrime))]
	public class SisyphusPrimePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(SisyphusPrime), "SetSpeed")]
		public static void SetSpeedPostfix(SisyphusPrime __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1.35f : 1.5f);
				__instance.anim.speed = num * __instance.eid.totalSpeedModifier;
			}
		}
	}
	[HarmonyPatch(typeof(V2))]
	public class V2Patch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(V2), "SetSpeed")]
		public static bool SetSpeedPrefix(V2 __instance)
		{
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (!Object.op_Implicit((Object)(object)__instance.nma))
			{
				__instance.nma = ((Component)__instance).GetComponent<NavMeshAgent>();
			}
			if (!Object.op_Implicit((Object)(object)__instance.eid))
			{
				__instance.eid = ((Component)__instance).GetComponent<EnemyIdentifier>();
			}
			if (__instance.difficulty < 0)
			{
				__instance.difficulty = Enemy.InitializeDifficulty(__instance.eid);
			}
			if (__instance.originalMovementSpeed != 0f)
			{
				__instance.movementSpeed = __instance.originalMovementSpeed;
			}
			else
			{
				switch (__instance.difficulty)
				{
				case 0:
					__instance.movementSpeed *= 0.65f;
					break;
				case 1:
					__instance.movementSpeed *= 0.75f;
					break;
				case 2:
					__instance.movementSpeed *= 0.85f;
					break;
				case 3:
					__instance.movementSpeed *= 1f;
					break;
				case 4:
				case 5:
				case 19:
					__instance.movementSpeed *= 1.5f;
					break;
				}
				__instance.movementSpeed *= __instance.eid.totalSpeedModifier;
				__instance.originalMovementSpeed = __instance.movementSpeed;
			}
			if (__instance.enraged)
			{
				__instance.movementSpeed *= 2f;
			}
			if (Object.op_Implicit((Object)(object)__instance.nma))
			{
				__instance.nma.speed = __instance.originalMovementSpeed;
			}
			GameObject[] weapons = __instance.weapons;
			for (int i = 0; i < weapons.Length; i++)
			{
				((Component)weapons[i].transform.GetChild(0)).SendMessage("UpdateBuffs", (object)__instance.eid, (SendMessageOptions)1);
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(V2), "UpdateCooldowns")]
		public static bool UpdateCooldownsPrefix(V2 __instance)
		{
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.patternCooldown > 0f)
			{
				__instance.patternCooldown = Mathf.MoveTowards(__instance.patternCooldown, 0f, Time.deltaTime);
			}
			if (__instance.shootCooldown > 0f || __instance.altShootCooldown > 0f)
			{
				float num = 1f;
				if (__instance.difficulty == 19)
				{
					num = 1.25f;
				}
				if (Util.IsHardMode())
				{
					num = 1.45f;
				}
				if (__instance.shootCooldown > 0f)
				{
					__instance.shootCooldown = Mathf.MoveTowards(__instance.shootCooldown, 0f, Time.deltaTime * num * (__instance.cowardPattern ? 0.5f : 1f) * __instance.eid.totalSpeedModifier);
				}
				if (__instance.altShootCooldown > 0f)
				{
					__instance.altShootCooldown = Mathf.MoveTowards(__instance.altShootCooldown, 0f, Time.deltaTime * num * __instance.eid.totalSpeedModifier);
				}
			}
			if (__instance.dodgeCooldown < 6f)
			{
				float num2 = 1f;
				switch (__instance.difficulty)
				{
				case 0:
				case 1:
				case 2:
					num2 = 0.1f;
					break;
				case 3:
					num2 = 0.5f;
					break;
				case 4:
				case 5:
					num2 = 1f;
					break;
				case 19:
					num2 = 1.25f;
					break;
				}
				if (Util.IsHardMode())
				{
					num2 = 1.4f;
				}
				__instance.dodgeCooldown = Mathf.MoveTowards(__instance.dodgeCooldown, 6f, Time.deltaTime * num2 * __instance.eid.totalSpeedModifier);
			}
			if (__instance.dodgeLeft > 0f)
			{
				__instance.dodgeLeft = Mathf.MoveTowards(__instance.dodgeLeft, 0f, Time.deltaTime * 3f * __instance.eid.totalSpeedModifier);
				if (__instance.dodgeLeft <= 0f)
				{
					__instance.DodgeEnd();
				}
			}
			if (__instance.secondEncounter && (__instance.coins.Count == 0 || (__instance.aboutToShoot && __instance.shootingForCoin)))
			{
				switch (__instance.difficulty)
				{
				case 0:
					__instance.coinsInSightCooldown = 0.8f;
					break;
				case 1:
					__instance.coinsInSightCooldown = 0.6f;
					break;
				case 2:
					__instance.coinsInSightCooldown = 0.4f;
					break;
				case 3:
					__instance.coinsInSightCooldown = 0.2f;
					break;
				case 4:
				case 5:
				case 19:
					__instance.coinsInSightCooldown = 0f;
					break;
				}
			}
			if (__instance.inPattern)
			{
				__instance.DistancePatience();
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(V2), "Dodge")]
		public static bool DodgePrefix(Transform projectile, V2 __instance)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: 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)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Invalid comparison between Unknown and I4
			//IL_0129: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.target == null || !__instance.active || __instance.dodgeLeft > 0f || __instance.chargingAlt)
			{
				return false;
			}
			if (Vector3.Distance(((Component)__instance).transform.position, __instance.target.position) <= 15f)
			{
				return false;
			}
			if (__instance.dodgeCooldown >= 1.5f)
			{
				__instance.dodgeCooldown -= 1.5f;
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(((Component)__instance).transform.position.x - projectile.position.x, 0f, ((Component)__instance).transform.position.z - projectile.position.z);
				if ((int)__instance.currentPattern == 2)
				{
					Vector3 normalized = ((Vector3)(ref val)).normalized;
					Vector3 val2 = __instance.targetPos - ((Component)__instance).transform.position;
					val = normalized + ((Vector3)(ref val2)).normalized;
				}
				__instance.DodgeNow(val);
				__instance.ChangeDirection((float)((Random.Range(0f, 1f) > 0.5f) ? 90 : (-90)));
				return false;
			}
			if (__instance.gc.onGround && !__instance.jumping && !__instance.slideOnly)
			{
				if (__instance.cowardPattern)
				{
					__instance.Jump();
					return false;
				}
				float num = Random.Range(0f, (__instance.difficulty >= 3) ? 2f : 3f);
				if (num > 1f)
				{
					return false;
				}
				if (num > 0.75f)
				{
					__instance.Jump();
					return false;
				}
				__instance.Slide();
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(V2), "ShootCheck")]
		public static bool ShootCheckPrefix(V2 __instance)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			float num = Vector3.Distance(__instance.target.position, ((Component)__instance).transform.position);
			if (!__instance.aboutToShoot)
			{
				if (num <= 15f)
				{
					__instance.SwitchWeapon(1);
				}
				else if (__instance.weapons.Length > 2 && num < 25f && __instance.eid.stuckMagnets.Count <= 0)
				{
					__instance.SwitchWeapon(2);
				}
				else
				{
					__instance.SwitchWeapon(0);
				}
			}
			if (Physics.Raycast(((Component)__instance).transform.position + Vector3.up * 2f, __instance.target.position - ((Component)__instance).transform.position, ref __instance.rhit, Vector3.Distance(((Component)__instance).transform.position, __instance.target.position), LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))))
			{
				if (__instance.altShootCooldown <= 0f && (Object)(object)((RaycastHit)(ref __instance.rhit)).transform != (Object)null && ((Component)((RaycastHit)(ref __instance.rhit)).transform).gameObject.CompareTag("Breakable"))
				{
					__instance.predictAmount = 0f;
					__instance.aimAtGround = false;
					if (__instance.distancePatience >= 4f)
					{
						__instance.shootCooldown = 1f;
					}
					else
					{
						__instance.shootCooldown = ((__instance.difficulty > 2) ? Random.Range(1f, 2f) : 2f);
					}
					__instance.altShootCooldown = 5f;
					((Component)__instance.weapons[__instance.currentWeapon].transform.GetChild(0)).SendMessage("PrepareAltFire");
					__instance.aboutToShoot = true;
					__instance.chargingAlt = true;
					((MonoBehaviour)__instance).Invoke("AltShootWeapon", 1f / __instance.eid.totalSpeedModifier);
				}
				return false;
			}
			__instance.aboutToShoot = true;
			if (__instance.altShootCooldown <= 0f || (__instance.distancePatience >= 8f && __instance.currentWeapon == 0 && !__instance.dontEnrage))
			{
				__instance.aimAtGround = __instance.currentWeapon != 0 || __instance.weapons.Length == 1;
				if (__instance.currentWeapon == 0)
				{
					__instance.predictAmount = 0.15f / __instance.eid.totalSpeedModifier;
				}
				else if (__instance.currentWeapon == 1 || __instance.difficulty > 2)
				{
					__instance.predictAmount = 0.25f / __instance.eid.totalSpeedModifier;
				}
				else
				{
					__instance.predictAmount = -0.25f / __instance.eid.totalSpeedModifier;
				}
				__instance.shootCooldown = ((__instance.difficulty > 2) ? Random.Range(1f, 2f) : 2f);
				__instance.altShootCooldown = 5f;
				if (__instance.secondEncounter && num >= 8f && !__instance.enraged && Random.Range(0f, 1f) < 0.5f)
				{
					__instance.SwitchWeapon(0);
					__instance.coinsToThrow = ((__instance.difficulty < 2) ? 1 : 3);
					__instance.ThrowCoins();
					return false;
				}
				__instance.chargingAlt = true;
				((Component)__instance.weapons[__instance.currentWeapon].transform.GetChild(0)).SendMessage("PrepareAltFire", (SendMessageOptions)1);
				float num2 = 1f;
				switch (__instance.difficulty)
				{
				case 0:
					num2 = 1.5f;
					break;
				case 1:
					num2 = 1.25f;
					break;
				case 2:
				case 3:
				case 4:
				case 5:
					num2 = 1f;
					break;
				case 19:
					num2 = 0.8f;
					break;
				}
				if (Util.IsHardMode())
				{
					num2 = 0.55f;
				}
				((MonoBehaviour)__instance).Invoke("AltShootWeapon", num2 / __instance.eid.totalSpeedModifier);
			}
			else
			{
				if (__instance.currentWeapon == 0)
				{
					__instance.predictAmount = 0f;
				}
				else if (__instance.currentWeapon == 1 || __instance.difficulty > 2)
				{
					__instance.predictAmount = 0.15f / __instance.eid.totalSpeedModifier;
				}
				else
				{
					__instance.predictAmount = -0.25f / __instance.eid.totalSpeedModifier;
				}
				if (__instance.currentWeapon == 0 && __instance.distancePatience >= 4f)
				{
					__instance.shootCooldown = 1f;
				}
				else
				{
					__instance.shootCooldown = ((__instance.difficulty > 2) ? Random.Range(1.5f, 2f) : 2f);
				}
				((Component)__instance.weapons[__instance.currentWeapon].transform.GetChild(0)).SendMessage("PrepareFire", (SendMessageOptions)1);
				if (__instance.currentWeapon == 0)
				{
					__instance.shootingForCoin = false;
					__instance.Flash();
					if (__instance.difficulty >= 2)
					{
						((MonoBehaviour)__instance).Invoke("ShootWeapon", 0.75f / __instance.eid.totalSpeedModifier);
					}
					if (__instance.difficulty >= 1)
					{
						((MonoBehaviour)__instance).Invoke("ShootWeapon", 0.95f / __instance.eid.totalSpeedModifier);
					}
					((MonoBehaviour)__instance).Invoke("ShootWeapon", 1.15f / __instance.eid.totalSpeedModifier);
					return false;
				}
				float num3 = 1f;
				switch (__instance.difficulty)
				{
				case 0:
					num3 = 1.25f;
					break;
				case 1:
					num3 = 1f;
					break;
				case 2:
				case 3:
				case 4:
				case 5:
					num3 = 0.75f;
					break;
				case 19:
					num3 = 0.6f;
					break;
				}
				if (Util.IsHardMode())
				{
					num3 = 0.4f;
				}
				((MonoBehaviour)__instance).Invoke("ShootWeapon", num3 / __instance.eid.totalSpeedModifier);
			}
			return false;
		}
	}
	public class BoolValue : MonoBehaviour
	{
		public bool value = false;

		public string description;

		public static bool? Get(string target, GameObject obj)
		{
			BoolValue[] components = obj.GetComponents<BoolValue>();
			foreach (BoolValue boolValue in components)
			{
				if (boolValue.description == target)
				{
					return boolValue.value;
				}
			}
			return null;
		}

		public static void Set(string target, bool newValue, GameObject obj)
		{
			BoolValue[] components = obj.GetComponents<BoolValue>();
			foreach (BoolValue boolValue in components)
			{
				if (boolValue.description == target)
				{
					boolValue.value = newValue;
				}
			}
		}
	}
	internal class CounterInt : MonoBehaviour
	{
		public int maxValue;

		public bool randomized = false;

		public int randomMin;

		public int randomMax;

		public int value = 1;

		public void Start()
		{
			TryRandomize();
		}

		public void Add()
		{
			if (value < maxValue)
			{
				value++;
				return;
			}
			value = 1;
			TryRandomize();
		}

		public void TryRandomize()
		{
			if (randomized)
			{
				maxValue = Random.Range(randomMin, randomMax + 1);
			}
		}
	}
	public class DamageOverTimeTracker : MonoBehaviour
	{
		public class DamageEvent
		{
			public float timestamp;

			public float amount;
		}

		public float damageThreshold = 30f;

		public float timeWindow = 5f;

		public float cooldownMax = 1f;

		public bool buffSpeed = true;

		public bool buffingSpeed = false;

		public float speedBuff = 1.25f;

		public float speedBuffTime = 5f;

		public float speedCooldown = 0f;

		public bool reached = false;

		public bool onCooldown = false;

		public List<DamageEvent> damageEvents = new List<DamageEvent>();

		public float previousHealth;

		public Enemy mach;

		public float cooldown = 0f;

		public void Start()
		{
			mach = ((Component)this).GetComponent<Enemy>();
			previousHealth = mach.health;
		}

		public void Update()
		{
			if (buffingSpeed)
			{
				speedCooldown += Time.deltaTime;
				if (speedCooldown >= speedBuffTime)
				{
					buffingSpeed = false;
				}
			}
			if (onCooldown)
			{
				cooldown += Time.deltaTime;
				if (cooldown < cooldownMax)
				{
					return;
				}
				reached = false;
				onCooldown = false;
				cooldown = 0f;
				damageEvents.Clear();
			}
			float health = mach.health;
			float num = previousHealth - health;
			if (num > 0f)
			{
				RegisterDamage(num);
			}
			previousHealth = health;
		}

		public void RegisterDamage(float damage)
		{
			float currentTime = Time.time;
			damageEvents.Add(new DamageEvent
			{
				timestamp = currentTime,
				amount = damage
			});
			damageEvents.RemoveAll((DamageEvent e) => currentTime - e.timestamp > timeWindow);
			float num = 0f;
			foreach (DamageEvent damageEvent in damageEvents)
			{
				num += damageEvent.amount;
			}
			if (num >= damageThreshold)
			{
				OnDamageThresholdReached();
				damageEvents.Clear();
			}
		}

		public void OnDamageThresholdReached()
		{
			reached = true;
			onCooldown = false;
			if (buffSpeed)
			{
				buffingSpeed = true;
			}
		}
	}
	internal class FerrymanCirclingProjectiles : MonoBehaviour
	{
		public float cooldownMax = 0.3f;

		public float scaleMultiplier = 3f;

		public float projectileSpeed = 80f;

		public float angleStep = 30f;

		public float angle = 0f;

		public bool active = false;

		public bool doubled = false;

		public float cooldown = 0f;

		public GameObject projectile = Plugin.Prefabs["Projectile"];

		public EnemyIdentifier eid;

		public void Start()
		{
			eid = ((Component)this).GetComponent<EnemyIdentifier>();
		}

		public void Update()
		{
			if ((Object)(object)eid == (Object)null || eid.dead)
			{
				if (BoolValue.Get("enraged", ((Component)this).gameObject).GetValueOrDefault())
				{
					BoolValue.Set("enraged", newValue: false, ((Component)this).gameObject);
					EnrageEffect componentInChildren = ((Component)this).gameObject.GetComponentInChildren<EnrageEffect>(true);
					Object.Destroy((Object)(object)((Component)componentInChildren).gameObject);
				}
				Object.Destroy((Object)(object)this);
			}
			else
			{
				if (!active)
				{
					return;
				}
				cooldown += Time.deltaTime;
				if (!(cooldown < cooldownMax))
				{
					cooldown = 0f;
					if (angle >= 360f)
					{
						angle %= 360f;
					}
					if (!doubled)
					{
						Shoot(4f);
					}
					else
					{
						Shoot(2.5f);
						Shoot(5.5f);
					}
					angle += angleStep;
				}
			}
		}

		public void Shoot(float heightOffset)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(projectile, ((Component)this).transform.position + heightOffset * ((Component)this).transform.up, Quaternion.LookRotation(Vector3.forward));
			val.transform.Rotate(new Vector3(0f, angle, 0f), (Space)1);
			Transform transform = val.transform;
			transform.position += 2f * val.transform.forward;
			Transform transform2 = val.transform;
			transform2.localScale *= scaleMultiplier;
			Projectile component = val.GetComponent<Projectile>();
			component.unparryable = true;
			component.speed = projectileSpeed;
			component.ignoreEnvironment = true;
			component.safeEnemyType = (EnemyType)26;
			component.enemyDamageMultiplier = 0f;
			component.damage = 20f;
			RemoveOnTime component2 = val.GetComponent<RemoveOnTime>();
			component2.time = 1f;
			Object.Destroy((Object)(object)((Component)component).GetComponent<MeshRenderer>());
			MeshRenderer component3 = ((Component)((Component)component).transform.Find("AlwaysLookAtCamera/ChargeEffect")).GetComponent<MeshRenderer>();
			((Renderer)component3).material.color = Color.white;
			TrailRenderer component4 = ((Component)component).GetComponent<TrailRenderer>();
			component4.startColor = Color.white;
			component4.endColor = new Color(0.5f, 1f, 1f);
			Light component5 = ((Component)component).GetComponent<Light>();
			component5.color = new Color(0f, 0.3886f, 1f);
		}
	}
	internal class FerrymanStuff : MonoBehaviour
	{
		public float initialSpeed = 0f;

		public float maxSpeed = 0f;

		public float speedChangeMultiplier = 1f;

		public bool changeColor = true;

		public Color targetFerrymanColor;

		public Color targetCloakColor;

		public bool reached = false;

		public bool addedStyle = false;

		public float currentValue;

		public float time = 0f;

		public EnemyIdentifier eid;

		public Material ferrymanMaterial;

		public Material cloakMaterial;

		public Color initialFerrymanColor;

		public Color initialCloakColor;

		public Color enragedColorMultiplier = new Color(1f, 0.25f, 0.25f);

		public void Start()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			currentValue = initialSpeed;
			_ = targetFerrymanColor;
			if (true)
			{
				ferrymanMaterial = ((Renderer)((Component)this).gameObject.GetComponentInChildren<SkinnedMeshRenderer>()).materials[0];
				initialFerrymanColor = ferrymanMaterial.color;
			}
			_ = targetCloakColor;
			if (true)
			{
				cloakMaterial = ((Renderer)((Component)this).gameObject.GetComponentInChildren<SkinnedMeshRenderer>()).materials[1];
				initialCloakColor = cloakMaterial.color;
			}
		}

		public void Update()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			bool valueOrDefault = BoolValue.Get("enraged", ((Component)this).gameObject).GetValueOrDefault();
			if (currentValue < maxSpeed)
			{
				time += Time.deltaTime;
			}
			currentValue = Mathf.MoveTowards(currentValue, maxSpeed, speedChangeMultiplier * Time.deltaTime * maxSpeed);
			if (changeColor)
			{
				_ = targetFerrymanColor;
				if ((Object)(object)eid != (Object)null && !eid.dead)
				{
					ferrymanMaterial.color = Color.Lerp(initialFerrymanColor, targetFerrymanColor, (currentValue - initialSpeed) / (maxSpeed - initialSpeed));
					if (valueOrDefault)
					{
						ferrymanMaterial.color = new Color(ferrymanMaterial.color.r * enragedColorMultiplier.r, ferrymanMaterial.color.g * enragedColorMultiplier.g, ferrymanMaterial.color.b * enragedColorMultiplier.b);
					}
				}
			}
			if (changeColor)
			{
				_ = targetCloakColor;
				if ((Object)(object)eid != (Object)null && !eid.dead)
				{
					cloakMaterial.color = Color.Lerp(initialCloakColor, targetCloakColor, (currentValue - initialSpeed) / (maxSpeed - initialSpeed));
					if (valueOrDefault)
					{
						cloakMaterial.color = new Color(cloakMaterial.color.r * enragedColorMultiplier.r, cloakMaterial.color.g * enragedColorMultiplier.g, cloakMaterial.color.b * enragedColorMultiplier.b);
					}
				}
			}
			if (!(currentValue < maxSpeed) && !addedStyle)
			{
				reached = true;
			}
		}
	}
	internal class EnemyIdentifierSaver : MonoBehaviour
	{
		public EnemyIdentifier eid = null;
	}
	internal class IdolHealingSetup : MonoBehaviour
	{
		public EnemyIdentifier eid;

		public float cooldownMax = 2f;

		public float cooldown = 0f;

		public bool stop = false;

		public float cooldownMaxOriginal;

		public void Start()
		{
			eid = ((Component)this).GetComponent<EnemyIdentifier>();
			cooldown = cooldownMax;
			cooldownMaxOriginal = cooldownMax;
		}

		public void Update()
		{
			//IL_0070: 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)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			if (stop || BlindEnemies.Blind)
			{
				return;
			}
			cooldown += Time.deltaTime;
			if (!(cooldown < cooldownMax))
			{
				cooldown = 0f;
				GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["Explosion"], ((Component)eid).transform.position, ((Component)eid).transform.rotation);
				((Object)val).name = "Idol Healing Explosion";
				Transform transform = val.transform;
				transform.localScale *= 2.5f;
				Object.Destroy((Object)(object)((Component)val.transform.Find("Sphere_8 (1)")).gameObject);
				Explosion componentInChildren = val.GetComponentInChildren<Explosion>();
				componentInChildren.harmless = true;
				componentInChildren.damage = 0;
				componentInChildren.speed = 1.75f;
				componentInChildren.maxSize = 2.5f;
				componentInChildren.ignite = false;
				val.GetComponent<ExplosionController>().tryIgniteGasoline = false;
				MeshRenderer[] componentsInChildren = val.GetComponentsInChildren<MeshRenderer>();
				MeshRenderer[] array = componentsInChildren;
				foreach (MeshRenderer val2 in array)
				{
					Color color = ((Renderer)val2).material.color;
					((Renderer)val2).material.color = new Color(0f, 1f, 0f);
				}
				((Component)componentInChildren).gameObject.AddComponent<EnemyIdentifierSaver>().eid = eid;
				((Behaviour)val.GetComponentInChildren<AudioSource>()).enabled = false;
				RemoveOnTime[] componentsInChildren2 = val.GetComponentsInChildren<RemoveOnTime>();
				foreach (RemoveOnTime val3 in componentsInChildren2)
				{
					val3.time /= 3f;
				}
				((Component)componentInChildren).GetComponent<Rigidbody>().isKinematic = false;
				((Collider)((Component)componentInChildren).GetComponent<SphereCollider>()).isTrigger = true;
			}
		}
	}
	internal class IdolHealingExplosion : MonoBehaviour
	{
		public float healing;

		public float healingReducedHardMode;

		public List<EnemyIdentifier> healedList = new List<EnemyIdentifier>();

		public void Update()
		{
			((Collider)((Component)this).GetComponent<SphereCollider>()).enabled = true;
		}

		public void OnTriggerEnter(Collider other)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Invalid comparison between Unknown and I4
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Invalid comparison between Unknown and I4
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Invalid comparison between Unknown and I4
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Expected I4, but got Unknown
			GameObject gameObject = ((Component)other).gameObject;
			if (gameObject.layer != 10 && gameObject.layer != 11)
			{
				return;
			}
			EnemyIdentifierIdentifier component = ((Component)other).GetComponent<EnemyIdentifierIdentifier>();
			if (!Object.op_Implicit((Object)(object)component) || !Object.op_Implicit((Object)(object)component.eid) || component.eid.dead)
			{
				return;
			}
			EnemyIdentifier eid = component.eid;
			if (healedList.Contains(eid))
			{
				return;
			}
			if ((int)eid.enemyType == 1 || (int)eid.enemyType == 9 || (int)eid.enemyType == 38)
			{
				if (!Object.op_Implicit((Object)(object)eid.drone))
				{
					eid.drone = ((Component)eid).GetComponent<Drone>();
				}
				if (Object.op_Implicit((Object)(object)eid.drone) && Object.op_Implicit((Object)(object)eid.drone.Enemy))
				{
					float num = healing;
					if (Util.IsHardMode() && eid.drone.Enemy.health < 8f)
					{
						num = healingReducedHardMode;
					}
					float health = 0.1f * (float)Mathf.RoundToInt(10f * (eid.drone.Enemy.health + num));
					eid.drone.Enemy.health = health;
					eid.health = health;
					healedList.Add(eid);
				}
				return;
			}
			if ((int)eid.enemyType == 4)
			{
				if (!Object.op_Implicit((Object)(object)eid.spider))
				{
					eid.spider = ((Component)eid).GetComponent<MaliciousFace>();
				}
				if (Object.op_Implicit((Object)(object)eid.spider))
				{
					float num2 = healing;
					if (Util.IsHardMode() && eid.spider.spider.health < 8f)
					{
						num2 = healingReducedHardMode;
					}
					float health2 = 0.1f * (float)Mathf.RoundToInt(10f * (eid.spider.spider.health + num2));
					eid.spider.spider.health = health2;
					eid.health = health2;
					healedList.Add(eid);
				}
				return;
			}
			EnemyClass enemyClass = eid.enemyClass;
			EnemyClass val = enemyClass;
			switch ((int)val)
			{
			case 0:
				if (!Object.op_Implicit((Object)(object)eid.zombie))
				{
					eid.zombie = ((Component)eid).GetComponent<Enemy>();
				}
				if (Object.op_Implicit((Object)(object)eid.zombie))
				{
					float num5 = healing;
					if (Util.IsHardMode() && eid.zombie.health < 8f)
					{
						num5 = healingReducedHardMode;
					}
					Plugin.Logger.LogWarning((object)("healing: " + num5));
					float health5 = 0.1f * (float)Mathf.RoundToInt(10f * (eid.zombie.health + num5));
					eid.zombie.health = health5;
					eid.health = health5;
					healedList.Add(eid);
				}
				break;
			case 1:
				if (!Object.op_Implicit((Object)(object)eid.machine))
				{
					eid.machine = ((Component)eid).GetComponent<Enemy>();
				}
				if (Object.op_Implicit((Object)(object)eid.machine))
				{
					float num4 = healing;
					if (Util.IsHardMode() && eid.machine.health < 8f)
					{
						num4 = healingReducedHardMode;
					}
					float health4 = 0.1f * (float)Mathf.RoundToInt(10f * (eid.machine.health + num4));
					eid.machine.health = health4;
					eid.health = health4;
					healedList.Add(eid);
				}
				break;
			case 2:
				if (!Object.op_Implicit((Object)(object)eid.statue))
				{
					eid.statue = ((Component)eid).GetComponent<Enemy>();
				}
				if (Object.op_Implicit((Object)(object)eid.statue))
				{
					float num3 = healing;
					if (Util.IsHardMode() && eid.statue.health < 8f)
					{
						num3 = healingReducedHardMode;
					}
					float health3 = 0.1f * (float)Mathf.RoundToInt(10f * (eid.statue.health + num3));
					eid.statue.health = health3;
					eid.health = health3;
					healedList.Add(eid);
				}
				break;
			}
		}
	}
	public class MirrorReaperMortar : MonoBehaviour
	{
		public bool canShootMortar = false;

		public float cooldown = 0f;

		public float cooldownMax = 2.5f;

		public void Start()
		{
			if (Util.IsHardMode())
			{
				cooldownMax = 1.75f;
			}
		}

		public void Update()
		{
			if (!canShootMortar)
			{
				cooldown += Time.deltaTime;
				if (!(cooldown < cooldownMax))
				{
					cooldown = 0f;
					canShootMortar = true;
				}
			}
		}
	}
	public class MoveBacker : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <MoveBack>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MoveBacker <>4__this;

			private Vector3 <target>5__1;

			private Vector3 <forward>5__2;

			private Vector3 <targetPosition>5__3;

			private NavMeshHit <hit>5__4;

			private LayerMask <groundLayer>5__5;

			private float <navMeshSampleRadius>5__6;

			private float <groundCheckDistance>5__7;

			private Vector3 <rayOrigin>5__8;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0342: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: 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_01ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0277: Unknown result type (might be due to invalid IL or missing references)
				//IL_027c: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				//IL_029e: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a8: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.moving = true;
					if (!Object.op_Implicit((Object)(object)<>4__this.eid) || <>4__this.eid.dead)
					{
						return false;
					}
					<target>5__1 = ((<>4__this.eid.target == null) ? ((Component)MonoSingleton<NewMovement>.Instance).transform.position : <>4__this.eid.target.position);
					<forward>5__2 = <target>5__1 - ((Component)<>4__this).transform.position;
					<forward>5__2.y = 0f;
					((Vector3)(ref <forward>5__2)).Normalize();
					<targetPosition>5__3 = ((Component)<>4__this).transform.position - 15f * <forward>5__2;
					<groundLayer>5__5 = LayerMask.op_Implicit(LayerMask.GetMask(new string[4] { "Outdoors", "OutdoorsBaked", "Environment", "EnvironmentBaked" }));
					<navMeshSampleRadius>5__6 = 1f;
					<groundCheckDistance>5__7 = 2f;
					if (!NavMesh.SamplePosition(<targetPosition>5__3, ref <hit>5__4, <navMeshSampleRadius>5__6, -1))
					{
						<>4__this.moving = false;
						return false;
					}
					<rayOrigin>5__8 = ((NavMeshHit)(ref <hit>5__4)).position + ((Component)<>4__this).transform.up * 0.1f;
					if (!Physics.Raycast(<rayOrigin>5__8, -1f * ((Component)<>4__this).transform.up, <groundCheckDistance>5__7, LayerMask.op_Implicit(<groundLayer>5__5)))
					{
						<>4__this.moving = false;
						return false;
					}
					if (!Object.op_Implicit((Object)(object)<>4__this.nma))
					{
						<>4__this.moving = false;
						return false;
					}
					((Behaviour)<>4__this.nma).enabled = false;
					<>4__this.rb.isKinematic = false;
					<>4__this.rb.useGravity = true;
					<>4__this.rb.drag = 12f;
					<>4__this.rb.AddForce(-<forward>5__2 * <>4__this.strength, (ForceMode)2);
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.rb.isKinematic = true;
					<>4__this.rb.useGravity = false;
					if (!Object.op_Implicit((Object)(object)<>4__this.nma))
					{
						<>4__this.moving = false;
						return false;
					}
					((Behaviour)<>4__this.nma).enabled = true;
					<>4__this.rb.drag = 0f;
					<>4__this.nma.Warp(<>4__this.rb.position);
					<>4__this.moving = false;
					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 Rigidbody rb;

		public NavMeshAgent nma;

		public EnemyIdentifier eid;

		public float strength = 150f;

		public bool moving = false;

		public void Start()
		{
			rb = ((Component)this).GetComponent<Rigidbody>();
			nma = ((Component)this).GetComponent<NavMeshAgent>();
			eid = ((Component)this).GetComponent<EnemyIdentifier>();
		}

		public void Update()
		{
			if (eid.dead)
			{
				Object.Destroy((Object)(object)this);
			}
		}

		[IteratorStateMachine(typeof(<MoveBack>d__7))]
		public IEnumerator MoveBack()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MoveBack>d__7(0)
			{
				<>4__this = this
			};
		}
	}
	public class OriginalHealth : MonoBehaviour
	{
		public float health;
	}
	internal class SentryMortar : MonoBehaviour
	{
		public bool canShootOrb = true;

		public Rigidbody rb;

		public void FixedUpdate()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rb != (Object)null)
			{
				rb.AddForce(0f, -5f * Mathf.Abs(rb.velocity.y), 0f);
			}
		}
	}
	internal class StalkerHealBackMessenger : MonoBehaviour
	{
		public Enemy source;

		public void Awake()
		{
			source = null;
		}

		public void HealSelf()
		{
			Enemy obj = source;
			obj.health += 1.5f;
			EnemyIdentifier eid = source.eid;
			eid.health += 1.5f;
		}
	}
	internal class StalkerHealBack : MonoBehaviour
	{
		public Enemy source;

		public bool healed = false;

		public void Update()
		{
			if ((Object)(object)source == (Object)null || healed)
			{
				return;
			}
			Enemy obj = source;
			obj.health += 1.5f * source.eid.totalDamageModifier;
			EnemyIdentifier eid = source.eid;
			eid.health += 1.5f * source.eid.totalDamageModifier;
			healed = true;
			if (Util.IsHardMode())
			{
				Enemy component = ((Component)this).GetComponent<Enemy>();
				if (component != null)
				{
					component.health += 5f * source.eid.totalDamageModifier;
				}
				EnemyIdentifier component2 = ((Component)this).GetComponent<EnemyIdentifier>();
				if (component2 != null)
				{
					component2.health += 5f * source.eid.totalDamageModifier;
				}
			}
		}
	}
	public class StrayAttack : MonoBehaviour
	{
		public float animSpeedFast = 4f;

		public float animSpeedSlow = 1.75f;

		public int projectilesLeft = 0;

		public Animator anim = null;

		public EnemyIdentifier eid = null;

		public void Update()
		{
			if ((Object)(object)eid == (Object)null || eid.dead || (Object)(object)anim == (Object)null)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			if (projectilesLeft > 0 && (Object)(object)eid.zombie != (Object)null && eid.zombie.grounded)
			{
				anim.speed = animSpeedFast;
			}
			else if ((Object)(object)eid.zombie != (Object)null && !eid.zombie.grounded)
			{
				projectilesLeft = 0;
			}
			if (projectilesLeft == 0)
			{
				anim.speed = animSpeedSlow;
			}
		}
	}
	internal class StreetcleanerAfterburn : MonoBehaviour
	{
		public int damage = 0;

		public int tickCount = 4;

		public float cooldownMax = 0.5f;

		public float cooldown = 0f;

		public bool damagedThePlayer = false;

		public bool stoppedAttacking = false;

		public bool destroyOnEnd = false;

		public int ticks = 0;

		public void Update()
		{
			if (!damagedThePlayer || !stoppedAttacking)
			{
				return;
			}
			cooldown += Time.deltaTime;
			if (cooldown < cooldownMax)
			{
				return;
			}
			cooldown = 0f;
			if (ticks < tickCount)
			{
				ticks++;
				if (!MonoSingleton<NewMovement>.Instance.boost || MonoSingleton<NewMovement>.Instance.sliding)
				{
					MonoSingleton<NewMovement>.Instance.GetHurt(damage, false, 0f, false, false, 0.35f, false);
				}
			}
			else if (destroyOnEnd)
			{
				Object.Destroy((Object)(object)this);
			}
			else
			{
				ticks = 0;
				damagedThePlayer = false;
				stoppedAttacking = false;
			}
		}
	}
	internal class TimerFloat : MonoBehaviour
	{
		public bool deleteOnReached = false;

		public float cooldownMax = 1f;

		public bool running = false;

		public bool keepRunning = false;

		public bool reached = false;

		public float cooldown = 0f;

		public void Update()
		{
			if (reached && deleteOnReached)
			{
				Object.Destroy((Object)(object)this);
			}
			else
			{
				if (!running)
				{
					return;
				}
				cooldown += Time.deltaTime;
				if (!(cooldown < cooldownMax))
				{
					reached = true;
					if (!keepRunning)
					{
						running = false;
					}
				}
			}
		}

		public void Run()
		{
			running = true;
		}

		public void Reset()
		{
			cooldown = 0f;
			reached = false;
		}

		public void ResetAndRun()
		{
			Reset();
			Run();
		}

		public void Stop()
		{
			running = false;
		}

		public void ResetAndStop()
		{
			Reset();
			Stop();
		}
	}
	[HarmonyPatch(typeof(SwingCheck2), "Update")]
	public class CerberusDashPatch
	{
		public static void Postfix(SwingCheck2 __instance)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Util.IsDifficulty(19) && (int)__instance.eid.enemyType == 0 && ((Component)__instance.eid).GetComponent<StatueBoss>().isEnraged)
			{
				__instance.knockBackForce = 23f;
			}
		}
	}
	[HarmonyPatch(typeof(StatueBoss))]
	public class StatueBossPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(StatueBoss), "Start")]
		public static void StartPostfix(StatueBoss __instance)
		{
			if (__instance.difficulty == 19)
			{
				Plugin.SetEnemyWeakness("cannonball", 0.8f, __instance.eid);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StatueBoss), "SetSpeed")]
		public static void SetSpeedPostfix(StatueBoss __instance)
		{
			if (__instance.difficulty == 19)
			{
				if (__instance.eid.totalSpeedModifier > 1.2f)
				{
					__instance.realSpeedModifier -= 0.2f;
				}
				if (Util.IsHardMode())
				{
					__instance.realSpeedModifier *= 1.3f;
				}
				__instance.anim.speed = 1.45f * __instance.realSpeedModifier;
				if (__instance.isEnraged)
				{
					__instance.anim.speed = 1.65f * __instance.realSpeedModifier;
				}
				if (Object.op_Implicit((Object)(object)__instance.nma))
				{
					NavMeshAgent nma = __instance.nma;
					nma.speed *= 1.2f;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StatueBoss), "AttackCheck")]
		public static bool AttackCheckPrefix(StatueBoss __instance)
		{
			if (!Util.IsHardMode())
			{
				return true;
			}
			if (__instance.attackCheckCooldown > 0f)
			{
				return true;
			}
			if (__instance.inAction || !__instance.gc.onGround)
			{
				return false;
			}
			if (!__instance.CheckAndSetAttackVision())
			{
				return false;
			}
			bool flag = !__instance.isEnraged && Random.Range(0, 60) > __instance.tackleChance && Random.Range(0, 4) == 0;
			bool flag2 = __instance.isEnraged && Random.Range(0, 8) == 0;
			if (flag || flag2)
			{
				if (__instance.tackleChance < 50)
				{
					__instance.tackleChance = 50;
				}
				__instance.tackleChance += 20;
				__instance.inAction = true;
				__instance.Stomp();
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StatueBoss), "Tackle")]
		public static void TacklePrefix(StatueBoss __instance, bool __runOriginal)
		{
			//IL_003e: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty == 19 && __runOriginal)
			{
				GameObject val = Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.unparryableFlash, __instance.eid.weakPoint.transform.position + ((Component)__instance).transform.forward * 1.5f, ((Component)__instance).transform.rotation);
				Transform transform = val.transform;
				transform.localScale *= 5f;
				val.transform.SetParent(__instance.eid.weakPoint.transform, true);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StatueBoss), "Tackle")]
		public static void TacklePostfix(StatueBoss __instance, bool __runOriginal)
		{
			if (__instance.difficulty == 19 && __runOriginal)
			{
				__instance.extraTackles = 1;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StatueBoss), "StopDash")]
		public static bool StopDashPrefix(StatueBoss __instance)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			__instance.dashPower = 0f;
			if (__instance.gc.onGround)
			{
				__instance.rb.isKinematic = true;
			}
			else
			{
				__instance.rb.velocity = Vector3.zero;
			}
			__instance.damaging = false;
			__instance.partAud.Stop();
			__instance.StopDamage();
			if (__instance.extraTackles > 0)
			{
				__instance.dontFall = true;
				__instance.extraTackles--;
				__instance.tracking = true;
				__instance.anim.speed = 0.1f;
				GameObject val = Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.unparryableFlash, __instance.eid.weakPoint.transform.position + ((Component)__instance).transform.forward * 1.5f, ((Component)__instance).transform.rotation);
				Transform transform = val.transform;
				transform.localScale *= 5f;
				val.transform.SetParent(__instance.eid.weakPoint.transform, true);
				__instance.anim.Play("Tackle", -1, 0.4f);
				float num = 0.5f;
				if (Util.IsHardMode())
				{
					num = 0.2f;
				}
				else if (__instance.difficulty == 19)
				{
					num = 0.35f;
				}
				((MonoBehaviour)__instance).Invoke("DelayedTackle", num / __instance.realSpeedModifier);
				return false;
			}
			__instance.dontFall = false;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StatueBoss), "StompHit")]
		public static bool StompHitPrefix(StatueBoss __instance)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: 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_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (Util.IsHardMode())
			{
				GroundWave component = Object.Instantiate<GameObject>(Plugin.Prefabs["MirrorReaperGroundWave"], ((Component)__instance).transform.position, ((Component)__instance).transform.rotation).GetComponent<GroundWave>();
				component.target = __instance.eid.target;
				((Component)component).transform.SetParent(Object.op_Implicit((Object)(object)((Component)__instance).transform.parent) ? ((Component)__instance).transform.parent : ((Component)GoreZone.ResolveGoreZone(((Component)__instance).transform)).transform);
				component.lifetime = 15f;
				Breakable componentInChildren = ((Component)component).GetComponentInChildren<Breakable>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.durability = 5f;
				}
				component.eid = __instance.eid;
				component.difficulty = __instance.difficulty;
			}
			__instance.cc.CameraShake(1f);
			if ((Object)(object)__instance.currentStompWave != (Object)null)
			{
				Object.Destroy((Object)(object)__instance.currentStompWave);
			}
			int num = 1;
			switch (__instance.difficulty)
			{
			case 4:
				num = 2;
				break;
			case 5:
				num = 3;
				break;
			case 19:
				num = 2;
				break;
			}
			AudioSource val = default(AudioSource);
			for (int i = 0; i < num; i++)
			{
				__instance.currentStompWave = Object.Instantiate<GameObject>(AddressablesExtensions.ToAsset(__instance.stompWave), new Vector3(__instance.stompPos.position.x, ((Component)__instance).transform.position.y, __instance.stompPos.position.z), Quaternion.identity);
				PhysicalShockwave component2 = __instance.currentStompWave.GetComponent<PhysicalShockwave>();
				switch (__instance.difficulty)
				{
				case 19:
					component2.speed = 100f;
					break;
				case 4:
				case 5:
					component2.speed = 75f;
					break;
				case 3:
					component2.speed = 50f;
					break;
				case 2:
					component2.speed = 35f;
					break;
				case 1:
					component2.speed = 25f;
					break;
				case 0:
					component2.speed = 15f;
					break;
				}
				component2.damage = Mathf.RoundToInt(25f * __instance.eid.totalDamageModifier);
				component2.maxSize = 100f;
				component2.enemy = true;
				component2.enemyType = (EnemyType)0;
				if (i != 0)
				{
					component2.speed /= (float)(1 + i * 2);
					if (((Component)component2).TryGetComponent<AudioSource>(ref val))
					{
						((Behaviour)val).enabled = false;
					}
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StatueBoss), "OrbSpawn")]
		public static bool OrbSpawnPrefix(StatueBoss __instance)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			Vector3 val = ((Component)__instance).transform.position + Vector3.up * 3.5f;
			Vector3 val2 = ((EnemyScript)__instance).ToPlanePos(((Component)__instance.orbLight).transform.position) + Vector3.up * 3.5f - val;
			PhysicsCastResult val3 = default(PhysicsCastResult);
			Vector3 val4 = default(Vector3);
			PortalTraversalV2[] array = default(PortalTraversalV2[]);
			PortalPhysicsV2.ProjectThroughPortals(val, val2, LayerMask.op_Implicit(default(LayerMask)), ref val3, ref val4, ref array);
			Vector3 val5 = val4;
			bool flag = false;
			Vector3 val6 = __instance.predictedTargetPosition;
			if (array.Length != 0)
			{
				PortalTraversalV2 val7 = array[0];
				PortalHandle portalHandle = val7.portalHandle;
				Portal portalObject = val7.portalObject;
				if (((Enum)portalObject.GetTravelFlags(portalHandle.side)).HasFlag((Enum)(object)(PortalTravellerFlags)16))
				{
					Matrix4x4 travelMatrix = PortalUtils.GetTravelMatrix(array);
					val6 = ((Matrix4x4)(ref travelMatrix)).MultiplyPoint3x4(val6);
				}
				else if (!portalObject.passThroughNonTraversals)
				{
					val5 = PortalTransformExtensions.GetPositionInFront(portalObject.GetTransform(portalHandle.side), array[0].entrancePoint, 0.01f);
					flag = true;
				}
			}
			GameObject val8 = Object.Instantiate<GameObject>(AddressablesExtensions.ToAsset(__instance.orbProjectile), val5, Quaternion.identity);
			val8.transform.LookAt(val6);
			Rigidbody val9 = default(Rigidbody);
			if (val8.TryGetComponent<Rigidbody>(ref val9))
			{
				float num = 10000f;
				if (__instance.difficulty > 2)
				{
					num = 20000f;
				}
				else if (__instance.difficulty == 2)
				{
					num = 15000f;
				}
				val9.AddForce(val8.transform.forward * num);
			}
			Projectile val10 = default(Projectile);
			if (val8.TryGetComponent<Projectile>(ref val10))
			{
				val10.target = __instance.eid.target;
				Projectile obj = val10;
				obj.damage *= __instance.eid.totalDamageModifier;
				if (__instance.difficulty <= 2)
				{
					val10.bigExplosion = false;
				}
				else if (__instance.difficulty == 19)
				{
					val10.homingType = (HomingType)1;
					val10.turningSpeedMultiplier = 0.7f;
					val10.speed = 90f;
					val9.useGravity = false;
				}
				if (flag)
				{
					val10.Explode();
				}
			}
			__instance.orbGrowing = false;
			__instance.orbLight.range = 0f;
			__instance.part.Play();
			return false;
		}
	}
	[HarmonyPatch(typeof(Drone))]
	public class DronePatch
	{
		[CompilerGenerated]
		private sealed class <ShootGeryonBeamCoroutine>d__12 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Drone __instance;

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

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

			[DebuggerHidden]
			public <ShootGeryonBeamCoroutine>d__12(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.7f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (__instance.eid.dead)
					{
						return false;
					}
					ShootGeryonBeam(__instance);
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public Drone __instance;

			public float rotationOffset;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Expected O, but got Unknown
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.7f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (__instance.eid.dead)
					{
						return false;
					}
					ShootGeryonBeam(__instance);
					<>2__current = (object)new WaitForSeconds(0.75f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (__instance.eid.dead)
					{
						return false;
					}
					ShootGeryonBeam(__instance, rotationOffset);
					ShootGeryonBeam(__instance, 0f - rotationOffset);
					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();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Drone), "Start")]
		public static void StartPostfix(Drone __instance)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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_00e1: Invalid comparison between Unknown and I4
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Invalid comparison between Unknown and I4
			if (__instance.difficulty != 19)
			{
				return;
			}
			bool flag = (Object)(object)((Component)__instance).GetComponent<DroneFlesh>() != (Object)null;
			EnemyIdentifier eid = __instance.eid;
			EnemyType enemyType = eid.enemyType;
			EnemyType val = enemyType;
			if ((int)val != 1)
			{
				if ((int)val != 9)
				{
					if ((int)val == 38)
					{
						Plugin.SetEnemyWeakness("cannonball", 2f, eid);
						Plugin.SetEnemyWeakness("railcannon", 0.75f, eid);
					}
				}
				else
				{
					Plugin.SetEnemyWeakness("railcannon", 0.5f, eid);
				}
			}
			else if (!flag)
			{
				CounterInt counterInt = ((Component)__instance).gameObject.AddComponent<CounterInt>();
				counterInt.randomized = true;
				counterInt.randomMin = 4;
				counterInt.randomMax = 6;
				counterInt.value += 2;
			}
			if (!Util.IsHardMode())
			{
				return;
			}
			EnemyType enemyType2 = eid.enemyType;
			EnemyType val2 = enemyType2;
			if ((int)val2 != 1)
			{
				if ((int)val2 != 9)
				{
					if ((int)val2 == 38)
					{
						OriginalHealth originalHealth = ((Component)__instance).gameObject.AddComponent<OriginalHealth>();
						originalHealth.health = __instance.enemy.health;
						BoolValue boolValue = ((Component)__instance).gameObject.AddComponent<BoolValue>();
						boolValue.description = "enraged";
						boolValue.value = false;
						CounterInt counterInt2 = ((Component)__instance).gameObject.AddComponent<CounterInt>();
						counterInt2.maxValue = 3;
						counterInt2.Add();
						Plugin.SetEnemyWeakness("cannonball", 1f, eid);
					}
				}
				else
				{
					CounterInt counterInt3 = ((Component)__instance).gameObject.AddComponent<CounterInt>();
					counterInt3.maxValue = 2;
				}
			}
			else if (!flag)
			{
				OriginalHealth originalHealth2 = ((Component)__instance).gameObject.AddComponent<OriginalHealth>();
				originalHealth2.health = __instance.enemy.health;
				Util.AddToArray(ref eid.weaknesses, "revolver");
				Util.AddToArray(ref eid.weaknessMultipliers, 0.4f);
				TimerFloat timerFloat = ((Component)__instance).gameObject.AddComponent<TimerFloat>();
				timerFloat.cooldownMax = 0.2f;
				timerFloat.cooldown = 0.2f;
				timerFloat.Run();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Drone), "GetHurt")]
		public static void GetHurtPrefix(Vector3 force, ref float multiplier, GameObject sourceWeapon, bool fromExplosion, Drone __instance)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Invalid comparison between Unknown and I4
			if (!Util.IsHardMode())
			{
				return;
			}
			bool flag = (Object)(object)((Component)__instance).GetComponent<DroneFlesh>() != (Object)null;
			if ((int)__instance.eid.enemyType == 1 && !flag)
			{
				if (!(__instance.eid.hitter != "explosion") || !(__instance.eid.hitter != "ffexplosion"))
				{
					TimerFloat component = ((Component)__instance).GetComponent<TimerFloat>();
					if (!component.reached)
					{
						multiplier = 0f;
						return;
					}
					component.ResetAndRun();
					OriginalHealth component2 = ((Component)__instance).GetComponent<OriginalHealth>();
					multiplier = Mathf.Min(multiplier, component2.health / 2f);
				}
			}
			else if ((int)__instance.eid.enemyType == 38)
			{
				OriginalHealth component3 = ((Component)__instance).GetComponent<OriginalHealth>();
				multiplier = Mathf.Min(multiplier, component3.health / 2f);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Drone), "Dodge", new Type[] { typeof(Vector3) })]
		public static bool DodgePrefix(ref Vector3 direction, Drone __instance, bool __runOriginal)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Invalid comparison between Unknown and I4
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			if (!__runOriginal)
			{
				return false;
			}
			if (__instance.difficulty != 19)
			{
				return true;
			}
			float num = 20f;
			if (Util.IsHardMode())
			{
				num = 35f;
			}
			if ((int)__instance.eid.enemyType == 38)
			{
				num = 600f;
			}
			else if ((int)__instance.eid.enemyType == 9)
			{
				num = 150f;
			}
			num *= __instance.eid.totalSpeedModifier;
			if (PortalPhysicsV2.Raycast(((Component)__instance).transform.position, ((Vector3)(ref direction)).normalized, 7f, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1)), (QueryTriggerInteraction)0))
			{
				direction *= -1f;
			}
			if (Object.op_Implicit((Object)(object)__instance.dodgeSound) && !__instance.hasDimensionalTarget)
			{
				OneShotAudioExtension.PlayClipAtPoint(__instance.dodgeSound, MonoSingleton<AudioMixerController>.Instance.allGroup, ((Component)__instance).transform.position, 128, 0f, 0.15f, Random.Range(0.75f, 1.25f), (AudioRolloffMode)1, 1f, 100f);
			}
			__instance.rb.AddForce(((Vector3)(ref direction)).normalized * num, (ForceMode)1);
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Drone), "GetCooldownSpeed")]
		public static bool GetCooldownSpeedPrefix(ref float __result, Drone __instance)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0045: Invalid comparison between Unknown and I4
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Invalid comparison between Unknown and I4
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			if (__instance.difficulty != 19)
			{
				return true;
			}
			float num = (float)__instance.difficulty / 2f;
			if (Util.IsHardMode())
			{
				EnemyType enemyType = __instance.eid.enemyType;
				EnemyType val = enemyType;
				if ((int)val != 1 && (int)val != 9)
				{
					if ((int)val == 38)
					{
						num = 2f;
					}
				}
				else
				{
					num = 2.8f;
				}
			}
			else if (__instance.difficulty == 19)
			{
				EnemyType enemyType2 = __instance.eid.enemyType;
				EnemyType val2 = enemyType2;
				if ((int)val2 != 1 && (int)val2 != 9)
				{
					if ((int)val2 == 38)
					{
						num = 1.65f;
					}
				}
				else
				{
					num = 2.25f;
				}
			}
			else if ((int)__instance.eid.enemyType == 38 && __instance.difficulty >= 3)
			{
				num -= (num - 1f) / 2f;
			}
			else if ((int)__instance.eid.enemyType == 9 && __instance.difficulty >= 4)
			{
				num = 1.2f;
			}
			else if (__instance.difficulty == 1)
			{
				num = 0.75f;
			}
			else if (__instance.difficulty == 0)
			{
				num = 0.5f;
			}
			if (num == 0f)
			{
				num = 0.25f;
			}
			__result = num * __instance.eid.totalSpeedModifier;
			return false;
		}

		public static GameObject SpawnBigOrb(Vector3 position, Quaternion rotation, EnemyTarget target, bool startsSlow = false)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileExplosiveHH"], position, rotation);
			Projectile component = val.GetComponent<Projectile>();
			Transform transform = val.transform;
			transform.localScale *= 0.75f;
			component.damage = 35f;
			component.speed = 55f;
			component.bigExplosion = false;
			component.target = target;
			Explosion[] componentsInChildren = ((Component)component.explosionEffect.transform).GetComponentsInChildren<Explosion>();
			foreach (Explosion val2 in componentsInChildren)
			{
				BillionExplosionController billionExplosionController = ((Component)val2).GetComponent<BillionExplosionController>();
				if ((Object)(object)billionExplosionController == (Object)null)
				{
					billionExplosionController = ((Component)val2).gameObject.AddComponent<BillionExplosionController>();
				}
				billionExplosionController.enemyDamageMultiplier = 0f;
			}
			component.homingType = (HomingType)0;
			component.turningSpeedMultiplier = 0f;
			ProjectileSpeedStutter projectileSpeedStutter = ((Component)component).gameObject.AddComponent<ProjectileSpeedStutter>();
			projectileSpeedStutter.homing = true;
			projectileSpeedStutter.slowRate = 2.25f;
			projectileSpeedStutter.explodeWhenClose = true;
			projectileSpeedStutter.changeColor = true;
			projectileSpeedStutter.explodeDistance = 8f;
			projectileSpeedStutter.explodeStutterDelay = 2;
			projectileSpeedStutter.originalSpeed = component.speed;
			if (startsSlow)
			{
				component.speed = 1f;
				projectileSpeedStutter.cooldown = -0.4f;
			}
			projectileSpeedStutter.targetSpeedMultiplier = 0f;
			return val;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Drone), "Explode")]
		public static void ExplodePrefix(Drone __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00d6: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: 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)
			if (!Util.IsHardMode() || (int)__instance.eid.enemyType != 1 || (Object)(object)((Component)__instance).GetComponent<DroneFlesh>() != (Object)null || BoolValue.Get("shotOrbOnDeath", ((Component)__instance).gameObject).GetValueOrDefault() || Random.Range(0, 2) == 0)
			{
				return;
			}
			Vector3 position = ((Component)__instance).transform.position;
			Vector3 forward = ((Component)__instance).transform.forward;
			Vector3 position2 = position + forward;
			Quaternion val = ((Component)__instance).transform.rotation;
			PhysicsCastResult val2 = default(PhysicsCastResult);
			Vector3 val3 = default(Vector3);
			PortalTraversalV2[] array = default(PortalTraversalV2[]);
			PortalPhysicsV2.ProjectThroughPortals(position, forward, LayerMask.op_Implicit(default(LayerMask)), ref val2, ref val3, ref array);
			bool flag = false;
			if (array.Length != 0)
			{
				PortalTraversalV2 val4 = array[0];
				PortalHandle portalHandle = val4.portalHandle;
				Portal portalObject = val4.portalObject;
				if (((Enum)portalObject.GetTravelFlags(portalHandle.side)).HasFlag((Enum)(object)(PortalTravellerFlags)16))
				{
					Matrix4x4 travelMatrix = PortalUtils.GetTravelMatrix(array);
					position2 = val3;
					val = ((Matrix4x4)(ref travelMatrix)).rotation * val;
				}
				else
				{
					position2 = PortalTransformExtensions.GetPositionInFront(portalObject.GetTransform(portalHandle.side), array[0].entrancePoint, 0.05f);
					flag = !portalObject.passThroughNonTraversals;
				}
			}
			EnemyTarget target = __instance?.eid?.target;
			if (__instance?.eid?.target == null)
			{
				target = new EnemyTarget(((Component)MonoSingleton<NewMovement>.Instance).transform);
			}
			GameObject val5 = SpawnBigOrb(position2, val, target, startsSlow: true);
			if (__instance != null)
			{
				EnemyIdentifier eid = __instance.eid;
				Vector3? obj;
				if (eid == null)
				{
					obj = null;
				}
				else
				{
					EnemyTarget target2 = eid.target;
					obj = ((target2 != null) ? new Vector3?(target2.position) : null);
				}
				Vector3? val6 = obj;
				if (val6.HasValue)
				{
					val5.transform.LookAt(__instance.eid.target.position);
				}
			}
			Transform transform = val5.transform;
			transform.position += 5f * val5.transform.forward;
			val5.GetComponent<ProjectileSpeedStutter>().explodeStutterCounter = -1;
			BoolValue boolValue = ((Component)__instance).gameObject.AddComponent<BoolValue>();
			boolValue.value = true;
			boolValue.description = "shotOrbOnDeath";
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Drone), "Update")]
		public static bool UpdatePrefix(Drone __instance)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Invalid comparison between Unknown and I4
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Invalid comparison between Unknown and I4
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Invalid comparison between Unknown and I4
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Invalid comparison between Unknown and I4
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Invalid comparison between Unknown and I4
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Invalid comparison between Unknown and I4
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.crashing)
			{
				return false;
			}
			__instance.UpdateRigidbodySettings();
			bool flag = __instance.hasAnyTarget || ((int)__instance.eid.enemyType == 9 && __instance.eid.target != null);
			if ((__instance.targetSpotted || (int)__instance.eid.enemyType == 9) && flag)
			{
				if (__instance.hasDroneVision)
				{
					TargetData val = __instance.vision.CalculateData(__instance.droneTargetHandle);
					__instance.viewTarget = val.headPosition;
				}
				else if (__instance.hasDimensionalTarget)
				{
					__instance.viewTarget = __instance.lastDimensionalTarget;
				}
				else if ((int)__instance.eid.enemyType == 9 && __instance.eid.target != null)
				{
					__instance.viewTarget = __instance.eid.target.position;
				}
				float num = __instance.GetCooldownSpeed();
				if ((int)__instance.eid.enemyType == 38 && __instance.difficulty <= 3)
				{
					num /= 2f;
				}
				if (__instance.dodgeCooldown > 0f)
				{
					__instance.dodgeCooldown = Mathf.MoveTowards(__instance.dodgeCooldown, 0f, Time.deltaTime * num);
				}
				else if (!__instance.stationary && !__instance.lockPosition)
				{
					__instance.dodgeCooldown = Random.Range(1f, 3f);
					__instance.RandomDodge(false);
				}
			}
			if (__instance.ShouldProcessAttack())
			{
				float num2 = __instance.GetCooldownSpeed();
				if (__instance.difficulty == 19 && (int)__instance.eid.enemyType == 9)
				{
					num2 = 1.2f;
					float num3 = ((!Util.IsHardMode()) ? 1f : 2.25f);
					num2 *= num3 * __instance.eid.totalSpeedModifier;
				}
				if (__instance.attackCooldown > 0f)
				{
					__instance.attackCooldown = Mathf.MoveTowards(__instance.attackCooldown, 0f, Time.deltaTime * num2);
				}
				else if (__instance.projectile != null && (!Object.op_Implicit((Object)(object)__instance.vc) || __instance.vc.virtueCooldown == 0f))
				{
					__instance.ProcessAttack();
				}
			}
			if (Object.op_Implicit((Object)(object)__instance.eid) && __instance.eid.hooked && !__instance.hooked)
			{
				__instance.Hooked();
			}
			else if (Object.op_Implicit((Object)(object)__instance.eid) && !__instance.eid.hooked && __instance.hooked)
			{
				__instance.Unhooked();
			}
			if (__instance.enemy.parryable)
			{
				__instance.sinceParryable = TimeSince.op_Implicit(0f);
			}
			if ((int)__instance.eid.enemyType == 38 && __instance.hooked && !__instance.CanBeHooked())
			{
				MonoSingleton<HookArm>.Instance.StopThrow(1f, true);
				__instance.Unhooked();
				__instance.RandomDodge(true);
			}
			if (__instance.droneWingRotationSpeed != 0f)
			{
				for (int i = 0; i < __instance.rotatorWings.Length; i++)
				{
					__instance.rotatorWings[i].Rotate(Vector3.right, 360f * Time.deltaTime * __instance.droneWingRotationSpeed * (float)((i % 2 != 0) ? 1 : (-1)));
				}
			}
			if (!Util.IsHardMode() || (int)__instance.eid.enemyType != 38)
			{
				return false;
			}
			OriginalHealth component = ((Component)__instance).GetComponent<OriginalHealth>();
			if (__instance.eid.health > 0.5f * component.health || BoolValue.Get("enraged", ((Component)__instance).gameObject).GetValueOrDefault())
			{
				return false;
			}
			BoolValue.Set("enraged", newValue: true, ((Component)__instance).gameObject);
			GameObject val2 = Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.enrageEffect, ((Component)__instance).transform.Find("Providence"));
			val2.transform.localScale = 0.25f * Vector3.one;
			val2.transform.localPosition = new Vector3(0f, 0f, -0.2f);
			SkinnedMeshRenderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (SkinnedMeshRenderer val3 in componentsInChildren)
			{
				((Renderer)val3).material.color = new Color(1f, 0.4f, 0.4f, 1f);
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Drone), "Shoot")]
		public static bool ShootPrefix(Drone __instance)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Invalid comparison between Unknown and I4
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Invalid comparison between Unknown and I4
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Invalid comparison between Unknown and I4
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_0517: Invalid comparison between Unknown and I4
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0544: Unknown result type (might be due to invalid IL or missing references)
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Expected O, but got Unknown
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b2: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			__instance.enemy.parryable = false;
			if (__instance.crashing || !__instance.projectile.RuntimeKeyIsValid())
			{
				return false;
			}
			if ((int)__instance.eid.enemyType == 1 && !__instance.eid.puppet)
			{
				EnemySimplifier[] componentsInChildren = ((Component)__instance.modelTransform).GetComponentsInChildren<EnemySimplifier>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].ChangeMaterialNew((MaterialState)0, __instance.origMaterial);
				}
			}
			if (!((Component)__instance).gameObject.activeInHierarchy)
			{
				return false;
			}
			Vector3 position = ((Component)__instance).transform.position;
			Vector3 forward = ((Component)__instance).transform.forward;
			Vector3 val = position + forward;
			Quaternion val2 = ((Component)__instance).transform.rotation;
			PhysicsCastResult val3 = default(PhysicsCastResult);
			Vector3 val4 = default(Vector3);
			PortalTraversalV2[] array = default(PortalTraversalV2[]);
			PortalPhysicsV2.ProjectThroughPortals(position, forward, LayerMask.op_Implicit(default(LayerMask)), ref val3, ref val4, ref array);
			bool flag = false;
			if (array.Length != 0)
			{
				PortalTraversalV2 val5 = array[0];
				PortalHandle portalHandle = val5.portalHandle;
				Portal portalObject = val5.portalObject;
				if (((Enum)portalObject.GetTravelFlags(portalHandle.side)).HasFlag((Enum)(object)(PortalTravellerFlags)16))
				{
					Matrix4x4 travelMatrix = PortalUtils.GetTravelMatrix(array);
					val = val4;
					val2 = ((Matrix4x4)(ref travelMatrix)).rotation * val2;
				}
				else
				{
					val = PortalTransformExtensions.GetPositionInFront(portalObject.GetTransform(portalHandle.side), array[0].entrancePoint, 0.05f);
					flag = !portalObject.passThroughNonTraversals;
				}
			}
			CounterInt component = ((Component)__instance).GetComponent<CounterInt>();
			bool flag2 = __instance.difficulty == 19 && (int)__instance.eid.enemyType == 1 && (Object)(object)component != (Object)null && component.value == component.maxValue;
			bool flag3 = Util.IsHardMode() && (int)__instance.eid.enemyType == 38 && (Object)(object)component != (Object)null && component.value == component.maxValue;
			List<Projectile> list = new List<Projectile>();
			GameObject val6;
			if (flag2)
			{
				EnemyTarget target = __instance?.eid?.target;
				if (__instance?.eid?.target == null)
				{
					target = new EnemyTarget(((Component)MonoSingleton<NewMovement>.Instance).transform);
				}
				val6 = SpawnBigOrb(val, val2, target);
			}
			else if (flag3)
			{
				ShootFart(__instance, 55f);
				ShootFart(__instance, -55f);
				val6 = null;
			}
			else
			{
				val6 = Object.Instantiate<GameObject>(AddressablesExtensions.ToAsset(__instance.projectile), val, val2);
			}
			if ((int)__instance.eid.enemyType == 1)
			{
				if (__instance.difficulty == 19)
				{
					component.Add();
				}
				Transform transform = val6.transform;
				Vector3 position2 = transform.position;
				Vector3 up = transform.up;
				Quaternion rotation = transform.rotation;
				Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
				if (!flag2)
				{
					Transform transform2 = val6.transform;
					transform2.localScale *= 0.5f;
				}
				val6.transform.rotation = Quaternion.Euler(eulerAngles.x, eulerAngles.y, (float)Random.Range(0, 360));
				list.Add(val6.GetComponent<Projectile>());
				List<Projectile> list2 = list;
				__instance.SetProjectileSettings(list2[list2.Count - 1]);
				GameObject val7 = Object.Instantiate<GameObject>(AddressablesExtensions.ToAsset(__instance.projectile), position2 + up, rotation);
				if (__instance.difficulty > 2)
				{
					val7.transform.rotation = Quaternion.Euler(eulerAngles.x + 10f, eulerAngles.y, eulerAngles.z);
				}
				Transform transform3 = val7.transform;
				transform3.localScale *= 0.5f;
				list.Add(val7.GetComponent<Projectile>());
				List<Projectile> list3 = list;
				__instance.SetProjectileSettings(list3[list3.Count - 1]);
				val7 = Object.Instantiate<GameObject>(AddressablesExtensions.ToAsset(__instance.projectile), position2 - up, rotation);
				if (__instance.difficulty > 2)
				{
					val7.transform.rotation = Quaternion.Euler(eulerAngles.x - 10f, eulerAngles.y, eulerAngles.z);
				}
				Transform transform4 = val7.transform;
				transform4.localScale *= 0.5f;
				list.Add(val7.GetComponent<Projectile>());
				List<Projectile> list4 = list;
				__instance.SetProjectileSettings(list4[list4.Count - 1]);
			}
			else if ((int)__instance.eid.enemyType == 38)
			{
				if (Util.IsHardMode())
				{
					component.Add();
				}
				__instance.rb.AddForce(((Component)__instance).transform.forward * -1500f, (ForceMode)1);
				if (!flag3)
				{
					__instance.SetProjectileSettings(val6.GetComponent<Projectile>());
				}
				if (__instance.difficulty == 19 && !flag3)
				{
					float num = ((!Util.IsHardMode()) ? 2.5f : 3.35f);
					float beamWidth = ((!Util.IsHardMode()) ? 2.2f : 3f);
					val6.transform.localScale = new Vector3(num, num, num);
					LineRenderer[] componentsInChildren2 = val6.GetComponentsInChildren<LineRenderer>();
					foreach (LineRenderer val8 in componentsInChildren2)
					{
						val8.startWidth = num;
						val8.endWidth = num;
					}
					ContinuousBeam[] componentsInChildren3 = val6.GetComponentsInChildren<ContinuousBeam>();
					foreach (ContinuousBeam val9 in componentsInChildren3)
					{
						val9.beamWidth = beamWidth;
						val9.canHitEnemy = false;
					}
					val6.GetComponent<Projectile>().enemyDamageMultiplier = 0f;
					if (Util.IsHardMode())
					{
						if (!BoolValue.Get("enraged", ((Component)__instance).gameObject).GetValueOrDefault())
						{
							Spin val10 = val6.AddComponent<Spin>();
							val10.notRelative = false;
							val10.spinDirection = new Vector3(0f, 0f, 1f);
							val10.speed = 135f;
						}
						else
						{
							TimedRotator timedRotator = val6.AddComponent<TimedRotator>();
							timedRotator.angle = 22.5f;
							timedRotator.cooldownMax = 0.25f;
							timedRotator.spinDirection = new Vector3(0f, 0f, 1f);
						}
					}
				}
			}
			else
			{
				__instance.SetProjectileSettings(val6.GetComponent<Projectile>());
			}
			if (flag)
			{
				for (int l = 1; l < list.Count; l++)
				{
					list[l].Explode();
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Drone), "SetProjectileSettings")]
		public static void SetProjectileSettingsPrefix(Projectile proj, Drone __instance, out bool __state)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if ((int)__instance.eid.enemyType != 1)
			{
				__state = false;
			}
			else if (__instance.difficulty == 19 && proj.speed == 55f)
			{
				__state = true;
			}
			else
			{
				__state = false;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Drone), "SetProjectileSettings")]
		public static void SetProjectileSettingsPostfix(Projectile proj, Drone __instance, bool __state)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			if (__instance.difficulty != 19 || (int)__instance.eid.enemyType != 1)
			{
				return;
			}
			ProjectileSpeedStutter projectileSpeedStutter = ((Component)proj).GetComponent<ProjectileSpeedStutter>();
			if ((Object)(object)projectileSpeedStutter == (Object)null)
			{
				projectileSpeedStutter = ((Component)proj).gameObject.AddComponent<ProjectileSpeedStutter>();
			}
			if (!__state)
			{
				proj.speed = 90f;
				if (Util.IsHardMode())
				{
					proj.speed = 110f;
				}
				projectileSpeedStutter.originalSpeed = proj.speed;
				projectileSpeedStutter.slowRate = 3.75f;
				if (Util.IsHardMode())
				{
					projectileSpeedStutter.slowRate = 4.25f;
				}
			}
		}

		public static GameObject ShootFart(Drone __instance, float rotationOffset = 0f)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_004e: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance.eid == (Object)null || __instance.eid.target == null)
			{
				return null;
			}
			Vector3 val = __instance.eid.target.position - ((Component)__instance).transform.position;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			Quaternion val2 = Quaternion.LookRotation(normalized);
			Vector3 eulerAngles = ((Quaternion)(ref val2)).eulerAngles;
			eulerAngles.y += rotationOffset;
			val2 = Quaternion.Euler(eulerAngles);
			GameObject val3 = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileHomingAcid"], ((Component)__instance).transform.position + val2 * Vector3.forward * 5f, val2);
			Projectile component = val3.GetComponent<Projectile>();
			component.safeEnemyType = (EnemyType)38;
			component.speed = 25f;
			component.target = __instance.eid.target;
			HurtZone componentInChildren = val3.GetComponentInChildren<HurtZone>(true);
			componentInChildren.affected = (AffectedSubjects)1;
			return val3;
		}

		public static GameObject ShootGeryonBeam(Drone __instance, float rotationOffset = 0f)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["GeryonForwardArrowBeam"], ((Component)__instance).transform.position, Quaternion.identity);
			val.transform.LookAt(__instance.eid.target.position);
			val.transform.eulerAngles = new Vector3(0f, val.transform.eulerAngles.y + rotationOffset, 0f);
			Transform transform = val.transform;
			transform.position += 5f * val.transform.forward;
			Transform transform2 = val.transform;
			transform2.localScale *= 0.75f;
			HurtZone componentInChildren = val.GetComponentInChildren<HurtZone>();
			componentInChildren.affected = (AffectedSubjects)1;
			componentInChildren.hardDamagePercentage = 0.5f;
			ConstantForce component = val.GetComponent<ConstantForce>();
			component.relativeForce *= 1.25f;
			RemoveOnTime val2 = val.AddComponent<RemoveOnTime>();
			val2.time = 7f;
			ScaleTransform[] componentsInChildren = val.GetComponentsInChildren<ScaleTransform>();
			ScaleTransform[] array = componentsInChildren;
			foreach (ScaleTransform val3 in array)
			{
				val3.speed = 2.5f;
			}
			val.AddComponent<RemoveOnRespawn>();
			return val;
		}

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

		[IteratorStateMachine(typeof(<ShootGeryonBeamsEnragedCoroutine>d__13))]
		public static IEnumerator ShootGeryonBeamsEnragedCoroutine(Drone __instance, float rotationOffset = 0f)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ShootGeryonBeamsEnragedCoroutine>d__13(0)
			{
				__instance = __instance,
				rotationOffset = rotationOffset
			};
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Drone), "ShootSecondary")]
		public static bool ShootSecondaryPrefix(Drone __instance)
		{
			//IL_0065: 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_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)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.crashing || !__instance.secondaryProjectile.RuntimeKeyIsValid())
			{
				return false;
			}
			__instance.anim.Play("BeamPrep");
			GameObject val = Object.Instantiate<GameObject>(AddressablesExtensions.ToAsset(__instance.secondaryProjectile), ((Component)__instance).transform.position + ((Component)__instance).transform.forward, ((Component)__instance).transform.rotation);
			val.transform.SetParent(((Component)__instance).transform, true);
			Pincer val2 = default(Pincer);
			if (val.TryGetComponent<Pincer>(ref val2))
			{
				val2.difficulty = __instance.difficulty;
				__instance.droneCurrentRotation = 0f;
				__instance.droneWingRotationSpeed = ((Random.Range(0f, 1f) > 0.5f) ? 1 : (-1));
				Pincer obj = val2;
				obj.direction *= __instance.droneWingRotationSpeed;
				val2.firedMessageReceiver = ((Component)__instance).gameObject;
			}
			ContinuousBeam[] componentsInChildren = val.GetComponentsInChildren<ContinuousBeam>();
			foreach (ContinuousBeam val3 in componentsInChildren)
			{
				val3.canHitEnemy = false;
			}
			if (!Util.IsHardMode())
			{
				return false;
			}
			if (!BoolValue.Get("enraged", ((Component)__instance).gameObject).GetValueOrDefault())
			{
				return false;
			}
			GameObject gameObject = ((Component)((Component)__instance).GetComponentInChildren<Pincer>()).gameObject;
			Pincer component = Object.Instantiate<GameObject>(gameObject, ((Component)__instance).transform).GetComponent<Pincer>();
			component.rotationSpeed /= 2f;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Drone), "SpawnDroneInsignia")]
		public static bool SpawnDroneInsigniaPrefix(Drone __instance)
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Invalid comparison between Unknown and I4
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.eid.target == null)
			{
				return false;
			}
			if (__instance.crashing)
			{
				return false;
			}
			if (Util.IsHardMode())
			{
				CounterInt component = ((Component)__instance).GetComponent<CounterInt>();
				if (component.value == 2)
				{
					component.Add();
					if (!__instance.isEnraged)
					{
						((MonoBehaviour)__instance).StartCoroutine(ShootGeryonBeamCoroutine(__instance));
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(ShootGeryonBeamsEnragedCoroutine(__instance, 25f));
					}
					return false;
				}
				component.Add();
			}
			__instance.enemy.parryable = false;
			GameObject val = Object.Instantiate<GameObject>(AddressablesExtensions.ToAsset(__instance.projectile), __instance.eid.target.position, Quaternion.identity);
			val.SetActive(false);
			VirtueInsignia component2 = val.GetComponent<VirtueInsignia>();
			component2.target = __instance.eid.target;
			component2.parentEnemy = __instance.enemy;
			component2.hadParent = true;
			if (Util.IsHardMode())
			{
				((Component)val.transform.Find("Capsule")).GetComponent<CapsuleCollider>().radius = 0.425f;
				Follow val2 = val.AddComponent<Follow>();
				val2.speed = 4f;
				if (__instance.isEnraged)
				{
					val2.speed = 2f;
				}
				val2.followY = false;
				val2.mimicRotation = false;
				val2.target = __instance.eid.target.targetTransform;
			}
			if (__instance.isEnraged)
			{
				component2.explosionLength = 1.5f;
				component2.predictive = false;
				val.transform.localScale = new Vector3(3.85f, 1f, 3.85f);
				SpriteRenderer[] componentsInChildren = val.GetComponentsInChildren<SpriteRenderer>(true);
				foreach (SpriteRenderer val3 in componentsInChildren)
				{
					if (((Object)val3).name != "Shockwave")
					{
						val3.sprite = component2.predictiveVersion;
					}
				}
			}
			if (__instance.difficulty == 1)
			{
				component2.windUpSpeedMultiplier = 0.875f;
			}
			else if (__instance.difficulty == 0)
			{
				component2.windUpSpeedMultiplier = 0.75f;
			}
			if (__instance.difficulty == 19)
			{
				if (!__instance.isEnraged)
				{
					component2.explosionLength = 5f;
				}
			}
			else if (__instance.difficulty >= 4)
			{
				component2.explosionLength = ((__instance.difficulty == 5) ? 5f : 3.5f);
			}
			if ((int)MonoSingleton<PlayerTracker>.Instance.playerType == 1)
			{
				Transform transform = val.transform;
				transform.localScale *= 0.75f;
				component2.windUpSpeedMultiplier *= 0.875f;
			}
			component2.windUpSpeedMultiplier *= __instance.eid.totalSpeedModifier;
			component2.damage = Mathf.RoundToInt((float)component2.damage * __instance.eid.totalDamageModifier);
			val.SetActive(true);
			__instance.chargeParticle.Stop(false, (ParticleSystemStopBehavior)0);
			__instance.usedAttacks++;
			if (((Util.IsHardMode() && __instance.usedAttacks > 1) || (__instance.difficulty > 2 && __instance.usedAttacks > 2) || (__instance.difficulty == 2 && __instance.usedAttacks > 4 && !__instance.eid.blessed)) && !__instance.isEnraged && !__instance.eid.puppet && __instance.vc.currentVirtues.Count < 3)
			{
				((MonoBehaviour)__instance).Invoke("Enrage", 3f / __instance.eid.totalSpeedModifier);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(MortarLauncher))]
	public class MortarLauncherPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(MortarLauncher), "Start")]
		public static void StartPostfix(MortarLauncher __instance)
		{
			if (__instance.difficulty == 19)
			{
				if (((Object)__instance.mortar).name.Contains("HH"))
				{
					__instance.firingDelay = 5f;
					return;
				}
				__instance.firingDelay = 4.5f;
				CounterInt counterInt = ((Component)__instance).gameObject.AddComponent<CounterInt>();
				counterInt.maxValue = 2;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MortarLauncher), "ShootHoming")]
		public static bool ShootHomingPrefix(MortarLauncher __instance)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: 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_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.eid.target == null)
			{
				return false;
			}
			if (((Object)__instance.mortar).name.Contains("HH"))
			{
				Projectile val = Object.Instantiate<Projectile>(__instance.mortar, __instance.shootPoint.position, __instance.shootPoint.rotation);
				val.target = __instance.eid.target;
				Vector3 val2 = 0.6f * (((Component)MonoSingleton<NewMovement>.Instance).transform.position - ((Component)__instance).transform.position);
				val.predictiveHomingMultiplier = 0.5f;
				Rigidbody component = ((Component)val).GetComponent<Rigidbody>();
				component.drag = -0.5f;
				component.AddForce(((Component)__instance).transform.up * 30f + val2, (ForceMode)2);
				val.damage *= __instance.eid.totalDamageModifier;
				val.safeEnemyType = (EnemyType)35;
				val.predictiveHomingMultiplier = 0.5f;
				val.turningSpeedMultiplier = 2.64f;
				val.turnSpeed = 100f;
				((Component)val).gameObject.SetActive(true);
				if (Object.op_Implicit((Object)(object)__instance.anim))
				{
					__instance.anim.Play("Shoot", 0, 0f);
				}
				if (Util.IsHardMode())
				{
					ShockwaveOnExplode shockwaveOnExplode = ((Component)val).gameObject.AddComponent<ShockwaveOnExplode>();
					shockwaveOnExplode.enemyType = (EnemyType)35;
					shockwaveOnExplode.totalDamageModifier = __instance.eid.totalDamageModifier;
				}
			}
			else
			{
				CounterInt component2 = ((Component)__instance).GetComponent<CounterInt>();
				Vector3 val3 = ((__instance.eid.target != null) ? (__instance.eid.target.position - __instance.shootPoint.position) : __instance.shootPoint.forward);
				float magnitude = ((Vector3)(ref val3)).magnitude;
				((Vector3)(ref val3)).Normalize();
				LayerMask val4 = LayerMask.op_Implicit(LayerMask.GetMask(new string[4] { "Outdoors", "OutdoorsBaked", "Environment", "EnvironmentBaked" }));
				RaycastHit val5 = default(RaycastHit);
				if (Physics.Raycast(__instance.shootPoint.position, val3, ref val5, magnitude, LayerMask.op_Implicit(val4)))
				{
					component2.value = 1;
				}
				Vector3 val6 = Vector3.zero;
				if ((Object)(object)component2 != (Object)null && component2.value == 2)
				{
					val6 = 2f * ((Component)__instance).transform.up;
				}
				Quaternion val7 = ((__instance.eid.target != null) ? Quaternion.LookRotation(__instance.eid.target.position - __instance.shootPoint.position + val6) : __instance.shootPoint.rotation);
				if (Util.IsHardMode() && component2.value == 1)
				{
					GameObject val8 = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileHomingExplosive"], __instance.shootPoint.position, val7);
					Projectile component3 = val8.GetComponent<Projectile>();
					component3.damage *= __instance.eid.totalDamageModifier;
					component3.safeEnemyType = __instance.eid.enemyType;
					component3.enemyDamageMultiplier = 0f;
					component2.Add();
					if (Object.op_Implicit((Object)(object)__instance.anim))
					{
						__instance.anim.Play("Shoot", 0, 0f);
					}
					return false;
				}
				Projectile val9 = Object.Instantiate<Projectile>(__instance.mortar, __instance.shootPoint.position, val7);
				if ((Object)(object)component2 != (Object)null && component2.value == 1)
				{
					((Component)val9).GetComponent<Rigidbody>().velocity = __instance.shootPoint.forward * __instance.projectileForce;
				}
				val9.target = __instance.eid.target;
				if (component2 != null && component2.value == 2)
				{
					val9.homingType = (HomingType)4;
					val9.turningSpeedMultiplier = 0.2f;
					val9.speed = 5f;
					val9.ignoreEnvironment = true;
					SlowDownOverTime slowDownOverTime = ((Component)val9).gameObject.AddComponent<SlowDownOverTime>();
					slowDownOverTime.slowRate = -2.5f;
					ChangeScaleOverTime changeScaleOverTime = ((Component)val9).gameObject.AddComponent<ChangeScaleOverTime>();
					changeScaleOverTime.targetScaleMultiplier = 30f;
					changeScaleOverTime.time = 3f;
					((Component)val9).GetComponent<RemoveOnTime>().time = 1.75f;
				}
				component2.Add();
				val9.damage *= __instance.eid.totalDamageModifier;
				val9.safeEnemyType = __instance.eid.enemyType;
				((Component)val9).gameObject.SetActive(true);
				if (Object.op_Implicit((Object)(object)__instance.anim))
				{
					__instance.anim.Play("Shoot", 0, 0f);
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(DroneFlesh))]
	public class DefenseSystemDroneFleshPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(DroneFlesh), "Start")]
		public static void StartPostfix(DroneFlesh __instance)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			if (__instance.difficulty == 19 && (int)__instance.eid.enemyType == 35)
			{
				CounterInt counterInt = ((Component)((Component)__instance).transform.parent).gameObject.AddComponent<CounterInt>();
				counterInt.maxValue = 2;
				counterInt.value = 2;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(DroneFlesh), "ShootBeam")]
		public static void ShootBeamPostfix(DroneFlesh __instance)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			if (__instance.difficulty == 19 && (int)__instance.eid.enemyType == 35)
			{
				CounterInt component = ((Component)((Component)__instance).transform.parent).GetComponent<CounterInt>();
				component.Add();
			}
		}
	}
	[HarmonyPatch(typeof(Grenade))]
	public class DefenseSystemGrenadePatch
	{
		[CompilerGenerated]
		private sealed class <ShootOil>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Grenade __instance;

			private float <angleToUp>5__1;

			private bool <shiftDown>5__2;

			private int <oilIndex>5__3;

			private GameObject <oil>5__4;

			private BoolValue <bv>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<oil>5__4 = null;
				<bv>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fd: Expected O, but got Unknown
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<angleToUp>5__1 = Vector3.Angle(((Component)__instance).transform.forward, Vector3.up);
					<shiftDown>5__2 = <angleToUp>5__1 > 90f;
					<oilIndex>5__3 = 0;
					while (<oilIndex>5__3 < 25)
					{
						<oil>5__4 = Object.Instantiate<GameObject>(Plugin.Prefabs["GasolineProjectile"], ((Component)__instance).transform.position + Vector3.up * 1f, ((Component)__instance).transform.rotation);
						<oil>5__4.transform.Rotate((!<shiftDown>5__2) ? Random.Range(-50f, 50f) : (Random.Range(-50f, 50f) + 3f * (float)<oilIndex>5__3), (!<shiftDown>5__2) ? Random.Range(-50f, 50f) : (Random.Range(-50f, 50f) + 3f * (float)<oilIndex>5__3), Random.Range(-50f, 50f));
						<oil>5__4.GetComponent<Rigidbody>().AddForce(35f * <oil>5__4.transform.forward, (ForceMode)1);
						<bv>5__5 = <oil>5__4.AddComponent<BoolValue>();
						<bv>5__5.description = "toIgnite";
						<bv>5__5.value = true;
						<oil>5__4 = null;
						<bv>5__5 = null;
						<oilIndex>5__3++;
					}
					BoolValue.Set("shotOil", newValue: true, ((Component)__instance).gameObject);
					__instance.rocketSpeed = -1f;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					__instance.Explode(false, false, false, 1f, false, (GameObject)null, false);
					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();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Grenade), "Start")]
		public static void StartPostfix(Grenade __instance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			if (Util.IsDifficulty(19) && (Object)(object)__instance.originEnemy != (Object)null && (int)__instance.originEnemy.enemyType == 35)
			{
				BoolValue boolValue = ((Component)__instance).gameObject.AddComponent<BoolValue>();
				boolValue.description = "shotOil";
			}
		}

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

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Grenade), "Explode")]
		public static bool ExplodePrefix(bool big, bool harmless, bool super, float sizeMultiplier, bool ultrabooster, GameObject exploderWeapon, bool fup, Grenade __instance)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			if (!Util.IsDifficulty(19))
			{
				return true;
			}
			if (!((Object)(object)__instance.originEnemy != (Object)null) || (int)__instance.originEnemy.enemyType != 35)
			{
				return true;
			}
			CounterInt component = ((Component)__instance.originEnemy).GetComponent<CounterInt>();
			if (component.value == 1 && !Util.IsHardMode())
			{
				BoolValue.Set("shotOil", newValue: true, ((Component)__instance).gameObject);
			}
			if (BoolValue.Get("shotOil", ((Component)__instance).gameObject) == false)
			{
				((MonoBehaviour)__instance).StartCoroutine(ShootOil(__instance));
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(GasolineProjectile))]
	public class GasolineProjectilePatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(GasolineProjectile), "OnTriggerEnter")]
		public static bool OnTriggerEnterPrefix(Collider other, GasolineProjectile __instance)
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: 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_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: 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_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			if (!Util.IsDifficulty(19))
			{
				return true;
			}
			if (((Component)other).gameObject.layer == 10 || ((Component)other).gameObject.layer == 11)
			{
				if (__instance.hitSomething)
				{
					return false;
				}
				EnemyIdentifierIdentifier val = default(EnemyIdentifierIdentifier);
				if (((Component)other).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val) && Object.op_Implicit((Object)(object)val.eid) && !val.eid.dead)
				{
					__instance.hitSomething = true;
					val.eid.AddFlammable(0.1f);
					Object.Destroy((Object)(object)((Component)__instance).gameObject);
				}
				return false;
			}
			if (!LayerMaskDefaults.IsMatchingLayer(((Component)other).gameObject.layer, (LMD)1))
			{
				return false;
			}
			Vector3 position = ((Component)__instance).transform.position;
			Vector3 val2 = -__instance.rb.velocity;
			Vector3 position2 = ((Component)__instance).transform.position;
			Vector3 velocity = __instance.rb.velocity;
			Vector3 normalized = ((Vector3)(ref velocity)).normalized;
			velocity = __instance.rb.velocity;
			Vector3 val3 = position2 - normalized * Mathf.Max(2.5f, ((Vector3)(ref velocity)).magnitude * Time.fixedDeltaTime);
			velocity = __instance.rb.velocity;
			Ray val4 = default(Ray);
			((Ray)(ref val4))..ctor(val3, ((Vector3)(ref velocity)).normalized);
			RaycastHit val5 = default(RaycastHit);
			if (!other.Raycast(val4, ref val5, 10f))
			{
				return false;
			}
			if (!LayerMaskDefaults.IsMatchingLayer(((Component)((RaycastHit)(ref val5)).transform).gameObject.layer, (LMD)1))
			{
				return false;
			}
			position = ((RaycastHit)(ref val5)).point;
			val2 = ((RaycastHit)(ref val5)).normal;
			bool flag = true;
			MeshRenderer val6 = default(MeshRenderer);
			if (!MonoSingleton<PostProcessV2_Handler>.Instance.usedComputeShadersAtStart)
			{
				position += val2 * 0.2f;
				flag = false;
			}
			else if (((Component)other).TryGetComponent<MeshRenderer>(ref val6))
			{
				Material sharedMaterial = ((Renderer)val6).sharedMaterial;
				if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.IsKeywordEnabled("VERTEX_DISPLACEMENT"))
				{
					position += val2 * 0.2f;
					flag = false;
				}
			}
			GasolineStain val7 = Object.Instantiate<GasolineStain>(__instance.stain, position, ((Component)__instance).transform.rotation);
			Transform transform = ((Component)val7).transform;
			transform.forward = val2 * -1f;
			transform.Rotate(Vector3.forward * Random.Range(0f, 360f));
			val7.AttachTo(other, flag);
			if (Util.IsDifficulty(19) && BoolValue.Get("toIgnite", ((Component)__instance).gameObject).GetValueOrDefault())
			{
				MonoSingleton<StainVoxelManager>.Instance.TryIgniteAt(((Component)__instance).transform.position, 7);
			}
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	[HarmonyPatch(typeof(Ferryman))]
	public class FerrymanPatch
	{
		[CompilerGenerated]
		private sealed class <BackstepAttackExtra>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Ferryman __instance;

			private GameObject <explosion>5__1;

			private Explosion[] <>s__2;

			private int <>s__3;

			private Explosion <component>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1.35f / __instance.anim.speed);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<explosion>5__1 = Object.Instantiate<GameObject>(Plugin.Prefabs["ExplosionSisyphusPrimeCharged"], ((Component)__instance).transform.position + 2f * ((Component)__instance).transform.up, Quaternion.identity);
					((Component)<explosion>5__1.GetComponentInChildren<ExplosionController>(true)).transform.localScale = Vector3.one;
					<>s__2 = <explosion>5__1.GetComponentsInChildren<Explosion>(true);
					for (<>s__3 = 0; <>s__3 < <>s__2.Length; <>s__3++)
					{
						<component>5__4 = <>s__2[<>s__3];
						Explosion obj = <component>5__4;
						obj.speed *= 20f;
						Explosion obj2 = <component>5__4;
						obj2.maxSize *= 0.75f;
						<component>5__4.enemyDamageMultiplier = 0f;
						<component>5__4.originEnemy = __instance.eid;
						<component>5__4 = null;
					}
					<>s__2 = null;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public Ferryman __instance;

			private Transform <tr>5__1;

			private Vector3 <mainOffset>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Expected O, but got Unknown
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Expected O, but got Unknown
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Expected O, but got Unknown
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				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;
					<tr>5__1 = ((Component)__instance).transform;
					Vector3 val = <tr>5__1.forward + <tr>5__1.up;
					<mainOffset>5__2 = ((Vector3)(ref val)).normalized;
					SpawnHoming(__instance, ((Component)__instance).transform.position + 1.5f * <mainOffset>5__2);
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				}
				case 2:
					<>1__state = -1;
					SpawnHoming(__instance, ((Component)__instance).transform.position + 1.5f * (Quaternion.AngleAxis(120f, <tr>5__1.up) * <mainOffset>5__2));
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					SpawnHoming(__instance, ((Component)__instance).transform.position + 1.5f * (Quaternion.AngleAxis(-120f, <tr>5__1.up) * <mainOffset>5__2));
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public Ferryman __instance;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.95f / __instance.anim.speed);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					ShootMinosSnake(__instance);
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public Ferryman __instance;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1.125f / __instance.anim.speed);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					ShootMinosSnake(__instance);
					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();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Ferryman), "Start")]
		public static void StartPrefix(Ferryman __instance)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			__instance.difficulty = Util.GetDifficulty();
			if (__instance.difficulty == 19)
			{
				if ((Object)(object)__instance.eid == (Object)null)
				{
					__instance.eid = ((Component)__instance).GetComponent<EnemyIdentifier>();
				}
				FerrymanStuff ferrymanStuff = ((Component)__instance).gameObject.AddComponent<FerrymanStuff>();
				if (!Util.IsHardMode())
				{
					ferrymanStuff.initialSpeed = 1.1f;
					ferrymanStuff.maxSpeed = 1.3f;
				}
				else
				{
					ferrymanStuff.initialSpeed = 1.15f;
					ferrymanStuff.maxSpeed = 1.35f;
				}
				ferrymanStuff.changeColor = true;
				ferrymanStuff.targetFerrymanColor = new Color(0.4f, 0.4f, 1f);
				ferrymanStuff.targetCloakColor = new Color(0.55f, 0.55f, 1f);
				ferrymanStuff.eid = __instance.eid;
				OriginalHealth originalHealth = ((Component)__instance).gameObject.AddComponent<OriginalHealth>();
				originalHealth.health = __instance.mach.health;
				BoolValue boolValue = ((Component)__instance).gameObject.AddComponent<BoolValue>();
				boolValue.description = "enraged";
				boolValue.value = false;
				if (Util.IsHardMode())
				{
					((Component)__instance).gameObject.AddComponent<FerrymanCirclingProjectiles>();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Ferryman), "Update")]
		public static void UpdatePrefix(Ferryman __instance)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return;
			}
			__instance.SetSpeed();
			if (Util.IsHardMode())
			{
				OriginalHealth component = ((Component)__instance).GetComponent<OriginalHealth>();
				if (!(__instance.eid.health > 0.5f * component.health) && !BoolValue.Get("enraged", ((Component)__instance).gameObject).GetValueOrDefault())
				{
					BoolValue.Set("enraged", newValue: true, ((Component)__instance).gameObject);
					FerrymanCirclingProjectiles component2 = ((Component)__instance).GetComponent<FerrymanCirclingProjectiles>();
					component2.active = true;
					EnemySimplifier componentInChildren = ((Component)__instance).GetComponentInChildren<EnemySimplifier>();
					GameObject val = Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.enrageEffect, ((Component)componentInChildren).transform.parent);
					val.transform.localScale = 0.4f * Vector3.one;
					val.transform.localPosition = new Vector3(0f, 0.75f, 0f);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Ferryman), "SetSpeed")]
		public static void SetSpeedPostfix(Ferryman __instance)
		{
			if (__instance.eid.dead || __instance.difficulty != 19)
			{
				return;
			}
			OriginalHealth component = ((Component)__instance).GetComponent<OriginalHealth>();
			FerrymanStuff component2 = ((Component)__instance).GetComponent<FerrymanStuff>();
			float num = ((!Util.IsHardMode()) ? 1f : 1.15f);
			component2.speedChangeMultiplier = num * 0.4f / (component.health * __instance.eid.totalHealthModifier);
			__instance.defaultMovementSpeed = 32f * component2.currentValue;
			__instance.anim.speed = component2.currentValue * __instance.eid.totalSpeedModifier;
			__instance.nma.speed = __instance.defaultMovementSpeed * __instance.eid.totalSpeedModifier;
			if (component2.reached && !component2.addedStyle)
			{
				MonoSingleton<StyleHUD>.Instance.AddPoints(25, "billion.blue", (GameObject)null, __instance.eid, -1, "", "");
				component2.addedStyle = true;
				if (Util.IsHardMode())
				{
					FerrymanCirclingProjectiles component3 = ((Component)__instance).GetComponent<FerrymanCirclingProjectiles>();
					component3.active = true;
					component3.doubled = true;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Ferryman), "SlamHit")]
		public static void SlamHitPostfix(Ferryman __instance)
		{
			if (Util.IsHardMode())
			{
				((MonoBehaviour)__instance).StartCoroutine(SlamHitExtra(__instance));
			}
		}

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

		public static GameObject SpawnHoming(Ferryman __instance, Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = position - ((Component)__instance).transform.position;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			Quaternion val2 = Quaternion.LookRotation(normalized);
			GameObject val3 = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileHoming"], position, val2);
			Projectile component = val3.GetComponent<Projectile>();
			component.safeEnemyType = (EnemyType)26;
			component.speed = 30f;
			component.ignoreExplosions = true;
			component.target = __instance.eid.target;
			return val3;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Ferryman), "BackstepAttack")]
		public static void BackstepAttackPostfix(Ferryman __instance)
		{
			if (Util.IsHardMode())
			{
				((MonoBehaviour)__instance).StartCoroutine(BackstepAttackExtra(__instance));
			}
		}

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

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Ferryman), "VaultSwing")]
		public static void VaultSwingPostfix(Ferryman __instance)
		{
			if (Util.IsHardMode())
			{
				((MonoBehaviour)__instance).StartCoroutine(VaultSwingExtra(__instance));
			}
		}

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

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Ferryman), "Stinger")]
		public static void StingerPostfix(Ferryman __instance)
		{
			if (Util.IsHardMode())
			{
				((MonoBehaviour)__instance).StartCoroutine(StingerExtra(__instance));
			}
		}

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

		public static void ShootMinosSnake(Ferryman __instance)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileMinosPrimeSnake"], ((Component)__instance).transform.position + 3.5f * ((Component)__instance).transform.up, Quaternion.LookRotation(((Component)__instance).transform.up));
			Projectile componentInChildren = val.GetComponentInChildren<Projectile>();
			componentInChildren.speed = 75f;
			componentInChildren.turningSpeedMultiplier *= 2.5f;
			componentInChildren.ignoreEnvironment = true;
			componentInChildren.ignoreExplosions = true;
			componentInChildren.stopTrackingAfterSeconds = 1f;
		}
	}
	[HarmonyPatch(typeof(Gutterman))]
	public class GuttermanPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Gutterman), "Start")]
		public static void StartPostfix(Gutterman __instance)
		{
			if (__instance.difficulty == 19)
			{
				BoolValue boolValue = ((Component)__instance).gameObject.AddComponent<BoolValue>();
				boolValue.description = "targetInZone";
				MoveBacker moveBacker = ((Component)__instance).gameObject.AddComponent<MoveBacker>();
				if (Util.IsHardMode())
				{
					TimerFloat timerFloat = ((Component)__instance).gameObject.AddComponent<TimerFloat>();
					timerFloat.cooldownMax = 1.6f;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Gutterman), "SetSpeed")]
		public static void SetSpeedPostfix(Gutterman __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1f : 1.15f);
				float num2 = num * __instance.eid.totalSpeedModifier;
				__instance.anim.speed = 1.2f * num2;
				__instance.defaultMovementSpeed = 12f * num2;
				__instance.windupSpeed = 1.35f * num2;
				__instance.nma.speed = (__instance.slowMode ? (__instance.defaultMovementSpeed / 1.5f) : __instance.defaultMovementSpeed);
				if (Util.IsHardMode())
				{
					__instance.nma.angularSpeed = 200f;
				}
				__instance.trackingSpeedMultiplier = ((!Util.IsHardMode()) ? 1.2f : 1.45f);
				if (__instance.trackingSpeed < __instance.defaultTrackingSpeed)
				{
					__instance.trackingSpeed = __instance.defaultTrackingSpeed;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Gutterman), "GetSpeed")]
		public static bool GetSpeedPrefix(int difficulty, ref EnemyMovementData __result)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (difficulty != 19)
			{
				return true;
			}
			float num = ((!Util.IsHardMode()) ? 1f : 1.15f);
			__result = new EnemyMovementData
			{
				speed = 12f * num,
				angularSpeed = ((!Util.IsHardMode()) ? 120f : 200f),
				acceleration = 8f
			};
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Gutterman), "FixedUpdate")]
		public static bool UpdatePrefix(Gutterman __instance)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19 || __instance.eid.dead || __instance.eid.target == null)
			{
				return true;
			}
			MoveBacker moveBacker = ((Component)__instance).GetComponent<MoveBacker>();
			if ((Object)(object)moveBacker == (Object)null)
			{
				moveBacker = ((Component)__instance).gameObject.AddComponent<MoveBacker>();
			}
			TimerFloat timerFloat = null;
			if (Util.IsHardMode())
			{
				timerFloat = ((Component)__instance).GetComponent<TimerFloat>();
			}
			float num = Vector3.Distance(((Component)__instance).transform.position, __instance.eid.target.position);
			bool flag = BoolValue.Get("targetInZone", ((Component)__instance).gameObject) == false || (timerFloat?.reached ?? false);
			if (num <= 10f && flag)
			{
				if (Util.IsHardMode())
				{
					GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["ExplosionSisyphusPrimeCharged"], ((Component)__instance).transform.position + 2f * ((Component)__instance).transform.up, Quaternion.identity);
					((Component)val.GetComponentInChildren<ExplosionController>(true)).transform.localScale = Vector3.one;
					Explosion[] componentsInChildren = val.GetComponentsInChildren<Explosion>(true);
					foreach (Explosion val2 in componentsInChildren)
					{
						val2.speed *= 25f;
						val2.maxSize *= 0.5f;
						val2.enemyDamageMultiplier = 0f;
						val2.originEnemy = __instance.eid;
					}
				}
				((MonoBehaviour)__instance).StartCoroutine(moveBacker.MoveBack());
				BoolValue.Set("targetInZone", newValue: true, ((Component)__instance).gameObject);
				timerFloat?.ResetAndRun();
			}
			else if (num >= 20f)
			{
				BoolValue.Set("targetInZone", newValue: false, ((Component)__instance).gameObject);
			}
			if (moveBacker.moving)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Guttertank))]
	public class GuttertankPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Guttertank), "Start")]
		public static void StartPostfix(Guttertank __instance)
		{
			if (Util.IsHardMode())
			{
				TimerFloat timerFloat = ((Component)__instance).gameObject.AddComponent<TimerFloat>();
				timerFloat.cooldownMax = 3f;
				timerFloat.cooldown = 3f;
				timerFloat.Run();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Guttertank), "SetSpeed")]
		public static void SetSpeedPostfix(Guttertank __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1f : 1.1f);
				__instance.anim.speed = 1.2f * num * __instance.eid.totalSpeedModifier;
				__instance.nma.speed = 20f * __instance.anim.speed;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Guttertank), "GetSpeed")]
		public static bool GetSpeedPrefix(int difficulty, ref EnemyMovementData __result)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (difficulty != 19)
			{
				return true;
			}
			float num = ((!Util.IsHardMode()) ? 1f : 1.1f);
			__result = new EnemyMovementData
			{
				speed = 24f * num,
				angularSpeed = 1200f,
				acceleration = 80f
			};
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Guttertank), "PlaceMine")]
		public static void PlaceMinePrefix(Guttertank __instance)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!Util.IsHardMode())
			{
				return;
			}
			TimerFloat component = ((Component)__instance).GetComponent<TimerFloat>();
			if (component.reached)
			{
				component.ResetAndRun();
				GroundWave component2 = Object.Instantiate<GameObject>(Plugin.Prefabs["MirrorReaperGroundWave"], ((Component)__instance).transform.position, ((Component)__instance).transform.rotation).GetComponent<GroundWave>();
				component2.target = __instance.eid.target;
				((Component)component2).transform.SetParent(Object.op_Implicit((Object)(object)((Component)__instance).transform.parent) ? ((Component)__instance).transform.parent : ((Component)GoreZone.ResolveGoreZone(((Component)__instance).transform)).transform);
				component2.lifetime = 15f;
				Breakable componentInChildren = ((Component)component2).GetComponentInChildren<Breakable>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					componentInChildren.durability = 5f;
				}
				component2.eid = __instance.eid;
				component2.difficulty = __instance.difficulty;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Guttertank), "CheckMines")]
		public static void CheckMinesPostfix(Guttertank __instance, ref bool __result)
		{
			if (Util.IsHardMode() && Random.Range(1, 101) > 22)
			{
				__result = true;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Guttertank), "PrepMine")]
		public static void PrepMinePostfix(Guttertank __instance)
		{
			if (Util.IsHardMode())
			{
				__instance.mineCooldown = 1.25f;
			}
		}
	}
	[HarmonyPatch(typeof(Grenade), "Explode")]
	public class GuttertankGrenadePatch
	{
		public static void Prefix(bool big, bool harmless, bool super, float sizeMultiplier, bool ultrabooster, GameObject exploderWeapon, bool fup, Grenade __instance)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_007d: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: 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_0132: Unknown result type (might be due to invalid IL or missing references)
			if (harmless || !((Object)(object)__instance.originEnemy != (Object)null) || __instance.originEnemy.difficulty != 19 || (int)__instance.originEnemy.enemyType != 34)
			{
				return;
			}
			for (int i = 0; i < 12; i++)
			{
				EnemyIdentifier originEnemy = __instance.originEnemy;
				Vector3 val = ((originEnemy.target == null) ? ((Component)MonoSingleton<NewMovement>.Instance).transform.position : originEnemy.target.position);
				Vector3 val2 = val - ((Component)__instance).transform.position;
				((Vector3)(ref val2)).Normalize();
				Projectile component = Object.Instantiate<GameObject>(Plugin.Prefabs["Projectile"], ((Component)__instance).transform.position, Quaternion.LookRotation(val2)).GetComponent<Projectile>();
				if (i != 0)
				{
					((Component)component).transform.Rotate(new Vector3(3f * (float)Mathf.RoundToInt(Random.Range(-12f, 12f)), 3f * (float)Mathf.RoundToInt(Random.Range(-12f, 12f)), 3f * (float)Mathf.RoundToInt(Random.Range(-12f, 12f))), (Space)1);
				}
				Transform transform = ((Component)component).transform;
				transform.position += 6f * ((Component)component).transform.forward;
				Transform transform2 = ((Component)component).transform;
				transform2.localScale *= 3f;
				component.speed = 80f;
				component.safeEnemyType = (EnemyType)34;
				component.ignoreEnvironment = true;
				component.target = originEnemy.target;
				component.friendly = false;
				component.damage = 30f;
				component.enemyDamageMultiplier = 0f;
				((Component)component).GetComponent<RemoveOnTime>().time = 2f;
			}
		}
	}
	[HarmonyPatch(typeof(EnemyIdentifier))]
	public class BlessPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(EnemyIdentifier), "Bless")]
		public static void BlessPostfix(EnemyIdentifier __instance)
		{
			if (__instance.difficulty == 19 && !((Object)(object)((Component)__instance).GetComponent<FerrymanFake>() != (Object)null))
			{
				IdolHealingSetup idolHealingSetup = ((Component)__instance).gameObject.AddComponent<IdolHealingSetup>();
				idolHealingSetup.cooldownMax = 2f;
				if (Util.IsHardMode())
				{
					idolHealingSetup.cooldownMax = 1.5f;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(EnemyIdentifier), "Unbless")]
		public static void UnblessPostfix(EnemyIdentifier __instance)
		{
			if (__instance.difficulty == 19)
			{
				Object.Destroy((Object)(object)((Component)__instance).GetComponent<IdolHealingSetup>());
			}
		}
	}
	[HarmonyPatch(typeof(Explosion), "Start")]
	public class ExplosionIdolPatch
	{
		public static void Postfix(Explosion __instance)
		{
			if (!Util.IsDifficulty(19) || ((Object)((Component)__instance).transform.parent).name != "Idol Healing Explosion")
			{
				return;
			}
			EnemyIdentifierSaver component = ((Component)__instance).GetComponent<EnemyIdentifierSaver>();
			IdolHealingExplosion idolHealingExplosion = ((Component)__instance).gameObject.AddComponent<IdolHealingExplosion>();
			idolHealingExplosion.healing = 0.8f;
			if (Util.IsHardMode())
			{
				idolHealingExplosion.healing = 1.2f;
				idolHealingExplosion.healingReducedHardMode = 0.9f;
			}
			EnemyIdentifier[] array = Object.FindObjectsByType<EnemyIdentifier>((FindObjectsSortMode)0);
			EnemyIdentifier[] array2 = array;
			foreach (EnemyIdentifier val in array2)
			{
				if ((Object)(object)val.idol?.target == (Object)(object)component?.eid && (Object)(object)component?.eid != (Object)null)
				{
					IdolHealingSetup component2 = ((Component)component.eid).GetComponent<IdolHealingSetup>();
					component2.cooldownMax = component2.cooldownMaxOriginal / val.totalHealthModifier;
					break;
				}
			}
		}
	}
	[HarmonyPatch(typeof(MaliciousFace))]
	public class MaliciousFacePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(MaliciousFace), "Start")]
		public static void StartPostfix(MaliciousFace __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1f : 1.2f);
				__instance.coolDownMultiplier = 1.4f * num;
				__instance.maxBurst = 13;
				if (Util.IsHardMode())
				{
					__instance.maxBurst = 18;
					Plugin.SetEnemyWeakness("hammer", 0.6f, __instance.eid);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MaliciousFace), "OnParry")]
		public static bool OnParryPrefix(ref DamageData data, bool isShotgun, MaliciousFace __instance)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: 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_01ca: 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)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (!__instance.spiderParryable)
			{
				return false;
			}
			__instance.spiderParryable = false;
			MonoSingleton<FistControl>.Instance.currentPunch.Parry(false, __instance.eid, "");
			__instance.currentExplosion = Object.Instantiate<GameObject>(AddressablesExtensions.ToAsset(__instance.beamExplosion), ((Component)__instance).transform.position, Quaternion.identity);
			if (!InvincibleEnemies.Enabled && !__instance.eid.blessed)
			{
				Enemy spider = __instance.spider;
				spider.health -= (float)((__instance.spider.parryFramesLeft > 0) ? 4 : 5) / __instance.eid.totalHealthModifier;
			}
			Explosion[] componentsInChildren = __instance.currentExplosion.GetComponentsInChildren<Explosion>();
			foreach (Explosion val in componentsInChildren)
			{
				if (__instance.difficulty != 19)
				{
					val.speed *= __instance.eid.totalDamageModifier;
					val.maxSize *= 1.75f * __instance.eid.totalDamageModifier;
					val.damage = Mathf.RoundToInt(50f * __instance.eid.totalDamageModifier);
					val.canHit = (AffectedSubjects)2;
					val.friendlyFire = true;
					continue;
				}
				val.speed *= 1.25f;
				val.maxSize *= 0.8f;
				Transform transform = __instance.currentExplosion.transform;
				transform.localScale *= 0.8f;
				val.damage = Mathf.RoundToInt(25f * __instance.eid.totalDamageModifier);
				val.canHit = (AffectedSubjects)1;
				val.friendlyFire = false;
				Enemy spider2 = __instance.spider;
				spider2.health += 1.5f / __instance.eid.totalHealthModifier;
				EnemyIdentifier eid = __instance.eid;
				eid.health += 1.5f / __instance.eid.totalHealthModifier;
			}
			if ((Object)(object)__instance.currentEnrageEffect == (Object)null)
			{
				((MonoBehaviour)__instance).CancelInvoke("BeamFire");
				((MonoBehaviour)__instance).Invoke("StopWaiting", 1f);
				Object.Destroy((Object)(object)__instance.currentCE);
			}
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MaliciousFace), "AttackCheck")]
		public static void AttackCheckPostfix(TargetData targetData, MaliciousFace __instance)
		{
			if (Util.IsDifficulty(19))
			{
				__instance.beamsAmount = 2;
				if (__instance.isEnraged)
				{
					__instance.beamsAmount = 3;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MaliciousFace), "HandleCollision")]
		public static bool HandleCollisionPrefix(Collision other, MaliciousFace __instance)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			if (!Util.IsHardMode())
			{
				return true;
			}
			if (other.gameObject.CompareTag("Moving"))
			{
				__instance.BreakCorpse();
				MonoSingleton<CameraController>.Instance.CameraShake(2f);
				return false;
			}
			if (LayerMaskDefaults.IsMatchingLayer(other.gameObject.layer, (LMD)1))
			{
				Breakable val5 = default(Breakable);
				if (other.gameObject.CompareTag("Floor"))
				{
					__instance.rb.isKinematic = true;
					PhysicsExtensions.SetGravityMode(__instance.rb, false);
					Transform transform = ((Component)__instance).transform;
					Object.Instantiate<GameObject>(__instance.impactParticle, transform.position, transform.rotation);
					((Quaternion)(ref __instance.spriteRot)).eulerAngles = new Vector3(((ContactPoint)(ref other.contacts[0])).normal.x + 90f, ((ContactPoint)(ref other.contacts[0])).normal.y, ((ContactPoint)(ref other.contacts[0])).normal.z);
					__instance.spritePos = new Vector3(((ContactPoint)(ref other.contacts[0])).point.x, ((ContactPoint)(ref other.contacts[0])).point.y + 0.1f, ((ContactPoint)(ref other.contacts[0])).point.z);
					GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["PhysicalShockwave"], ((Component)__instance).transform.position - 2f * ((Component)__instance).transform.up, Quaternion.identity);
					PhysicalShockwave component = val.GetComponent<PhysicalShockwave>();
					component.speed = 50f;
					component.damage = Mathf.RoundToInt(25f * __instance.eid.totalDamageModifier);
					component.maxSize = 75f;
					component.enemy = true;
					component.enemyType = (EnemyType)4;
					Transform transform2 = ((Component)__instance).transform;
					transform2.position -= transform2.up * 1.5f;
					__instance.spiderFalling = false;
					__instance.rb.excludeLayers = default(LayerMask);
					MaliciousFaceCatcher val2 = default(MaliciousFaceCatcher);
					if (!other.gameObject.TryGetComponent<MaliciousFaceCatcher>(ref val2))
					{
						Object.Instantiate<GameObject>(__instance.impactSprite, __instance.spritePos, __instance.spriteRot).transform.SetParent(__instance.gz.goreZone, true);
					}
					SphereCollider val3 = default(SphereCollider);
					if (((Component)__instance).TryGetComponent<SphereCollider>(ref val3))
					{
						Object.Destroy((Object)(object)val3);
					}
					SpiderBodyTrigger componentInChildren = ((Component)((Component)__instance).transform.parent).GetComponentInChildren<SpiderBodyTrigger>(true);
					if (Object.op_Implicit((Object)(object)componentInChildren))
					{
						Object.Destroy((Object)(object)((Component)componentInChildren).gameObject);
					}
					((Behaviour)((Component)__instance.rb).GetComponent<NavMeshObstacle>()).enabled = true;
					MonoSingleton<CameraController>.Instance.CameraShake(2f);
					if (__instance.fallEnemiesHit.Count > 0)
					{
						Collider val4 = default(Collider);
						foreach (EnemyIdentifier item in __instance.fallEnemiesHit)
						{
							if ((Object)(object)item != (Object)null && !item.dead && ((Component)item).TryGetComponent<Collider>(ref val4))
							{
								Physics.IgnoreCollision(__instance.headCollider, val4, false);
							}
						}
						__instance.fallEnemiesHit.Clear();
						return false;
					}
				}
				else if (other.gameObject.TryGetComponent<Breakable>(ref val5) && !val5.playerOnly && !val5.specialCaseOnly)
				{
					val5.Break();
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MaliciousFace), "ShootProj")]
		public static bool ShootProjPrefix(ref TargetData targetData, MaliciousFace __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			Vector3 val = targetData.headPosition;
			Vector3 val2 = __instance.mouth.position;
			Vector3 val3 = val2 - ((Component)__instance).transform.position;
			PhysicsCastResult val4 = default(PhysicsCastResult);
			Vector3 val5 = default(Vector3);
			PortalTraversalV2[] array = default(PortalTraversalV2[]);
			PortalPhysicsV2.ProjectThroughPortals(((Component)__instance).transform.position, val3, LayerMask.op_Implicit(default(LayerMask)), ref val4, ref val5, ref array);
			bool flag = false;
			if (array.Length != 0)
			{
				PortalTraversalV2 val6 = array[0];
				PortalHandle portalHandle = val6.portalHandle;
				Portal portalObject = val6.portalObject;
				if (((Enum)portalObject.GetTravelFlags(portalHandle.side)).HasFlag((Enum)(object)(PortalTravellerFlags)16))
				{
					val2 = val5;
					Matrix4x4 travelMatrix = PortalUtils.GetTravelMatrix(array);
					val = ((Matrix4x4)(ref travelMatrix)).MultiplyPoint3x4(val);
				}
				else
				{
					flag = !portalObject.passThroughNonTraversals;
				}
			}
			__instance.currentProj = Object.Instantiate<GameObject>(__instance.proj, val2, Quaternion.LookRotation(val - val2));
			Projectile component = __instance.currentProj.GetComponent<Projectile>();
			if (__instance.difficulty == 19)
			{
				((Component)component).GetComponent<RemoveOnTime>().time = 3f;
				component.enemyDamageMultiplier = 0.175f;
				component.damage = 20f;
				if (Util.IsHardMode())
				{
					component.enemyDamageMultiplier = 0f;
				}
			}
			float num = 1 + __instance.currentBurst / 5 * 2;
			if (__instance.difficulty == 19)
			{
				switch (__instance.currentBurst % 9)
				{
				case 0:
					__instance.currentProj.transform.LookAt(val);
					__instance.currentProj.transform.localScale = new Vector3(1.5f, 1.5f, 1.5f);
					component.damage = 40f;
					break;
				case 1:
					__instance.currentProj.transform.LookAt(val + ((Component)__instance).transform.right * num);
					break;
				case 2:
					__instance.currentProj.transform.LookAt(val + ((Component)__instance).transform.right * num + ((Component)__instance).transform.up * num);
					break;
				case 3:
					__instance.currentProj.transform.LookAt(val + ((Component)__instance).transform.up * num);
					break;
				case 4:
					__instance.currentProj.transform.LookAt(val + ((Component)__instance).transform.up * num - ((Component)__instance).transform.right * num);
					break;
				case 5:
					__instance.currentProj.transform.LookAt(val - ((Component)__instance).transform.right * num);
					break;
				case 6:
					__instance.currentProj.transform.LookAt(val - ((Component)__instance).transform.right * num - ((Component)__instance).transform.up * num);
					break;
				case 7:
					__instance.currentProj.transform.LookAt(val - ((Component)__instance).transform.up * num);
					break;
				case 8:
					__instance.currentProj.transform.LookAt(val - ((Component)__instance).transform.up * num + ((Component)__instance).transform.right * num);
					break;
				}
			}
			else if (__instance.difficulty >= 4)
			{
				switch (__instance.currentBurst % 5)
				{
				case 1:
					__instance.currentProj.transform.LookAt(val + ((Component)__instance).transform.right * num);
					break;
				case 2:
					__instance.currentProj.transform.LookAt(val + ((Component)__instance).transform.up * num);
					break;
				case 3:
					__instance.currentProj.transform.LookAt(val - ((Component)__instance).transform.right * num);
					break;
				case 4:
					__instance.currentProj.transform.LookAt(val - ((Component)__instance).transform.up * num);
					break;
				}
			}
			if (!flag)
			{
				component.safeEnemyType = (EnemyType)4;
				component.targetHandle = targetData.handle;
				if (__instance.difficulty == 19)
				{
					component.speed *= 1.5f;
				}
				else if (__instance.difficulty > 2)
				{
					component.speed *= 1.25f;
				}
				else if (__instance.difficulty == 1)
				{
					component.speed *= 0.75f;
				}
				else if (__instance.difficulty == 0)
				{
					component.speed *= 0.5f;
				}
				component.damage *= __instance.eid.totalDamageModifier;
			}
			else
			{
				component.Explode();
			}
			__instance.currentBurst++;
			__instance.readyToShoot = false;
			float num2 = (Util.IsHardMode() ? 0.02f : ((__instance.difficulty == 19) ? 0.025f : ((__instance.difficulty >= 4) ? 0.05f : ((__instance.difficulty <= 0) ? 0.2f : 0.1f))));
			((MonoBehaviour)__instance).Invoke("ReadyToShoot", num2 / __instance.eid.totalSpeedModifier);
			return false;
		}
	}
	[HarmonyPatch(typeof(Mannequin))]
	public class MannequinPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mannequin), "Start")]
		public static void StartPostfix(Mannequin __instance)
		{
			if (__instance.difficulty == 19)
			{
				CounterInt counterInt = ((Component)__instance).gameObject.AddComponent<CounterInt>();
				counterInt.maxValue = 2;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mannequin), "SetSpeed")]
		public static void SetSpeedPostfix(Mannequin __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1f : 1.15f);
				__instance.anim.speed = 1.5f * num * __instance.eid.totalSpeedModifier;
				__instance.walkSpeed = 25f * num * __instance.eid.totalSpeedModifier;
				__instance.skitterSpeed = 90f * num * __instance.eid.totalSpeedModifier;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mannequin), "ProjectileAttack")]
		public static void ProjectileAttackPostfix(Mannequin __instance)
		{
			if (__instance.difficulty == 19)
			{
				if (!Util.IsHardMode())
				{
					__instance.projectileCooldown = Random.Range(1f, 3f) / __instance.eid.totalSpeedModifier;
				}
				else
				{
					__instance.projectileCooldown = Random.Range(0.75f, 2f) / __instance.eid.totalSpeedModifier;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Mannequin), "ShootProjectile")]
		public static bool ShootProjectilePrefix(Mannequin __instance)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: 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_01e0: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)__instance.currentChargeProjectile))
			{
				Object.Destroy((Object)(object)__instance.currentChargeProjectile);
			}
			if ((Object)(object)__instance.projectile == (Object)null || ((object)__instance.projectile).Equals((object?)null))
			{
				__instance.trackTarget = false;
				__instance.chargingProjectile = false;
				return false;
			}
			CounterInt component = ((Component)__instance).GetComponent<CounterInt>();
			Vector3 zero = Vector3.zero;
			if (component != null && component.value == 2)
			{
				((Vector3)(ref zero))..ctor(0f, 2f, 0f);
			}
			Quaternion val = ((__instance.eid.target != null) ? Quaternion.LookRotation(__instance.shootTarget.position - __instance.shootPoint.position + zero) : __instance.shootPoint.rotation);
			if (Util.IsHardMode() && component.value == 1)
			{
				GameObject val2 = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileHomingExplosive"], __instance.shootPoint.position, val);
				Projectile component2 = val2.GetComponent<Projectile>();
				component2.damage *= __instance.eid.totalDamageModifier;
				component2.safeEnemyType = (EnemyType)31;
				component2.enemyDamageMultiplier = 0f;
				component.Add();
				return false;
			}
			Projectile val3 = Object.Instantiate<Projectile>(__instance.projectile, __instance.shootPoint.position, val);
			val3.target = __instance.eid.target;
			val3.safeEnemyType = (EnemyType)31;
			if (__instance.difficulty <= 2)
			{
				val3.turningSpeedMultiplier = 0.75f;
			}
			__instance.trackTarget = false;
			__instance.chargingProjectile = false;
			if (component.value == 2)
			{
				val3.homingType = (HomingType)4;
				val3.turningSpeedMultiplier = 0.2f;
				val3.speed = 5f;
				val3.ignoreEnvironment = true;
				SlowDownOverTime slowDownOverTime = ((Component)val3).gameObject.AddComponent<SlowDownOverTime>();
				slowDownOverTime.slowRate = -2.5f;
				ChangeScaleOverTime changeScaleOverTime = ((Component)val3).gameObject.AddComponent<ChangeScaleOverTime>();
				changeScaleOverTime.targetScaleMultiplier = 30f;
				changeScaleOverTime.time = 3f;
				((Component)val3).GetComponent<RemoveOnTime>().time = 1.75f;
			}
			component.Add();
			return false;
		}
	}
	[HarmonyPatch(typeof(MassSpear))]
	public class MassSpearPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(MassSpear), "GetHurt")]
		public static bool GetHurtPrefix(float damage, MassSpear __instance)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			Object.Instantiate<GameObject>(__instance.breakMetalSmall, ((Component)__instance).transform.position, Quaternion.identity);
			__instance.spearHealth -= ((__instance.difficulty >= 4 && __instance.difficulty != 19) ? (damage / 1.5f) : damage);
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MassSpear), "Start")]
		public static bool StartPrefix(MassSpear __instance)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			__instance.lr = ((Component)__instance).GetComponentInChildren<LineRenderer>();
			__instance.rb = ((Component)__instance).GetComponent<Rigidbody>();
			__instance.aud = ((Component)__instance).GetComponent<AudioSource>();
			__instance.mass = ((Component)__instance.originPoint).GetComponentInParent<Mass>();
			((MonoBehaviour)__instance).Invoke("CheckForDistance", 3f / __instance.speedMultiplier);
			float num = 75f;
			switch (__instance.difficulty)
			{
			case 1:
				num = 75f;
				break;
			case 2:
				num = 200f;
				break;
			case 3:
			case 4:
			case 5:
			case 19:
				num = 250f;
				break;
			}
			__instance.rb.AddForce(num * __instance.speedMultiplier * ((Component)__instance).transform.forward, (ForceMode)2);
			__instance.lastPosition = ((Component)__instance.lr).transform.position;
			__instance.distanceTravelled = 0f;
			return false;
		}
	}
	[HarmonyPatch(typeof(Mass))]
	public class MassPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mass), "Start")]
		public static void StartPostfix(Mass __instance)
		{
			if (__instance.difficulty == 19)
			{
				__instance.explosiveProjectileLaunchVelocity = 25f;
				if (Util.IsHardMode())
				{
					CounterInt counterInt = ((Component)__instance).gameObject.AddComponent<CounterInt>();
					counterInt.maxValue = 3;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mass), "SetSpeed")]
		public static void SetSpeedPostfix(Mass __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1.5f : 2f);
				__instance.anim.speed = num * __instance.eid.totalSpeedModifier;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mass), "SlamImpact")]
		public static void SlamImpactPostfix(Mass __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (Util.IsHardMode())
			{
				Vector3 val = 14f * ((Component)__instance).transform.forward + 8f * ((Component)__instance).transform.up;
				Plugin.CreateVirtueInsignia(0.5f, 0.75f, 4.5f, ((Component)__instance).transform.position + val, ((Component)__instance).transform.position + val + ((Component)__instance).transform.forward, __instance.eid.target, __instance.stat, __instance.eid.totalDamageModifier, 0.5f);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mass), "SwingEnd")]
		public static void SwingEndPostfix(Mass __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (Util.IsHardMode())
			{
				Vector3 val = 14f * ((Component)__instance).transform.forward + 8f * ((Component)__instance).transform.up;
				Plugin.CreateVirtueInsignia(0.5f, 0.75f, 4.5f, ((Component)__instance).transform.position + val, ((Component)__instance).transform.position + val + ((Component)__instance).transform.right, __instance.eid.target, __instance.stat, __instance.eid.totalDamageModifier, 0.5f);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Mass), "ShootProjectile")]
		public static bool ShootProjectilePrefix(int arm, GameObject projectile, ref float velocity, Mass __instance)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.dead || __instance.eid.target == null)
			{
				return false;
			}
			Transform val = __instance.shootPoints[arm];
			GameObject val2 = Object.Instantiate<GameObject>(projectile, val.position, val.rotation);
			Rigidbody val3 = default(Rigidbody);
			if (val2.TryGetComponent<Rigidbody>(ref val3))
			{
				Vector3 val5;
				if (__instance.difficulty == 19)
				{
					Vector3 val4 = __instance.targetPos - ((Component)__instance).transform.position;
					val5 = 1.5f * ((Vector3)(ref val4)).normalized;
				}
				else
				{
					val5 = Vector3.zero;
				}
				Vector3 val6 = val5;
				val3.AddForce(val.up * velocity + val6, (ForceMode)2);
			}
			Projectile val7 = default(Projectile);
			if (val2.TryGetComponent<Projectile>(ref val7))
			{
				val7.target = __instance.eid.target;
				val7.safeEnemyType = (EnemyType)2;
				((Component)val7).transform.SetParent(((Component)__instance.stat.GetGoreZone()).transform, true);
				Projectile obj = val7;
				obj.damage *= __instance.eid.totalDamageModifier;
				if (__instance.difficulty == 19)
				{
					val7.predictiveHomingMultiplier = 0.5f;
					val7.turningSpeedMultiplier = 2.64f;
					val7.turnSpeed = 100f;
					Rigidbody component = ((Component)val7).GetComponent<Rigidbody>();
					component.drag = -1f;
				}
				if (Util.IsHardMode())
				{
					CounterInt component2 = ((Component)__instance).GetComponent<CounterInt>();
					if (__instance.crazyMode && component2.value != 1)
					{
						component2.Add();
						return false;
					}
					if (__instance.crazyMode)
					{
						component2.Add();
					}
					ShockwaveOnExplode shockwaveOnExplode = val2.AddComponent<ShockwaveOnExplode>();
					shockwaveOnExplode.enemyType = (EnemyType)2;
					shockwaveOnExplode.totalDamageModifier = __instance.eid.totalDamageModifier;
					shockwaveOnExplode.speed = 70f;
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Mass), "SlamImpact")]
		public static bool SlamImpactPrefix(Mass __instance)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.dead)
			{
				return false;
			}
			if (__instance.difficulty != 19)
			{
				return true;
			}
			int num = 2;
			AudioSource val2 = default(AudioSource);
			for (int i = 0; i < num; i++)
			{
				GameObject val = Object.Instantiate<GameObject>(__instance.slamExplosion, new Vector3(__instance.shootPoints[2].position.x, ((Component)__instance).transform.position.y, __instance.shootPoints[2].position.z), Quaternion.identity);
				PhysicalShockwave component = val.GetComponent<PhysicalShockwave>();
				float num2 = 1.5f;
				switch (__instance.difficulty)
				{
				case 0:
					component.speed = 15f;
					num2 = 1.5f;
					break;
				case 1:
					component.speed = 20f;
					num2 = 2f;
					break;
				case 2:
				case 3:
					component.speed = 25f;
					num2 = 2.5f;
					break;
				case 4:
				case 5:
					component.speed = 35f;
					num2 = 2.5f;
					break;
				case 19:
					component.speed = 50f;
					num2 = 2.5f;
					break;
				}
				val.transform.localScale = new Vector3(val.transform.localScale.x, val.transform.localScale.y * num2, val.transform.localScale.z);
				component.damage = Mathf.RoundToInt(30f * __instance.eid.totalDamageModifier);
				component.maxSize = 100f;
				component.enemy = true;
				component.enemyType = (EnemyType)2;
				val.transform.SetParent(((Component)__instance.stat.GetGoreZone()).transform, true);
				if (i != 0)
				{
					component.speed *= (float)i * 0.6f;
					if (((Component)component).TryGetComponent<AudioSource>(ref val2))
					{
						((Behaviour)val2).enabled = false;
					}
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Mindflayer))]
	public class MindflayerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mindflayer), "SetSpeed")]
		public static void SetSpeedPostfix(Mindflayer __instance)
		{
			__instance.difficulty = Util.GetDifficulty();
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1f : 1.35f);
				__instance.cooldownMultiplier = 3.25f * num * __instance.eid.totalSpeedModifier;
				__instance.anim.speed = 1.75f * num * __instance.eid.totalSpeedModifier;
				__instance.defaultAnimSpeed = __instance.anim.speed;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mindflayer), "ShootProjectiles")]
		public static void ShootProjectilesPostfix(Mindflayer __instance)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (Util.IsHardMode() && __instance.hadVision)
			{
				Plugin.CreateVirtueInsignia(0.5f, 0.7f, 5f, __instance.eid.target.position, ((Component)__instance).transform.position, __instance.eid.target, __instance.enemy, __instance.eid.totalDamageModifier, 0.5f);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Mindflayer), "StartBeam")]
		public static void StartBeamPostfix(Mindflayer __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return;
			}
			int num = ((!__instance.isEnraged) ? 10 : 15);
			Color val2 = default(Color);
			for (int i = 0; i < num; i++)
			{
				Vector3 onUnitSphere = Random.onUnitSphere;
				float num2 = Mathf.Atan2(onUnitSphere.z, onUnitSphere.x) * 57.29578f;
				if (num2 < 0f)
				{
					num2 += 360f;
				}
				float num3 = Mathf.Asin(onUnitSphere.y) * 57.29578f;
				num2 = Mathf.Round(num2 / 2f) * 2f;
				num3 = Mathf.Round(num3 / 2f) * 2f;
				float num4 = num2 * (MathF.PI / 180f);
				float num5 = num3 * (MathF.PI / 180f);
				float num6 = Mathf.Cos(num5) * Mathf.Cos(num4);
				float num7 = Mathf.Sin(num5);
				float num8 = Mathf.Cos(num5) * Mathf.Sin(num4);
				Vector3 val = new Vector3(num6, num7, num8);
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				Projectile component = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileHoming"], ((Component)__instance).transform.position + 2f * normalized, Quaternion.LookRotation(normalized)).GetComponent<Projectile>();
				component.homingType = (HomingType)0;
				component.speed = 60f;
				component.unparryable = true;
				component.damage = 15f;
				component.enemyDamageMultiplier = 1f;
				if (Util.IsHardMode())
				{
					Transform transform = ((Component)component).transform;
					transform.localScale *= 2f;
					if (__instance.isEnraged)
					{
						Transform transform2 = ((Component)component).transform;
						transform2.localScale *= 1.25f;
					}
				}
				SlowDownOverTime slowDownOverTime = ((Component)component).gameObject.AddComponent<SlowDownOverTime>();
				slowDownOverTime.slowRate = ((!__instance.isEnraged) ? Random.Range(1.8f, 3.75f) : Random.Range(2f, 4.5f));
				if (Util.IsHardMode())
				{
					slowDownOverTime.slowRate /= 1.4f;
				}
				RemoveOnTime component2 = ((Component)component).GetComponent<RemoveOnTime>();
				component2.time = 5f;
				ChangeScaleOverTime changeScaleOverTime = ((Component)component).gameObject.AddComponent<ChangeScaleOverTime>();
				changeScaleOverTime.delay = 4f;
				changeScaleOverTime.time = 1f;
				changeScaleOverTime.targetScaleMultiplier = 0f;
				AudioSource component3 = ((Component)component).GetComponent<AudioSource>();
				component3.volume *= 0.125f;
				AudioSource component4 = ((Component)((Component)component).transform.Find("ChargeEffect")).GetComponent<AudioSource>();
				component4.volume *= 0.125f;
				((Color)(ref val2))..ctor(0.5f, 0.85f, 0.35f);
				MeshRenderer[] componentsInChildren = ((Component)component).GetComponentsInChildren<MeshRenderer>();
				MeshRenderer[] array = componentsInChildren;
				foreach (MeshRenderer val3 in array)
				{
					((Renderer)val3).material.color = val2;
				}
				TrailRenderer componentInChildren = ((Component)component).GetComponentInChildren<TrailRenderer>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.startColor = val2;
					componentInChildren.endColor = val2;
				}
				Light component5 = ((Component)component).GetComponent<Light>();
				component5.color = val2;
				ParticleSystem componentInChildren2 = ((Component)component).GetComponentInChildren<ParticleSystem>();
				componentInChildren2.Stop(true, (ParticleSystemStopBehavior)1);
				MainModule main = componentInChildren2.main;
				((MainModule)(ref main)).loop = false;
				((MainModule)(ref main)).duration = 4f;
				((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(val2);
				componentInChildren2.Play();
			}
		}
	}
	[HarmonyPatch(typeof(GroundWave), "FixedUpdate")]
	public class GroundWavePatch
	{
		public static bool Prefix(GroundWave __instance, bool __runOriginal)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (!__instance.isTraversingLink || !__runOriginal)
			{
				return false;
			}
			Vector3 val = __instance.traversalVelocity * Time.fixedDeltaTime;
			Transform transform = ((Component)__instance).transform;
			transform.position += val;
			if (((Vector3)(ref __instance.traversalVelocity)).sqrMagnitude > 0.001f)
			{
				((Component)__instance).transform.rotation = Quaternion.LookRotation(((Vector3)(ref __instance.traversalVelocity)).normalized, Vector3.up);
			}
			if (Object.op_Implicit((Object)(object)__instance.rb))
			{
				__instance.rb.position = ((Component)__instance).transform.position;
				__instance.rb.rotation = ((Component)__instance).transform.rotation;
			}
			if (__instance.hasCrossed)
			{
				__instance.postTeleportDistance += ((Vector3)(ref val)).magnitude;
				if (__instance.postTeleportDistance >= 2f)
				{
					__instance.isTraversingLink = false;
					((Behaviour)__instance.nma).enabled = true;
					__instance.nma.Warp(((Component)__instance).transform.position);
					__instance.nma.velocity = __instance.traversalVelocity;
					if ((Object)(object)__instance.nma != (Object)null && ((Behaviour)__instance.nma).enabled)
					{
						__instance.nma.SetDestination(__instance.target.GetNavPoint());
					}
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(MirrorReaper))]
	public class MirrorReaperPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(MirrorReaper), "UpdateDifficulty")]
		public static void UpdateDifficultyPostfix(MirrorReaper __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1.4f : 1.75f);
				__instance.anim.speed = num * __instance.eid.totalSpeedModifier;
				__instance.maxGroundWaves = ((!Util.IsHardMode()) ? 3 : 4);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MirrorReaper), "AttackCheck")]
		public static void AttackCheckPostfix(MirrorReaper __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 0.2f : 0.4f);
				__instance.cooldown -= num * Time.deltaTime;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MirrorReaper), "SpawnGroundWave")]
		public static void SpawnGroundWavePostfix(MirrorReaper __instance)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: 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_02cc: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return;
			}
			Vector3 val = ((__instance.eid.target == null) ? (((Component)MonoSingleton<NewMovement>.Instance).transform.position - ((Component)__instance).transform.position) : (__instance.eid.target.position - ((Component)__instance).transform.position));
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			float num = 5f;
			float num2 = 8f;
			GameObject val2 = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileExplosiveHH"], ((Component)__instance).transform.position + ((Component)__instance).transform.up * num + normalized * num2, Quaternion.identity);
			val2.transform.localScale = 1.5f * Vector3.one;
			Projectile component = val2.GetComponent<Projectile>();
			Explosion[] componentsInChildren = ((Component)component.explosionEffect.transform).GetComponentsInChildren<Explosion>();
			foreach (Explosion val3 in componentsInChildren)
			{
				BillionExplosionController billionExplosionController = ((Component)val3).GetComponent<BillionExplosionController>();
				if ((Object)(object)billionExplosionController == (Object)null)
				{
					billionExplosionController = ((Component)val3).gameObject.AddComponent<BillionExplosionController>();
				}
				billionExplosionController.enemyDamageMultiplier = 0f;
				billionExplosionController.damageMultiplier = 1.5f;
			}
			component.damage = 30f;
			component.enemyDamageMultiplier = 0f;
			component.turningSpeedMultiplier = 3f;
			component.predictiveHomingMultiplier = 0.75f;
			component.turnSpeed = 300f;
			component.bigExplosion = false;
			component.safeEnemyType = (EnemyType)41;
			val2.transform.localScale = 2.5f * Vector3.one;
			ProjectileHeightExplosion projectileHeightExplosion = val2.AddComponent<ProjectileHeightExplosion>();
			projectileHeightExplosion.maxDistance = 4f;
			projectileHeightExplosion.target = __instance.eid.target;
			Color val4 = default(Color);
			((Color)(ref val4))..ctor(0.75f, 0.6f, 0f);
			MeshRenderer[] componentsInChildren2 = ((Component)component).GetComponentsInChildren<MeshRenderer>();
			MeshRenderer[] array = componentsInChildren2;
			foreach (MeshRenderer val5 in array)
			{
				((Renderer)val5).material.color = val4;
			}
			TrailRenderer component2 = ((Component)component).GetComponent<TrailRenderer>();
			component2.startColor = val4;
			component2.endColor = val4;
			Light component3 = ((Component)component).GetComponent<Light>();
			component3.color = val4;
			Rigidbody component4 = val2.GetComponent<Rigidbody>();
			component4.drag = 0f;
			AddForce val6 = val2.AddComponent<AddForce>();
			val6.onEnable = true;
			Vector3 val7 = 2.3f * val;
			Vector3 val8 = 0.03f * val;
			Vector3 velocity = __instance.nma.velocity;
			val6.force = val7 + val8 * ((Vector3)(ref velocity)).magnitude;
			val2.SetActive(false);
			val2.SetActive(true);
		}
	}
	[HarmonyPatch(typeof(Power))]
	public class PowerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Power), "UpdateSpeed")]
		public static void UpdateSpeedPostfix(Power __instance)
		{
			float num = ((!Util.IsHardMode()) ? 1.15f : 1.4f);
			__instance.anim.speed = num * __instance.eid.totalSpeedModifier;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Power), "CanPlaySound")]
		public static void CanPlaySoundPostfix(Power __instance, ref bool __result)
		{
			if (__instance.difficulty == 19)
			{
				__result = true;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Power), "PickAttack")]
		public static void PickAttackPostfix(Power __instance)
		{
			if (__instance.difficulty == 19)
			{
				__instance.attackCooldown = 1.5f;
				if (Util.IsHardMode())
				{
					__instance.attackCooldown = 1.15f;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Power), "Spear")]
		public static void SpearPrefix(Power __instance)
		{
			if (__instance.difficulty == 19)
			{
				__instance.forwardSpeed = 150f;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Power), "SpearAttack")]
		public static bool SpearAttackPrefix(Power __instance)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (!__instance.active || __instance.juggled)
			{
				return false;
			}
			if (__instance.target == null)
			{
				__instance.spearAttacks = 0;
			}
			if (__instance.spearAttacks == 0)
			{
				__instance.ToSpearThrow();
				return false;
			}
			__instance.spearing = (SpearAttackState)1;
			__instance.goForward = false;
			__instance.spearAttacks--;
			float num = 1.5f;
			switch (__instance.difficulty)
			{
			case 0:
			case 1:
				num = 2f;
				break;
			case 2:
				num = 1.5f;
				break;
			case 3:
			case 4:
			case 5:
			case 19:
				num = 0.75f;
				break;
			}
			if (Util.IsHardMode())
			{
				num = 0.6f;
			}
			((MonoBehaviour)__instance).Invoke("SpearAttack", num / __instance.eid.totalSpeedModifier);
			bool flag = false;
			Vector3 val = __instance.lastTargetData.realHeadPosition;
			float num2 = Random.Range(0f, 1f);
			PhysicsCastResult val2 = default(PhysicsCastResult);
			Vector3 val3 = default(Vector3);
			if (!PortalPhysicsV2.Raycast(__instance.lastTargetData.realHeadPosition, Vector3.up, ref val2, ref val3, 17f, LayerMask.op_Implicit(__instance.environmentMask), (QueryTriggerInteraction)1))
			{
				PortalPhysicsV2.Raycast(__instance.lastTargetData.realHeadPosition, Vector3.up, ref val2, ref val3, 15f, LayerMask.op_Implicit(__instance.environmentMask), (QueryTriggerInteraction)1);
				val = val3;
				flag = true;
			}
			else if (!PortalPhysicsV2.Raycast(__instance.lastTargetData.realHeadPosition, Vector3.down, ref val2, ref val3, 17f, LayerMask.op_Implicit(__instance.environmentMask), (QueryTriggerInteraction)1))
			{
				PortalPhysicsV2.Raycast(((Component)__instance).transform.position, Vector3.down, ref val2, ref val3, 15f, LayerMask.op_Implicit(__instance.environmentMask), (QueryTriggerInteraction)1);
				val = val3;
				flag = true;
			}
			if (!flag || ((__instance.difficulty >= 4 || __instance.enraged) && num2 > 0.5f))
			{
				__instance.spearing = (SpearAttackState)2;
				__instance.anim.Play("SpearStinger");
				__instance.Teleport(false, true, true, true, false, false);
				__instance.FollowTarget();
				((MonoBehaviour)__instance).Invoke("SpearFlash", 0.25f / __instance.eid.totalSpeedModifier);
				((MonoBehaviour)__instance).Invoke("SpearGoHorizontal", 0.5f / __instance.eid.totalSpeedModifier);
				return false;
			}
			if ((Object)(object)__instance.anim != (Object)null)
			{
				__instance.anim.Play("SpearDrop");
			}
			int num3 = Mathf.RoundToInt(Vector3.Distance(((Component)__instance).transform.position, val) / 2.5f);
			for (int i = 0; i < num3; i++)
			{
				__instance.CreateDecoy(Vector3.Lerp(((Component)__instance).transform.position, val, (float)i / (float)num3), (float)i / (float)num3 + 0.1f, (Animator)null);
			}
			((Component)__instance).transform.position = val;
			__instance.teleportAttempts = 0;
			Object.Instantiate<GameObject>(__instance.teleportSound, ((Component)__instance).transform.position, Quaternion.identity);
			if (__instance.eid.hooked)
			{
				MonoSingleton<HookArm>.Instance.StopThrow(1f, true);
			}
			__instance.LookAtTarget(0);
			float num4 = 0.75f;
			switch (__instance.difficulty)
			{
			case 0:
			case 1:
				num4 = 1f;
				break;
			case 2:
				num4 = 0.75f;
				break;
			case 3:
			case 4:
			case 5:
			case 19:
				num4 = 0.5f;
				break;
			}
			if (Util.IsHardMode())
			{
				num4 = 0.4f;
			}
			((MonoBehaviour)__instance).Invoke("SpearFlash", num4 / 2f / __instance.eid.totalSpeedModifier);
			((MonoBehaviour)__instance).Invoke("SpearGo", num4 / __instance.eid.totalSpeedModifier);
			return false;
		}
	}
	[HarmonyPatch(typeof(Puppet))]
	public class PuppetPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Puppet), "Start")]
		public static void Postfix(Puppet __instance)
		{
			if (Util.IsDifficulty(19))
			{
				float num = ((!Util.IsHardMode()) ? 1.5f : 2.25f);
				((Component)__instance).GetComponent<Animator>().speed = num;
				NavMeshAgent component = ((Component)__instance).GetComponent<NavMeshAgent>();
				component.speed *= num;
			}
		}
	}
	[HarmonyPatch(typeof(Turret))]
	public class TurretPatch
	{
		[CompilerGenerated]
		private sealed class <ShootMortar>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Turret __instance;

			public int shotsLeft;

			public int maxShots;

			private float <upOffset>5__1;

			private float <forwardOffset>5__2;

			private GameObject <projectile>5__3;

			private Projectile <projectileComp>5__4;

			private Vector3 <bigProjectileExtraForce>5__5;

			private Rigidbody <projectileRigidbody>5__6;

			private Rigidbody <sentryRigidbody>5__7;

			private AddForce <forceComp>5__8;

			private GameObject <fart>5__9;

			private Projectile <proj>5__10;

			private HurtZone <hurtZone>5__11;

			private Explosion[] <>s__12;

			private int <>s__13;

			private Explosion <explosion>5__14;

			private BillionExplosionController <excon>5__15;

			private Vector3 <distance>5__16;

			private ProjectileHeightExplosion <heightExplosion>5__17;

			private Color <newProjectileColor>5__18;

			private MeshRenderer[] <renderers>5__19;

			private TrailRenderer <trail>5__20;

			private Light <light>5__21;

			private MeshRenderer[] <>s__22;

			private int <>s__23;

			private MeshRenderer <renderer>5__24;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<projectile>5__3 = null;
				<projectileComp>5__4 = null;
				<projectileRigidbody>5__6 = null;
				<sentryRigidbody>5__7 = null;
				<forceComp>5__8 = null;
				<fart>5__9 = null;
				<proj>5__10 = null;
				<hurtZone>5__11 = null;
				<>s__12 = null;
				<explosion>5__14 = null;
				<excon>5__15 = null;
				<heightExplosion>5__17 = null;
				<renderers>5__19 = null;
				<trail>5__20 = null;
				<light>5__21 = null;
				<>s__22 = null;
				<renderer>5__24 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Expected O, but got Unknown
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_0220: Unknown result type (might be due to invalid IL or missing references)
				//IL_0225: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0430: Unknown result type (might be due to invalid IL or missing references)
				//IL_0435: Unknown result type (might be due to invalid IL or missing references)
				//IL_044a: Unknown result type (might be due to invalid IL or missing references)
				//IL_044f: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_05f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0547: Unknown result type (might be due to invalid IL or missing references)
				//IL_0559: Unknown result type (might be due to invalid IL or missing references)
				//IL_057c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0692: Unknown result type (might be due to invalid IL or missing references)
				//IL_0697: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_06d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_06d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_0707: Unknown result type (might be due to invalid IL or missing references)
				//IL_070c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0711: Unknown result type (might be due to invalid IL or missing references)
				//IL_0716: Unknown result type (might be due to invalid IL or missing references)
				//IL_071c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0721: Unknown result type (might be due to invalid IL or missing references)
				//IL_0726: Unknown result type (might be due to invalid IL or missing references)
				//IL_0621: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (shotsLeft <= 0)
					{
						return false;
					}
					<>2__current = (object)new WaitForSeconds((shotsLeft == maxShots) ? 0.15f : 0.25f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (Util.IsHardMode() && shotsLeft == maxShots)
					{
						<fart>5__9 = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileHomingAcid"], ((Component)__instance).transform.position + 3f * ((Component)__instance).transform.forward + 3f * ((Component)__instance).transform.up, ((Component)__instance).transform.rotation);
						<proj>5__10 = <fart>5__9.GetComponent<Projectile>();
						<proj>5__10.safeEnemyType = (EnemyType)20;
						<proj>5__10.speed = 25f;
						<hurtZone>5__11 = <fart>5__9.GetComponentInChildren<HurtZone>(true);
						<hurtZone>5__11.affected = (AffectedSubjects)1;
						<fart>5__9 = null;
						<proj>5__10 = null;
						<hurtZone>5__11 = null;
					}
					<upOffset>5__1 = ((shotsLeft != maxShots) ? 4.5f : 5f);
					<forwardOffset>5__2 = ((shotsLeft != maxShots) ? 3f : 4.5f);
					<projectile>5__3 = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileExplosiveHH"], ((Component)__instance).transform.position + ((Component)__instance).transform.up * <upOffset>5__1 + ((Component)__instance).transform.forward * <forwardOffset>5__2, Quaternion.identity);
					<projectile>5__3.transform.localScale = 1.5f * Vector3.one;
					<projectileComp>5__4 = <projectile>5__3.GetComponent<Projectile>();
					<>s__12 = ((Component)<projectileComp>5__4.explosionEffect.transform).GetComponentsInChildren<Explosion>();
					for (<>s__13 = 0; <>s__13 < <>s__12.Length; <>s__13++)
					{
						<explosion>5__14 = <>s__12[<>s__13];
						<excon>5__15 = ((Component)<explosion>5__14).GetComponent<BillionExplosionController>();
						if ((Object)(object)<excon>5__15 == (Object)null)
						{
							<excon>5__15 = ((Component)<explosion>5__14).gameObject.AddComponent<BillionExplosionController>();
						}
						<excon>5__15.enemyDamageMultiplier = 0f;
						<excon>5__15.damageMultiplier = 1.5f;
						if (shotsLeft == maxShots)
						{
							<excon>5__15.maxSizeMultiplier = 2.5f;
							<excon>5__15.speedMultiplier = 0.8f;
						}
						else
						{
							<excon>5__15.maxSizeMultiplier = 1f;
							<excon>5__15.speedMultiplier = 1.5f;
						}
						<excon>5__15 = null;
						<explosion>5__14 = null;
					}
					<>s__12 = null;
					<projectileComp>5__4.damage = 30f;
					<projectileComp>5__4.enemyDamageMultiplier = 0f;
					<projectileComp>5__4.predictiveHomingMultiplier = 0.75f;
					<projectileComp>5__4.bigExplosion = false;
					<bigProjectileExtraForce>5__5 = Vector3.zero;
					if (shotsLeft == maxShots)
					{
						<distance>5__16 = __instance.eid.target.position - ((Component)__instance).transform.position;
						<bigProjectileExtraForce>5__5 = new Vector3(0.9f * <distance>5__16.x, 16f + 0.75f * <distance>5__16.y, 0.9f * <distance>5__16.z);
						<projectile>5__3.transform.localScale = 2.5f * Vector3.one;
						<heightExplosion>5__17 = <projectile>5__3.AddComponent<ProjectileHeightExplosion>();
						<heightExplosion>5__17.maxDistance = 8f;
						<heightExplosion>5__17.target = __instance.eid.target;
						<newProjectileColor>5__18 = new Color(0.75f, 0.6f, 0f);
						<renderers>5__19 = ((Component)<projectileComp>5__4).GetComponentsInChildren<MeshRenderer>();
						<>s__22 = <renderers>5__19;
						for (<>s__23 = 0; <>s__23 < <>s__22.Length; <>s__23++)
						{
							<renderer>5__24 = <>s__22[<>s__23];
							((Renderer)<renderer>5__24).material.color = <newProjectileColor>5__18;
							<renderer>5__24 = null;
						}
						<>s__22 = null;
						<trail>5__20 = ((Component)<projectileComp>5__4).GetComponent<TrailRenderer>();
						<trail>5__20.startColor = <newProjectileColor>5__18;
						<trail>5__20.endColor = <newProjectileColor>5__18;
						<light>5__21 = ((Component)<projectileComp>5__4).GetComponent<Light>();
						<light>5__21.color = <newProjectileColor>5__18;
						<heightExplosion>5__17 = null;
						<renderers>5__19 = null;
						<trail>5__20 = null;
						<light>5__21 = null;
					}
					<projectileRigidbody>5__6 = <projectile>5__3.GetComponent<Rigidbody>();
					<projectileRigidbody>5__6.drag = ((shotsLeft != maxShots) ? (-2.2f) : 0f);
					<sentryRigidbody>5__7 = ((Component)__instance).GetComponent<Rigidbody>();
					if (<sentryRigidbody>5__7.velocity.y > 2f)
					{
						Rigidbody obj = <projectileRigidbody>5__6;
						obj.drag /= 0.5f * <sentryRigidbody>5__7.velocity.y;
						if (<projectileRigidbody>5__6.drag < -2.2f)
						{
							<projectileRigidbody>5__6.drag = 0f;
						}
					}
					<forceComp>5__8 = <projectile>5__3.AddComponent<AddForce>();
					<forceComp>5__8.onEnable = true;
					<forceComp>5__8.force = 12f * ((Component)__instance).transform.up + 10f * (((Component)__instance).transform.forward - new Vector3(0f, ((Component)__instance).transform.forward.y, 0f) + 0.2f * ((Component)__instance).transform.right * CalculateMortarAngle(maxShots - shotsLeft)) + <bigProjectileExtraForce>5__5;
					<projectile>5__3.SetActive(false);
					<projectile>5__3.SetActive(true);
					((MonoBehaviour)__instance).StartCoroutine(ShootMortar(__instance, shotsLeft - 1, maxShots));
					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();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Turret), "Start")]
		public static void StartPostfix(Turret __instance)
		{
			if (__instance.difficulty == 19)
			{
				__instance.maxAimTime = 3.75f;
				Animator anim = __instance.anim;
				anim.speed *= 1.25f;
				NavMeshAgent nma = __instance.nma;
				nma.speed *= 1.25f;
				SentryMortar sentryMortar = ((Component)__instance).gameObject.AddComponent<SentryMortar>();
				sentryMortar.rb = ((Component)__instance).GetComponent<Rigidbody>();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Turret), "Shoot")]
		public static bool ShootPrefix(Turret __instance)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			SentryMortar component = ((Component)__instance).GetComponent<SentryMortar>();
			component.canShootOrb = false;
			if (!__instance.isBarrelPortalBlocked)
			{
				Vector3 val = (Vector3)(__instance.isBarrelPortalCrossed ? __instance.barrelPos : new Vector3(((Component)__instance).transform.position.x, ((Component)__instance.barrelTip).transform.position.y, ((Component)__instance).transform.position.z));
				RevolverBeam val2 = Object.Instantiate<RevolverBeam>(__instance.beam, val, __instance.shootRotation);
				val2.alternateStartPoint = (__instance.isBarrelPortalCrossed ? Vector3.zero : __instance.barrelPos);
				RevolverBeam val3 = default(RevolverBeam);
				if (((Component)val2).TryGetComponent<RevolverBeam>(ref val3))
				{
					val3.target = __instance.eid.target;
					RevolverBeam obj = val3;
					obj.damage *= __instance.eid.totalDamageModifier;
					if (__instance.difficulty == 19)
					{
						RevolverBeam obj2 = val3;
						obj2.damage *= 0.8f;
					}
				}
			}
			__instance.anim.Play("Shoot");
			__instance.CancelAim(false);
			__instance.BodyFreeze();
			__instance.cooldown = Random.Range(2.5f, 3.5f);
			__instance.shotsInARow++;
			if (__instance.shotsInARow < 3)
			{
				((MonoBehaviour)__instance).Invoke("PreReAim", 0f);
			}
			return false;
		}

		public static float CalculateMortarAngle(float shotNumber)
		{
			if (shotNumber % 2f == 0f)
			{
				return 0f - shotNumber / 2f;
			}
			return (shotNumber + 1f) / 2f;
		}

		[IteratorStateMachine(typeof(<ShootMortar>d__3))]
		public static IEnumerator ShootMortar(Turret __instance, int shotsLeft, int maxShots)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ShootMortar>d__3(0)
			{
				__instance = __instance,
				shotsLeft = shotsLeft,
				maxShots = maxShots
			};
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Turret), "CancelAim")]
		public static void CancelAimPrefix(Turret __instance)
		{
			if (__instance.difficulty == 19)
			{
				SentryMortar component = ((Component)__instance).GetComponent<SentryMortar>();
				if (__instance.aiming && component.canShootOrb)
				{
					((MonoBehaviour)__instance).StartCoroutine(ShootMortar(__instance, 3, 3));
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Turret), "CancelAim")]
		public static void CancelAimPostfix(Turret __instance)
		{
			if (__instance.difficulty == 19)
			{
				SentryMortar component = ((Component)__instance).GetComponent<SentryMortar>();
				component.canShootOrb = true;
			}
		}
	}
	[HarmonyPatch(typeof(Sisyphus))]
	public class SisyphusPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Sisyphus), "Start")]
		public static void StartPrefix(Sisyphus __instance)
		{
			if (__instance.difficulty == 19)
			{
				if (!Object.op_Implicit((Object)(object)__instance.eid))
				{
					__instance.eid = ((Component)__instance).GetComponent<EnemyIdentifier>();
				}
				DamageOverTimeTracker damageOverTimeTracker = ((Component)__instance).gameObject.AddComponent<DamageOverTimeTracker>();
				damageOverTimeTracker.damageThreshold = 30f * __instance.eid.totalHealthModifier;
				damageOverTimeTracker.timeWindow = 5f;
				damageOverTimeTracker.cooldownMax = 1f;
				damageOverTimeTracker.buffSpeed = true;
				damageOverTimeTracker.speedBuff = 1.1f;
				damageOverTimeTracker.speedBuffTime = 7f;
				if (Util.IsHardMode())
				{
					damageOverTimeTracker.speedBuffTime = 10f;
				}
				BoolValue boolValue = ((Component)__instance).gameObject.AddComponent<BoolValue>();
				boolValue.value = false;
				boolValue.description = "enraged";
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Sisyphus), "SetupExplosion")]
		public static void SetupExplosionPrefix(Sisyphus __instance)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (!Util.IsHardMode())
			{
				return;
			}
			if (BoolValue.Get("enraged", ((Component)__instance).gameObject) == false)
			{
				BlackHoleFromSisyphus[] array = Object.FindObjectsByType<BlackHoleFromSisyphus>((FindObjectsSortMode)0);
				foreach (BlackHoleFromSisyphus blackHoleFromSisyphus in array)
				{
					if ((Object)(object)blackHoleFromSisyphus.sisy == (Object)(object)__instance)
					{
						return;
					}
				}
			}
			GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["BlackHoleEnemy"], ((Component)__instance.boulderCb).transform.position, Quaternion.identity);
			Transform transform = val.transform;
			transform.localScale *= 3f;
			BlackHoleProjectile component = val.GetComponent<BlackHoleProjectile>();
			component.speed = (float)Random.Range(15, 26) / 2f;
			component.Activate();
			val.AddComponent<BlackHoleFromSisyphus>().sisy = __instance;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Sisyphus), "GetSpeed")]
		public static bool GetSpeedPrefix(int difficulty, ref EnemyMovementData __result)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (difficulty != 19)
			{
				return true;
			}
			float num = ((!Util.IsHardMode()) ? 1f : 1.25f);
			__result = new EnemyMovementData
			{
				speed = 15f * num,
				angularSpeed = 999f,
				acceleration = 666f
			};
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Sisyphus), "Death")]
		public static void DeathPostfix(Sisyphus __instance)
		{
			if (__instance.difficulty == 19)
			{
				Transform val = __instance.mach.chest.transform.Find("RageEffect(Clone)");
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Sisyphus), "SetSpeed")]
		public static void SetSpeedPostfix(Sisyphus __instance)
		{
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19 || __instance.eid.dead)
			{
				return;
			}
			DamageOverTimeTracker component = ((Component)__instance).GetComponent<DamageOverTimeTracker>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			float num = 1f;
			bool? flag = BoolValue.Get("enraged", ((Component)__instance).gameObject);
			if (component.buffingSpeed && flag == false)
			{
				num = component.speedBuff;
				BoolValue.Set("enraged", newValue: true, ((Component)__instance).gameObject);
				if (!__instance.eid.puppet)
				{
					SkinnedMeshRenderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<SkinnedMeshRenderer>();
					SkinnedMeshRenderer[] array = componentsInChildren;
					foreach (SkinnedMeshRenderer val in array)
					{
						((Renderer)val).material.color = new Color(1f, 0.35f, 0.35f);
					}
				}
				Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.enrageEffect, __instance.mach.chest.transform);
			}
			else if (!component.buffingSpeed && flag.GetValueOrDefault())
			{
				BoolValue.Set("enraged", newValue: false, ((Component)__instance).gameObject);
				SkinnedMeshRenderer[] componentsInChildren2 = ((Component)__instance).GetComponentsInChildren<SkinnedMeshRenderer>();
				if (!__instance.eid.puppet)
				{
					SkinnedMeshRenderer[] array2 = componentsInChildren2;
					foreach (SkinnedMeshRenderer val2 in array2)
					{
						((Renderer)val2).material.color = new Color(1f, 1f, 1f);
					}
				}
				Transform val3 = __instance.mach.chest.transform.Find("RageEffect(Clone)");
				if ((Object)(object)val3 != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val3).gameObject);
				}
			}
			float num2 = ((!Util.IsHardMode()) ? 1f : 1.25f);
			float num3 = num2 * num * __instance.eid.totalSpeedModifier;
			__instance.anim.speed = 1.05f * num3;
			__instance.nma.speed = 15f * num3;
			__instance.anim.SetFloat("StompSpeed", 1.1f * num3);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Sisyphus), "Update")]
		public static void UpdatePostfix(Sisyphus __instance)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return;
			}
			DamageOverTimeTracker component = ((Component)__instance).GetComponent<DamageOverTimeTracker>();
			if (component.buffSpeed && !component.buffingSpeed)
			{
				__instance.SetSpeed();
			}
			if (component.reached && !component.onCooldown)
			{
				component.onCooldown = true;
				__instance.SetSpeed();
				GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["ExplosionSuper"], ((Component)__instance).transform.position, Quaternion.identity);
				val.transform.LookAt(((Component)MonoSingleton<NewMovement>.Instance).transform);
				Transform transform = val.transform;
				transform.localScale *= 1.5f;
				Explosion[] componentsInChildren = val.GetComponentsInChildren<Explosion>();
				foreach (Explosion val2 in componentsInChildren)
				{
					val2.maxSize *= 1.5f;
					val2.damage = Mathf.RoundToInt(40f * __instance.eid.totalDamageModifier);
					val2.enemyDamageMultiplier = ((!Util.IsHardMode()) ? 0.875f : 0f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Stalker))]
	public class StalkerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Stalker), "SetSpeed")]
		public static void SetSpeedPostfix(Stalker __instance)
		{
			if (__instance.difficulty == 19)
			{
				Animator anim = __instance.anim;
				anim.speed *= 1.25f;
				__instance.explodeSpeed = 1.25f;
				__instance.anim.SetFloat("ExplodeSpeed", __instance.explodeSpeed);
				NavMeshAgent nma = __instance.nma;
				nma.speed *= 1.25f;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Stalker), "SandExplode")]
		public static bool SandExplodePrefix(int onDeath, Stalker __instance)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//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_00fe: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//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_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.exploded)
			{
				return false;
			}
			GameObject val = Object.Instantiate<GameObject>(AddressablesExtensions.ToAsset(__instance.explosion), ((Component)__instance).transform.position + ((Component)__instance).transform.up * 2.5f, Quaternion.identity);
			if (__instance.difficulty == 19)
			{
				StalkerHealBack stalkerHealBack = ((Component)__instance).gameObject.AddComponent<StalkerHealBack>();
				stalkerHealBack.healed = true;
				StalkerHealBackMessenger stalkerHealBackMessenger = ((Component)val.transform.Find("GameObject")).gameObject.AddComponent<StalkerHealBackMessenger>();
				stalkerHealBackMessenger.source = __instance.mach;
			}
			if (Util.IsHardMode())
			{
				Transform transform = val.transform;
				transform.localScale *= 1.15f;
				Vector3 position = ((Component)MonoSingleton<NewMovement>.Instance).transform.position;
				Vector3 val2 = ((Component)__instance).transform.position - position;
				((Vector3)(ref val2)).Normalize();
				GameObject val3 = Object.Instantiate<GameObject>(Plugin.Prefabs["ProjectileHomingAcid"], ((Component)__instance).transform.position + ((Component)__instance).transform.up * 4f, Quaternion.LookRotation(((Component)__instance).transform.up, val2));
				Projectile component = val3.GetComponent<Projectile>();
				component.safeEnemyType = (EnemyType)12;
				component.speed = 25f;
				component.target = new EnemyTarget(((Component)MonoSingleton<NewMovement>.Instance).transform);
				HurtZone componentInChildren = val3.GetComponentInChildren<HurtZone>(true);
				componentInChildren.affected = (AffectedSubjects)1;
			}
			if (onDeath != 1)
			{
				Transform transform2 = val.transform;
				transform2.localScale *= 1.5f;
			}
			if (__instance.eid.stuckMagnets.Count > 0)
			{
				float num = 0.75f;
				if (__instance.eid.stuckMagnets.Count > 1)
				{
					num -= 0.125f * (float)(__instance.eid.stuckMagnets.Count - 1);
				}
				Transform transform3 = val.transform;
				transform3.localScale *= num;
			}
			if (__instance.eid.target != null && Object.op_Implicit((Object)(object)__instance.eid.target.enemyIdentifier) && __instance.eid.target.enemyIdentifier.sandified)
			{
				if (MonoSingleton<StalkerController>.Instance.CheckIfTargetTaken(__instance.eid.target.targetTransform))
				{
					MonoSingleton<StalkerController>.Instance.targets.Remove(__instance.eid.target.targetTransform);
				}
				EnemyIdentifier val4 = default(EnemyIdentifier);
				if (((Component)__instance.eid.target.targetTransform).TryGetComponent<EnemyIdentifier>(ref val4) && (Object)(object)val4.buffTargeter == (Object)(object)__instance.eid)
				{
					val4.buffTargeter = null;
				}
			}
			if ((__instance.difficulty > 3 || __instance.eid.blessed || InvincibleEnemies.Enabled) && onDeath != 1)
			{
				__instance.exploding = false;
				__instance.countDownAmount = 0f;
				__instance.explosionCharge = 0f;
				__instance.currentColor = __instance.lightColors[0];
				__instance.lightAud.clip = __instance.lightSounds[0];
				__instance.blinking = false;
				return false;
			}
			__instance.exploded = true;
			if (!__instance.mach.limp && onDeath != 1)
			{
				__instance.mach.GoLimp();
				__instance.eid.Death();
			}
			if (__instance.eid.drillers.Count != 0)
			{
				for (int num2 = __instance.eid.drillers.Count - 1; num2 >= 0; num2--)
				{
					Object.Destroy((Object)(object)((Component)__instance.eid.drillers[num2]).gameObject);
				}
			}
			((Component)__instance).gameObject.SetActive(false);
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	[HarmonyPatch(typeof(SandificationZone))]
	public class SandificationZonePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(SandificationZone), "Enter")]
		public static void EnterPostfix(Collider other, SandificationZone __instance)
		{
			if (__instance.difficulty != 19)
			{
				return;
			}
			EnemyIdentifierIdentifier component = ((Component)other).GetComponent<EnemyIdentifierIdentifier>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			EnemyIdentifier eid = component.eid;
			if ((Object)(object)eid == (Object)null || eid.dead)
			{
				return;
			}
			StalkerHealBackMessenger component2 = ((Component)__instance).GetComponent<StalkerHealBackMessenger>();
			if (!((Object)(object)component2 == (Object)null))
			{
				StalkerHealBack stalkerHealBack = ((Component)eid).GetComponent<StalkerHealBack>();
				if ((Object)(object)stalkerHealBack == (Object)null)
				{
					stalkerHealBack = ((Component)eid).gameObject.AddComponent<StalkerHealBack>();
				}
				stalkerHealBack.source = component2.source;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SandificationZone), "Start")]
		public static void StartPostfix(SandificationZone __instance)
		{
			if (__instance.difficulty == 19)
			{
				RemoveOnTime[] componentsInChildren = ((Component)((Component)__instance).transform.parent).GetComponentsInChildren<RemoveOnTime>();
				foreach (RemoveOnTime val in componentsInChildren)
				{
					((MonoBehaviour)val).CancelInvoke("Remove");
					((MonoBehaviour)val).Invoke("Remove", 3.5f);
				}
				ScaleNFade[] componentsInChildren2 = ((Component)((Component)__instance).transform.parent).GetComponentsInChildren<ScaleNFade>();
				foreach (ScaleNFade val2 in componentsInChildren2)
				{
					val2.fadeSpeed /= 5f;
					val2.scaleSpeed /= 5f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Streetcleaner))]
	public class StreetcleanerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Streetcleaner), "Start")]
		public static void StartPostfix(Streetcleaner __instance)
		{
			//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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return;
			}
			float num = ((!Util.IsHardMode()) ? 1f : 1.1f);
			__instance.anim.speed = 1.25f * num * __instance.eid.totalSpeedModifier;
			__instance.nma.speed = 30f * num;
			__instance.nma.acceleration = 80f;
			__instance.nma.angularSpeed = 5000f;
			if (Util.IsHardMode())
			{
				StreetcleanerAfterburn streetcleanerAfterburn = ((Component)__instance).gameObject.AddComponent<StreetcleanerAfterburn>();
				streetcleanerAfterburn.damage = Mathf.RoundToInt(4f * __instance.eid.totalDamageModifier);
			}
			Transform child = ((Component)__instance).transform.GetChild(0);
			object obj;
			if (child == null)
			{
				obj = null;
			}
			else
			{
				Transform child2 = child.GetChild(0);
				if (child2 == null)
				{
					obj = null;
				}
				else
				{
					Transform obj2 = child2.Find("flameboi2rig2");
					if (obj2 == null)
					{
						obj = null;
					}
					else
					{
						Transform obj3 = obj2.Find("Armature");
						if (obj3 == null)
						{
							obj = null;
						}
						else
						{
							Transform obj4 = obj3.Find("flamethrowergrip");
							obj = ((obj4 != null) ? obj4.Find("Fire") : null);
						}
					}
				}
			}
			Transform val = (Transform)obj;
			if (!((Object)(object)val == (Object)null))
			{
				ParticleSystem component = ((Component)val.Find("Particle System")).GetComponent<ParticleSystem>();
				LimitVelocityOverLifetimeModule limitVelocityOverLifetime = component.limitVelocityOverLifetime;
				((LimitVelocityOverLifetimeModule)(ref limitVelocityOverLifetime)).dampen = ((LimitVelocityOverLifetimeModule)(ref limitVelocityOverLifetime)).dampen / 1.35f;
				Transform obj5 = val.Find("Particle System/Cube");
				obj5.localScale *= 1.35f;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Streetcleaner), "GetSpeed")]
		public static bool GetSpeedPrefix(int difficulty, ref EnemyMovementData __result)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (difficulty != 19)
			{
				return true;
			}
			float num = ((!Util.IsHardMode()) ? 1f : 1.1f);
			__result = new EnemyMovementData
			{
				speed = 30f * num,
				acceleration = 80f,
				angularSpeed = 5000f
			};
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(EnemyIdentifier), "GetReachDistanceMultiplier")]
		public static bool GetReachDistanceMultiplierPostfix(EnemyIdentifier __instance, ref float __result)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			if (__instance.difficulty != 19 || (int)__instance.enemyType != 6)
			{
				return true;
			}
			__result = 0.75f;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Streetcleaner), "LateUpdate")]
		public static bool LateUpdatePrefix(Streetcleaner __instance)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (!__instance.attacking)
			{
				return false;
			}
			if (__instance.target == null)
			{
				return false;
			}
			Vector3 val = (__instance.hasVision ? __instance.targetData.headPosition : __instance.target.headPosition);
			float num = ((__instance.difficulty == 5) ? 90 : 35);
			if (__instance.difficulty == 19)
			{
				num = 90f;
			}
			Quaternion rotation = __instance.aimBone.rotation;
			Quaternion val2 = Quaternion.RotateTowards(__instance.aimBone.rotation, Quaternion.LookRotation(val - __instance.aimBone.position, Vector3.up), num);
			Quaternion val3 = Quaternion.Inverse(((Component)__instance).transform.rotation * __instance.torsoDefaultRotation) * __instance.aimBone.rotation;
			if (Vector3.Dot(Vector3.up, val2 * Vector3.forward) > 0f)
			{
				__instance.aimBone.rotation = val2 * val3;
			}
			Quaternion val4 = Quaternion.Inverse(rotation) * __instance.aimBone.rotation;
			val4 = Quaternion.Euler(0f - ((Quaternion)(ref val4)).eulerAngles.y, ((Quaternion)(ref val4)).eulerAngles.z, 0f - ((Quaternion)(ref val4)).eulerAngles.x);
			Transform flameThrowerBone = __instance.flameThrowerBone;
			flameThrowerBone.rotation *= val4;
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Streetcleaner), "Update")]
		public static void UpdatePostfix(Streetcleaner __instance)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return;
			}
			if (!__instance.dead && (Object)(object)__instance.nma != (Object)null && ((Behaviour)__instance.nma).enabled && __instance.nma.isOnNavMesh)
			{
				float num = ((TargetData)(ref __instance.targetData)).DistanceTo(__instance.mach.chest.transform.position, false);
				if (__instance.target != null && __instance.target.isEnemy && (Object)(object)__instance.target.enemyIdentifier != (Object)null)
				{
					num *= __instance.target.enemyIdentifier.GetReachDistanceMultiplier();
				}
				bool flag = !__instance.hasDimensionalTarget && num <= (float)(__instance.attacking ? 16 : 6);
				if (!Util.IsHardMode())
				{
					__instance.nma.speed = 30f;
				}
				else
				{
					__instance.nma.speed = (flag ? 33f : 37.5f);
				}
				NavMeshAgent nma = __instance.nma;
				nma.speed *= __instance.eid.totalSpeedModifier;
			}
			else if (Util.IsHardMode())
			{
				StreetcleanerAfterburn component = ((Component)__instance).GetComponent<StreetcleanerAfterburn>();
				if (component != null)
				{
					component.destroyOnEnd = true;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Streetcleaner), "StartDamaging")]
		public static void StartDamagingPostfix(Streetcleaner __instance)
		{
			if (Util.IsHardMode())
			{
				StreetcleanerAfterburn component = ((Component)__instance).GetComponent<StreetcleanerAfterburn>();
				if (component != null)
				{
					component.damagedThePlayer = true;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Streetcleaner), "StopFire")]
		public static void StopFirePrefix(Streetcleaner __instance)
		{
			if (Util.IsHardMode() && __instance.attacking && __instance.damaging)
			{
				StreetcleanerAfterburn component = ((Component)__instance).GetComponent<StreetcleanerAfterburn>();
				if (component != null)
				{
					component.stoppedAttacking = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(SwordsMachine))]
	public class SwordsMachinePatch
	{
		[CompilerGenerated]
		private sealed class <SwordsMachineOverpump>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Vector3 position;

			public float damageMultiplier;

			public SwordsMachine __instance;

			private GameObject <explosionObject>5__1;

			private Explosion[] <>s__2;

			private int <>s__3;

			private Explosion <explosion>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<explosionObject>5__1 = null;
				<>s__2 = null;
				<explosion>5__4 = null;
				<>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
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.15f);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<explosionObject>5__1 = Object.Instantiate<GameObject>(Plugin.Prefabs["ExplosionSuper"], position, Quaternion.identity);
					<explosionObject>5__1.transform.LookAt(((Component)MonoSingleton<NewMovement>.Instance).transform);
					Transform transform = <explosionObject>5__1.transform;
					transform.localScale *= 1.5f;
					<>s__2 = <explosionObject>5__1.GetComponentsInChildren<Explosion>();
					for (<>s__3 = 0; <>s__3 < <>s__2.Length; <>s__3++)
					{
						<explosion>5__4 = <>s__2[<>s__3];
						Explosion obj = <explosion>5__4;
						obj.maxSize *= 1.5f;
						<explosion>5__4.damage = Mathf.RoundToInt(40f * damageMultiplier);
						<explosion>5__4.enemyDamageMultiplier = 0.25f;
						<explosion>5__4 = null;
					}
					<>s__2 = null;
					BoolValue.Set("overpumping", newValue: false, ((Component)__instance).gameObject);
					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();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SwordsMachine), "Start")]
		public static void StartPostfix(SwordsMachine __instance)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty == 19)
			{
				((Component)__instance).gameObject.AddComponent<CounterInt>().maxValue = 2;
				if (!__instance.bossVersion)
				{
					__instance.phaseChangeHealth = 10f;
				}
				TimerFloat timerFloat = ((Component)__instance).gameObject.AddComponent<TimerFloat>();
				timerFloat.cooldownMax = 2f;
				timerFloat.reached = true;
				BoolValue boolValue = ((Component)__instance).gameObject.AddComponent<BoolValue>();
				boolValue.description = "overpumping";
				boolValue.value = false;
				GameObject val = new GameObject("PumpChargeObject");
				val.transform.SetParent(((Component)__instance).transform);
				val.transform.localPosition = Vector3.zero;
				AudioSource val2 = val.AddComponent<AudioSource>();
				AudioSourceExtensions.SetPlayOnAwake(val2, false);
				val2.playOnAwake = false;
				val2.clip = Plugin.PumpCharge;
				AudioSourceExtensions.SetPitch(val2, 1.35f);
				AudioSourceExtensions.SetSpatialBlend(val2, 0f);
				val2.maxDistance = 50f;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SwordsMachine), "KnockdownSetup")]
		public static void KnockdownSetupPrefix(SwordsMachine __instance)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (Util.IsHardMode())
			{
				GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["GoopLarge"], ((Component)__instance).transform.position, Quaternion.identity);
				val.AddComponent<RemoveOnRespawn>();
				((Component)val.transform.Find("Cylinder")).GetComponent<HurtZone>().affected = (AffectedSubjects)1;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SwordsMachine), "SetSpeed")]
		public static void SetSpeedPostfixPostfix(SwordsMachine __instance)
		{
			if (__instance.difficulty == 19)
			{
				float num = ((!Util.IsHardMode()) ? 1f : 1.1f);
				__instance.nma.speed = (__instance.firstPhase ? 22f : 26f);
				NavMeshAgent nma = __instance.nma;
				nma.speed *= num;
				__instance.anim.speed = 1.2f * num;
				__instance.anim.SetFloat("ThrowSpeedMultiplier", 1.45f * num);
				__instance.anim.SetFloat("AttackSpeedMultiplier", 1.15f * num);
				__instance.moveSpeedMultiplier = 1.45f * num * __instance.eid.totalSpeedModifier;
				__instance.normalMovSpeed = __instance.nma.speed * __instance.eid.totalSpeedModifier;
				__instance.normalAnimSpeed = __instance.anim.speed * __instance.eid.totalSpeedModifier;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SwordsMachine), "GetSpeed")]
		public static bool GetSpeedPrefix(int difficulty, SwordsMachine __instance, ref EnemyMovementData __result)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (difficulty != 19)
			{
				return true;
			}
			float num = ((!Util.IsHardMode()) ? 1f : 1.1f);
			float num2 = (__instance.firstPhase ? 22f : 26f);
			num2 *= num;
			__result = new EnemyMovementData
			{
				speed = num2,
				angularSpeed = 1200f,
				acceleration = 160f
			};
			return false;
		}

		[IteratorStateMachine(typeof(<SwordsMachineOverpump>d__4))]
		public static IEnumerator SwordsMachineOverpump(Vector3 position, float damageMultiplier, SwordsMachine __instance)
		{
			//IL_0007: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SwordsMachineOverpump>d__4(0)
			{
				position = position,
				damageMultiplier = damageMultiplier,
				__instance = __instance
			};
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SwordsMachine), "ShootGun")]
		public static bool ShootGunPrefix(SwordsMachine __instance)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: 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_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			CounterInt component = ((Component)__instance).GetComponent<CounterInt>();
			TimerFloat component2 = ((Component)__instance).GetComponent<TimerFloat>();
			if (__instance.inAction)
			{
				return false;
			}
			switch (component.value)
			{
			case 1:
			{
				if (__instance.hasVision)
				{
					TargetData value = __instance.vision.CalculateData(__instance.targetHandle);
					__instance.shotgun.UpdateTarget((TargetData?)value);
				}
				else if (__instance.target != null)
				{
					__instance.lastTargetData.position = __instance.target.position;
					__instance.shotgun.UpdateTarget((TargetData?)__instance.lastTargetData);
				}
				Vector3 val = ((Component)__instance.shotgun.shootPoint).transform.position - ((EnemyScript)__instance).VisionSourcePosition;
				PhysicsCastResult val2 = default(PhysicsCastResult);
				Vector3 val3 = default(Vector3);
				PortalTraversalV2[] array = default(PortalTraversalV2[]);
				PortalPhysicsV2.ProjectThroughPortals(((EnemyScript)__instance).VisionSourcePosition, val, LayerMask.op_Implicit(default(LayerMask)), ref val2, ref val3, ref array);
				bool flag = false;
				if (array.Length != 0)
				{
					PortalTraversalV2 val4 = array[0];
					PortalHandle portalHandle = val4.portalHandle;
					Portal portalObject = val4.portalObject;
					flag = !((Enum)portalObject.GetTravelFlags(portalHandle.side)).HasFlag((Enum)(object)(PortalTravellerFlags)16) && !portalObject.passThroughNonTraversals;
				}
				__instance.shotgun.Fire(flag);
				component.Add();
				break;
			}
			case 2:
				((MonoBehaviour)__instance).StartCoroutine(SwordsMachineOverpump(__instance.shotgun.shootPoint.position, __instance.eid.totalDamageModifier, __instance));
				if (!__instance.gunDelay)
				{
					__instance.gunDelay = true;
					((MonoBehaviour)__instance).Invoke("ShootDelay", (float)Random.Range(2, 5) * 0.5f);
				}
				component.Add();
				component2.ResetAndRun();
				break;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SwordsMachine), "CheckToAttack")]
		public static bool CheckToAttackPrefix(SwordsMachine __instance)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.inAction || __instance.hasDimensionalTarget || !__instance.hasVision)
			{
				return false;
			}
			float num = Vector3.Distance(__instance.target.position, ((Component)__instance).transform.position);
			CounterInt component = ((Component)__instance).GetComponent<CounterInt>();
			TimerFloat component2 = ((Component)__instance).GetComponent<TimerFloat>();
			if (component.value != 2 || !component2.reached || num > 30f)
			{
				component.value = 1;
				return true;
			}
			if (!__instance.targetingStalker && Object.op_Implicit((Object)(object)__instance.shotgun) && __instance.shotgun.gunReady && !__instance.gunDelay && !__instance.shotgunning && (__instance.firstPhase || __instance.bothPhases))
			{
				AudioSourceExtensions.Play(((Component)((Component)__instance).transform.Find("PumpChargeObject")).GetComponent<AudioSource>(), true);
				BoolValue.Set("overpumping", newValue: true, ((Component)__instance).gameObject);
				__instance.shotgunning = true;
				__instance.anim.SetLayerWeight(1, 1f);
				__instance.anim.SetTrigger("Shoot");
				__instance.aimLerp = 0f;
				return false;
			}
			if (BoolValue.Get("overpumping", ((Component)__instance).gameObject).GetValueOrDefault())
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Enemy), "GetHurt")]
		public static void GetHurtPrefix(GameObject target, Vector3 force, ref float multiplier, float critMultiplier, Vector3 hurtPos, GameObject sourceWeapon, bool fromExplosion, Enemy __instance)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if (Util.IsHardMode() && (int)__instance.EID.enemyType == 7)
			{
				SwordsMachine sm = __instance.sm;
				if (sm == null || !sm.isEnraged)
				{
					multiplier *= 0.25f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Zombie))]
	public class ZombiePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZombieMelee), "Start")]
		public static void ZombieMeleeStartPostfix(ZombieMelee __instance)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Invalid comparison between Unknown and I4
			if (__instance.difficulty != 19 || __instance.eid.dead)
			{
				return;
			}
			float num = 1f;
			float num2 = 1f;
			float num3 = 1f;
			float num4 = 1f;
			float num5 = 1f;
			EnemyType enemyType = __instance.eid.enemyType;
			EnemyType val = enemyType;
			if ((int)val == 3)
			{
				if (!Util.IsHardMode())
				{
					num = 1.75f;
					num2 = 1.75f;
					num4 = 9000f;
					num5 = 240f;
					num3 = 20f * num;
				}
				else
				{
					num = 2f;
					num2 = 2f;
					num4 = 12000f;
					num5 = 400f;
					num3 = 20f * num;
				}
			}
			__instance.anim.speed = num2 * __instance.eid.totalSpeedModifier;
			__instance.nma.speed = num3 * __instance.eid.totalSpeedModifier;
			__instance.nma.angularSpeed = num4 * __instance.eid.totalSpeedModifier;
			__instance.nma.acceleration = num5 * __instance.eid.totalSpeedModifier;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZombieProjectiles), "Start")]
		public static void ZombieProjectilesStartPostfix(ZombieProjectiles __instance)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected I4, but got Unknown
			if (__instance.difficulty != 19 || __instance.eid.dead)
			{
				return;
			}
			float num = 1f;
			float num2 = 1f;
			float num3 = 1f;
			float num4 = 1f;
			float num5 = 1f;
			EnemyType enemyType = __instance.eid.enemyType;
			EnemyType val = enemyType;
			switch (val - 13)
			{
			case 0:
				if (!Util.IsHardMode())
				{
					num = 1.75f;
					num2 = 1.75f;
					num3 = 12.5f * num;
					num4 = 800f;
					num5 = 50f;
				}
				else
				{
					num = 2f;
					num2 = 2.5f;
					num3 = 17.5f * num;
					num4 = 1600f;
					num5 = 80f;
				}
				break;
			case 1:
				if (!Util.IsHardMode())
				{
					num = 1.75f;
					num2 = 1.5f;
					num3 = 12.5f * num;
					num4 = 800f;
					num5 = 50f;
				}
				else
				{
					num = 2f;
					num2 = 1.5f;
					num3 = 17.5f * num;
					num4 = 1600f;
					num5 = 80f;
				}
				break;
			case 2:
				if (!Util.IsHardMode())
				{
					num = 1.75f;
					num2 = 1.2f;
					num4 = 480f;
					num5 = 480f;
					float num6 = 1.2f * num;
					__instance.anim.SetFloat("RunSpeed", num6);
					num3 = 20f * num;
				}
				else
				{
					num = 2f;
					num2 = 1.35f;
					num4 = 600f;
					num5 = 560f;
					float num6 = 1.35f * num;
					__instance.anim.SetFloat("RunSpeed", num6);
					num3 = 24f * num;
				}
				break;
			}
			__instance.anim.speed = num2 * __instance.eid.totalSpeedModifier;
			__instance.nma.speed = num3 * __instance.eid.totalSpeedModifier;
			__instance.nma.angularSpeed = num4 * __instance.eid.totalSpeedModifier;
			__instance.nma.acceleration = num5 * __instance.eid.totalSpeedModifier;
		}
	}
	[HarmonyPatch(typeof(ZombieProjectiles))]
	public class ZombieProjectilesPatch
	{
		[CompilerGenerated]
		private sealed class <SoldierAttackDelay>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ZombieProjectiles __instance;

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

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

			[DebuggerHidden]
			public <SoldierAttackDelay>d__3(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.15f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					__instance.ThrowProjectile();
					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();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZombieProjectiles), "GetSpeed")]
		public static bool GetSpeedPrefix(int difficulty, ZombieProjectiles __instance, ref EnemyMovementData __result)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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)
			if (difficulty != 19)
			{
				return true;
			}
			float speed = 0f;
			float angularSpeed = 0f;
			float acceleration = 0f;
			EnemyType enemyType = __instance.eid.enemyType;
			EnemyType val = enemyType;
			if (val - 13 > 1)
			{
				if ((int)val == 15)
				{
					if (!Util.IsHardMode())
					{
						speed = 30.625f;
						angularSpeed = 480f;
						acceleration = 440f;
					}
					else
					{
						speed = 40f;
						angularSpeed = 600f;
						acceleration = 560f;
					}
				}
			}
			else if (!Util.IsHardMode())
			{
				speed = 21.875f;
				angularSpeed = 800f;
				acceleration = 50f;
			}
			else
			{
				speed = 35f;
				angularSpeed = 1600f;
				acceleration = 80f;
			}
			__result = new EnemyMovementData
			{
				speed = speed,
				angularSpeed = angularSpeed,
				acceleration = acceleration
			};
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZombieProjectiles), "Start")]
		public static void StartPostfix(ZombieProjectiles __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Invalid comparison between Unknown and I4
			if (__instance.difficulty != 19)
			{
				return;
			}
			if ((int)__instance.eid.enemyType == 13)
			{
				StrayAttack strayAttack = ((Component)__instance).gameObject.AddComponent<StrayAttack>();
				strayAttack.eid = __instance.eid;
				strayAttack.anim = __instance.anim;
				strayAttack.projectilesLeft = 0;
				if (!Util.IsHardMode())
				{
					strayAttack.animSpeedSlow = 1.75f;
					strayAttack.animSpeedFast = 4f;
				}
				else
				{
					strayAttack.animSpeedSlow = 2.5f;
					strayAttack.animSpeedFast = 6f;
				}
			}
			else if (Util.IsHardMode() && (int)__instance.eid.enemyType == 15)
			{
				__instance.projectile = Plugin.Prefabs["ProjectileHomingExplosive"];
				CounterInt counterInt = ((Component)__instance).gameObject.AddComponent<CounterInt>();
				counterInt.maxValue = 2;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZombieProjectiles), "ThrowProjectile")]
		public static void ThrowProjectilePostfix(ZombieProjectiles __instance, bool __runOriginal)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Invalid comparison between Unknown and I4
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19 || !__runOriginal)
			{
				return;
			}
			Projectile component = __instance.currentProjectile.GetComponent<Projectile>();
			if ((int)__instance.eid.enemyType == 13)
			{
				__instance.coolDownReduce = __instance.coolDown;
				component.speed = 90f;
				if (Util.IsHardMode())
				{
					component.speed = 90f;
					component.homingType = (HomingType)1;
					component.turningSpeedMultiplier = 0.7f;
				}
				StrayAttack component2 = ((Component)__instance).GetComponent<StrayAttack>();
				component2.projectilesLeft--;
				if (component2.projectilesLeft == 0)
				{
					if (!Util.IsHardMode())
					{
						__instance.coolDownReduce = 1.6f;
					}
					else
					{
						__instance.coolDownReduce = 1.2f;
					}
				}
			}
			if ((int)__instance.eid.enemyType != 15)
			{
				return;
			}
			component = __instance.currentProjectile.GetComponentInChildren<Projectile>();
			__instance.coolDownReduce = 2f;
			if (Util.IsHardMode())
			{
				__instance.coolDownReduce = 2.5f;
			}
			if (!Util.IsHardMode())
			{
				__instance.currentProjectile.transform.localScale = new Vector3(3f, 3f, 3f);
				ProjectileSpread component3 = __instance.currentProjectile.GetComponent<ProjectileSpread>();
				component3.projectileAmount = 8;
				component3.spreadAmount = 12f;
				component.speed = 82.5f;
				return;
			}
			component.bigExplosion = true;
			component.speed = 60f;
			component.ignoreExplosions = true;
			component.enemyDamageMultiplier = 0f;
			component.safeEnemyType = (EnemyType)15;
			component.homingType = (HomingType)4;
			component.turningSpeedMultiplier = 1f;
			component.stopTrackingAfterSeconds = 2f;
			((Component)component).GetComponent<RemoveOnTime>().time = 2.5f;
			CounterInt component4 = ((Component)__instance).GetComponent<CounterInt>();
			switch (component4.value)
			{
			case 1:
			{
				Projectile obj2 = component;
				obj2.speed -= 15f;
				break;
			}
			case 2:
			{
				Projectile obj = component;
				obj.speed += 15f;
				break;
			}
			}
			if (component4.value < 2)
			{
				component4.Add();
				((MonoBehaviour)__instance).StartCoroutine(SoldierAttackDelay(__instance));
			}
			else
			{
				component4.Add();
			}
		}

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

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZombieProjectiles), "Swing")]
		public static void SwingPrefix(ZombieProjectiles __instance)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			if (__instance.difficulty == 19 && (int)__instance.eid.enemyType == 13)
			{
				StrayAttack component = ((Component)__instance).GetComponent<StrayAttack>();
				if (component.projectilesLeft == 0)
				{
					component.projectilesLeft = 3;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZombieProjectiles), "Update")]
		public static void UpdatePostfix(ZombieProjectiles __instance)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			if (__instance.difficulty == 19 && (int)__instance.eid.enemyType == 13)
			{
				StrayAttack component = ((Component)__instance).GetComponent<StrayAttack>();
				if (__instance.anim.GetBool("Running"))
				{
					component.projectilesLeft = 0;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZombieProjectiles), "ShootProjectile")]
		public static void ShootProjectilePostfix(ZombieProjectiles __instance)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty == 19)
			{
				Projectile component = __instance.currentProjectile.GetComponent<Projectile>();
				component.speed = 60f;
				((Component)component).transform.localScale = new Vector3(1.5f, 1.5f, 1.5f);
				SlowDownOverTimeEase slowDownOverTimeEase = __instance.currentProjectile.AddComponent<SlowDownOverTimeEase>();
				slowDownOverTimeEase.slowRate = 0.15f;
				slowDownOverTimeEase.rateEase = 0.05f;
				slowDownOverTimeEase.makeUnparryableOnStop = true;
				slowDownOverTimeEase.changeColorOnStop = true;
				slowDownOverTimeEase.hasBeam = true;
				slowDownOverTimeEase.newProjectileColor = new Color(0.6f, 0.65f, 0f);
				slowDownOverTimeEase.volumeMultiplier = 0.8f;
				if (Util.IsHardMode())
				{
					slowDownOverTimeEase.reverseTimes = 5;
					component.ignoreEnvironment = true;
				}
				ChangeScaleOverTime changeScaleOverTime = __instance.currentProjectile.AddComponent<ChangeScaleOverTime>();
				changeScaleOverTime.delay = 5.25f;
				changeScaleOverTime.time = 1f;
				changeScaleOverTime.targetScaleMultiplier = 0f;
				RemoveOnTime component2 = __instance.currentProjectile.GetComponent<RemoveOnTime>();
				component2.time = 6.25f;
				if (Util.IsHardMode())
				{
					changeScaleOverTime.delay = 6.75f;
					component2.time = 7.75f;
				}
				LineRenderer componentInChildren = __instance.currentProjectile.GetComponentInChildren<LineRenderer>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.startWidth = 1.5f;
					componentInChildren.endWidth = 1.5f;
					changeScaleOverTime.scaleBeam = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ContinuousBeam), "Start")]
	public class ContinuousBeamPatch
	{
		public static void Postfix(ContinuousBeam __instance)
		{
			if (Util.IsHardMode())
			{
				SlowDownOverTimeEase component = ((Component)((Component)__instance).transform.parent).GetComponent<SlowDownOverTimeEase>();
				if ((Object)(object)component != (Object)null)
				{
					__instance.cancelIfEndPointBlocked = false;
					__instance.canHitEnemy = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZombieMelee))]
	public class ZombieMeleePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(ZombieMelee), "Start")]
		public static void StartPostfix(ZombieMelee __instance)
		{
			if (__instance.difficulty == 19)
			{
				__instance.defaultCoolDown = 0.2f;
				if (Util.IsHardMode())
				{
					__instance.mach.health = 1.5f;
					__instance.eid.health = 1.5f;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZombieMelee), "GetSpeed")]
		public static bool GetSpeedPrefix(int difficulty, ref EnemyMovementData __result)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (difficulty != 19)
			{
				return true;
			}
			if (!Util.IsHardMode())
			{
				__result = new EnemyMovementData
				{
					speed = 35f,
					acceleration = 240f,
					angularSpeed = 9000f
				};
				return false;
			}
			__result = new EnemyMovementData
			{
				speed = 40f,
				acceleration = 400f,
				angularSpeed = 12000f
			};
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZombieMelee), "Update")]
		public static bool UpdatePrefix(ZombieMelee __instance)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			if (__instance.diving)
			{
				((Component)__instance).transform.localRotation = Quaternion.identity;
				Transform modelTransform = __instance.modelTransform;
				Vector3 val = ((Component)__instance).transform.position + ((Component)__instance).transform.forward;
				Vector3 velocity = __instance.rb.velocity;
				modelTransform.LookAt(val + ((Vector3)(ref velocity)).normalized * 5f);
				__instance.modelTransform.Rotate(Vector3.right * 90f, (Space)1);
			}
			else
			{
				__instance.modelTransform.localRotation = Quaternion.identity;
				if (__instance.damaging)
				{
					__instance.rb.isKinematic = false;
					float num = 1f;
					if (__instance.difficulty >= 4)
					{
						num = 1.25f;
					}
					__instance.rb.velocity = ((Component)__instance).transform.forward * 40f * num * __instance.anim.speed;
				}
			}
			if (__instance.coolDown >= 0f)
			{
				__instance.coolDown = Mathf.MoveTowards(__instance.coolDown, 0f, 0.4f * Time.deltaTime * __instance.eid.totalSpeedModifier);
			}
			if (__instance.target == null)
			{
				return false;
			}
			__instance.UpdateTargetVision();
			if (__instance.track && __instance.hasVision)
			{
				if (__instance.difficulty > 1)
				{
					((Component)__instance).transform.LookAt(((EnemyScript)__instance).ToPlanePos(__instance.targetData.position));
				}
				else
				{
					float num2 = ((__instance.difficulty == 0) ? 360f : 720f);
					((Component)__instance).transform.rotation = Quaternion.RotateTowards(((Component)__instance).transform.rotation, Quaternion.LookRotation(((EnemyScript)__instance).ToPlanePos(__instance.targetData.position) - ((Component)__instance).transform.position), Time.deltaTime * num2 * __instance.eid.totalSpeedModifier);
				}
			}
			if (__instance.hasDimensionalTarget)
			{
				return false;
			}
			if (__instance.coolDown > 0f)
			{
				return false;
			}
			if (__instance.difficulty == 19 || (__instance.mach.grounded && !__instance.nma.isOnOffMeshLink && !__instance.mach.isTraversingPortalLink && !__instance.aboutToDive && !__instance.inAction && !__instance.damaging))
			{
				if (__instance.difficulty == 19)
				{
					__instance.coolDown = 0.1f;
				}
				if (Vector3.Distance(__instance.hasVision ? __instance.targetData.position : __instance.target.position, ((Component)__instance).transform.position) < __instance.swingDistance)
				{
					__instance.Swing();
					return false;
				}
				if (__instance.difficulty >= 4)
				{
					__instance.DiveCheck();
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZombieMelee), "DiveCheck")]
		public static bool DiveCheckPrefix(ZombieMelee __instance)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			float num = ((__instance.difficulty != 19) ? 20f : 17.5f);
			if (!__instance.hasVision || ((TargetData)(ref __instance.targetData)).DistanceTo(((Component)__instance).transform.position, false) > num)
			{
				return false;
			}
			__instance.diveTargetPos = __instance.targetData.position;
			if (__instance.diveTargetPos.y > ((Component)__instance).transform.position.y + 5f)
			{
				__instance.aboutToDive = true;
				if (__instance.difficulty == 19)
				{
					__instance.coolDown = 0.2f;
				}
				((MonoBehaviour)__instance).Invoke("JumpAttack", Random.Range(0f, 0.5f));
				return false;
			}
			if (((TargetData)(ref __instance.targetData)).DistanceTo(((Component)__instance).transform.position, false) > 10f && TimeSince.op_Implicit(__instance.randomJumpChanceCooldown) > 1f)
			{
				__instance.randomJumpChanceCooldown = TimeSince.op_Implicit(0f);
				if (Random.Range(0f, 1f) > 0.8f)
				{
					if (__instance.difficulty == 19)
					{
						__instance.coolDown = 0.2f;
					}
					__instance.JumpAttack();
				}
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZombieMelee), "JumpStart")]
		public static bool JumpPrefix(ZombieMelee __instance)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.difficulty != 19)
			{
				return true;
			}
			((Component)__instance).transform.LookAt(((EnemyScript)__instance).ToPlanePos(__instance.diveTargetPos));
			__instance.mach.Jump(((Component)__instance).transform.up * 25f + Vector3.ClampMagnitude(new Vector3((__instance.diveTargetPos.x - ((Component)__instance).transform.position.x) * 1.5f, 0f, (__instance.diveTargetPos.z - ((Component)__instance).transform.position.z) * 1.5f), 8f));
			Object.Instantiate<GameObject>(__instance.swingSound, ((Component)__instance).transform);
			__instance.diving = true;
			__instance.DamageStart();
			__instance.mach.ParryableCheck(false);
			((MonoBehaviour)__instance).Invoke("CheckThatJumpStarted", 1f);
			return false;
		}
	}
	[HarmonyPatch(typeof(EnemyIdentifier))]
	public class EnemyIdentifierHudMessagePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(EnemyIdentifier), "Start")]
		public static void StartPostfix(EnemyIdentifier __instance)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_018a: 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_0070: Invalid comparison between Unknown and I4
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			//IL_01ff: 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)
			if (__instance.difficulty != 19)
			{
				return;
			}
			GameObject val = GameObject.Find("BillionCustomHudMessages");
			if ((Object)(object)val == (Object)null)
			{
				val = new GameObject("BillionCustomHudMessages");
			}
			EnemyType enemyType = __instance.enemyType;
			EnemyType val2 = enemyType;
			if ((int)val2 <= 12)
			{
				if ((int)val2 != 2)
				{
					if ((int)val2 == 12)
					{
						Transform val3 = val.transform.Find("Stalker");
						if ((Object)(object)val3 == (Object)null)
						{
							val3 = new GameObject("Stalker").transform;
						}
						val3.SetParent(val.transform);
						if (!((Object)(object)((Component)val3).GetComponent<BoolValue>() != (Object)null))
						{
							BoolValue boolValue = ((Component)val3).gameObject.AddComponent<BoolValue>();
							boolValue.description = "shownMessage";
						}
					}
				}
				else
				{
					Transform val4 = val.transform.Find("Mass");
					if ((Object)(object)val4 == (Object)null)
					{
						val4 = new GameObject("Mass").transform;
					}
					val4.SetParent(val.transform);
					if (!((Object)(object)((Component)val4).GetComponent<BoolValue>() != (Object)null))
					{
						BoolValue boolValue2 = ((Component)val4).gameObject.AddComponent<BoolValue>();
						boolValue2.description = "shownMessage";
					}
				}
			}
			else if ((int)val2 != 21)
			{
				if ((int)val2 == 26)
				{
					Transform val5 = val.transform.Find("Ferryman");
					if ((Object)(object)val5 == (Object)null)
					{
						val5 = new GameObject("Ferryman").transform;
					}
					val5.SetParent(val.transform);
					if (!((Object)(object)((Component)val5).GetComponent<BoolValue>() != (Object)null))
					{
						BoolValue boolValue3 = ((Component)val5).gameObject.AddComponent<BoolValue>();
						boolValue3.description = "shownMessage";
					}
				}
			}
			else
			{
				Transform val6 = val.transform.Find("Idol");
				if ((Object)(object)val6 == (Object)null)
				{
					val6 = new GameObject("Idol").transform;
				}
				val6.SetParent(val.transform);
				if (!((Object)(object)((Component)val6).GetComponent<BoolValue>() != (Object)null))
				{
					BoolValue boolValue4 = ((Component)val6).gameObject.AddComponent<BoolValue>();
					boolValue4.description = "shownMessage";
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(EnemyIdentifier), "Update")]
		public static void UpdatePrefix(EnemyIdentifier __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Invalid comparison between Unknown and I4
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Invalid comparison between Unknown and I4
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Invalid comparison between Unknown and I4
			if (__instance.difficulty != 19 || __instance.dead)
			{
				return;
			}
			Transform transform = GameObject.Find("BillionCustomHudMessages").transform;
			if ((int)__instance.enemyType == 2 && SceneHelper.CurrentScene == "Level 1-3" && ((Object)((Component)__instance).transform.root).name == "Boss Arena")
			{
				GameObject gameObject = ((Component)transform.Find("Mass")).gameObject;
				if (BoolValue.Get("shownMessage", gameObject) == false)
				{
					HudMessage val = gameObject.AddComponent<HudMessage>();
					val.message = "<color=#aaccff>(Billion)</color> HM's hook can be destroyed with 1 Knuckleblaster punch";
					val.timed = true;
					val.timerTime = 5f;
					val.PlayMessage(false);
					BoolValue.Set("shownMessage", newValue: true, gameObject);
				}
			}
			else if ((int)__instance.enemyType == 12 && SceneHelper.CurrentScene == "Level 4-2" && ((Object)((Component)__instance).transform.root).name == "5 - Temple Entrance")
			{
				GameObject gameObject2 = ((Component)transform.Find("Stalker")).gameObject;
				if (BoolValue.Get("shownMessage", gameObject2) == false)
				{
					HudMessage val2 = gameObject2.AddComponent<HudMessage>();
					val2.message = "<color=#aaccff>(Billion)</color> Stalkers get overhealed when sanding enemies";
					val2.timed = true;
					val2.timerTime = 5f;
					val2.PlayMessage(false);
					BoolValue.Set("shownMessage", newValue: true, gameObject2);
				}
			}
			else if ((int)__instance.enemyType == 21 && SceneHelper.CurrentScene == "Level 5-2" && ((Object)((Component)__instance).transform.root).name == "3 - Ferryman's Cabin")
			{
				GameObject gameObject3 = ((Component)transform.Find("Idol")).gameObject;
				if (BoolValue.Get("shownMessage", gameObject3) == false)
				{
					HudMessage val3 = gameObject3.AddComponent<HudMessage>();
					val3.message = "<color=#aaccff>(Billion)</color> Idoled enemies overheal surrounding enemies";
					val3.timed = true;
					val3.timerTime = 7f;
					val3.PlayMessage(false);
					BoolValue.Set("shownMessage", newValue: true, gameObject3);
				}
			}
			else if ((int)__instance.enemyType == 26 && SceneHelper.CurrentScene == "Level 5-2" && ((Object)((Component)__instance).transform.root).name == "8 - Ship" && (Object)(object)((Component)__instance).GetComponent<FerrymanFake>() == (Object)null)
			{
				GameObject gameObject4 = ((Component)transform.Find("Ferryman")).gameObject;
				if (BoolValue.Get("shownMessage", gameObject4) == false)
				{
					HudMessage val4 = gameObject4.AddComponent<HudMessage>();
					val4.message = "<color=#aaccff>(Billion)</color> Ferrymen speed up over time";
					val4.timed = true;
					val4.timerTime = 5f;
					val4.PlayMessage(false);
					BoolValue.Set("shownMessage", newValue: true, gameObject4);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ObjectActivationCheck))]
	public class ObjectActivationCheckPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(ObjectActivationCheck), "StateChange")]
		public static void StateChangePostfix(ObjectActivationCheck __instance)
		{
			if (Util.IsDifficulty(19) && __instance.readyToActivate && SceneHelper.CurrentScene == "Level 4-2" && ((Object)((Component)__instance).transform.root).name == "7 - Boss Arena")
			{
				HudMessage val = ((Component)__instance).gameObject.AddComponent<HudMessage>();
				val.message = "<color=#aaccff>(Billion)</color> Dealing 30 damage to an Insurrectionist in 5 seconds makes them explode and temporarily enrage";
				val.timed = true;
				val.timerTime = 7f;
				val.PlayMessage(false);
			}
		}
	}
	public class AlternatingProjectileSplits : MonoBehaviour
	{
		public int maxLayer;

		public float projectileSpeed;

		public float projectileScaleMultiplier = 1f;

		public float cooldownMax = 0.125f;

		public float projectileSpeedIncreasePerLayer = 10f;

		public float projectileScaleIncreasePerLayer = 1.15f;

		public float rotationOffset = 12.5f;

		public bool keepFirstProjectile = true;

		public int currentLayer = 1;

		public GameObject proj;

		public Projectile projComp;

		public float cooldown = 0f;

		public void Start()
		{
			proj = ((Component)this).gameObject;
			projComp = proj.GetComponent<Projectile>();
		}

		public void Update()
		{
			cooldown += Time.deltaTime;
			if (cooldown < cooldownMax)
			{
				return;
			}
			cooldown = 0f;
			if (currentLayer < maxLayer)
			{
				bool flag = keepFirstProjectile && currentLayer == 1;
				if (!flag)
				{
					projComp.speed = 1f;
				}
				if (currentLayer % 2 == 1)
				{
					SplitOddLayer();
				}
				else
				{
					SplitEvenLayer();
				}
				if (!flag)
				{
					Object.Destroy((Object)(object)proj);
				}
				else
				{
					Object.Destroy((Object)(object)this);
				}
			}
		}

		public void SplitOddLayer()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			for (int i = 0; i < 4; i++)
			{
				switch (i)
				{
				case 0:
					((Vector3)(ref zero))..ctor(rotationOffset, 0f, 0f);
					break;
				case 1:
					((Vector3)(ref zero))..ctor(0f, rotationOffset, 0f);
					break;
				case 2:
					((Vector3)(ref zero))..ctor(0f - rotationOffset, 0f, 0f);
					break;
				case 3:
					((Vector3)(ref zero))..ctor(0f, 0f - rotationOffset, 0f);
					break;
				}
				CreateProjectile(zero);
			}
		}

		public void SplitEvenLayer()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			for (int i = 0; i < 4; i++)
			{
				switch (i)
				{
				case 0:
					((Vector3)(ref zero))..ctor(rotationOffset, rotationOffset, 0f);
					break;
				case 1:
					((Vector3)(ref zero))..ctor(0f - rotationOffset, rotationOffset, 0f);
					break;
				case 2:
					((Vector3)(ref zero))..ctor(0f - rotationOffset, 0f - rotationOffset, 0f);
					break;
				case 3:
					((Vector3)(ref zero))..ctor(rotationOffset, 0f - rotationOffset, 0f);
					break;
				}
				CreateProjectile(zero);
			}
		}

		public void CreateProjectile(Vector3 projectileRotation)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["Projectile"], ((Component)this).transform.position, ((Component)this).transform.rotation);
			Transform transform = val.transform;
			transform.localScale *= projectileScaleMultiplier * projectileScaleIncreasePerLayer;
			val.transform.Rotate(projectileRotation);
			Projectile component = val.GetComponent<Projectile>();
			component.speed = projectileSpeed + projectileScaleIncreasePerLayer;
			component.enemyDamageMultiplier = 0f;
			val.GetComponent<AudioSource>().volume = 0.5f * ((Component)this).GetComponent<AudioSource>().volume;
			if (currentLayer < maxLayer)
			{
				AlternatingProjectileSplits alternatingProjectileSplits = val.AddComponent<AlternatingProjectileSplits>();
				alternatingProjectileSplits.currentLayer = currentLayer + 1;
				alternatingProjectileSplits.maxLayer = maxLayer;
				alternatingProjectileSplits.projectileScaleMultiplier = projectileScaleMultiplier;
				alternatingProjectileSplits.projectileSpeed = projectileSpeed + projectileSpeedIncreasePerLayer;
				alternatingProjectileSplits.projectileSpeedIncreasePerLayer = projectileSpeedIncreasePerLayer;
				alternatingProjectileSplits.projectileScaleIncreasePerLayer = projectileScaleIncreasePerLayer * projectileScaleIncreasePerLayer;
			}
		}
	}
	internal class BillionExplosionController : MonoBehaviour
	{
		public float maxSizeMultiplier = 1f;

		public float speedMultiplier = 1f;

		public float enemyDamageMultiplier = 1f;

		public int damage = -1;

		public float damageMultiplier = 1f;

		public void Start()
		{
			maxSizeMultiplier = 1f;
			speedMultiplier = 1f;
			enemyDamageMultiplier = 1f;
			damage = -1;
			damageMultiplier = 1f;
		}
	}
	public class BlackHoleFromSisyphus : MonoBehaviour
	{
		public Sisyphus sisy = null;

		public void Update()
		{
			if ((Object)(object)sisy == (Object)null)
			{
				((Component)this).gameObject.GetComponent<BlackHoleProjectile>().Explode();
			}
		}
	}
	internal class ChangeScaleOverTime : MonoBehaviour
	{
		public float delay = 0f;

		public float targetScaleMultiplier;

		public float time;

		public float timeSinceStart;

		public Projectile proj;

		public Vector3 currentScale;

		public Vector3 initialScale;

		public Vector3 targetScale;

		public LineRenderer line;

		public bool scaleBeam = false;

		public float currentBeamScale;

		public float initialBeamScale;

		public float targetBeamScale;

		public void Start()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			proj = ((Component)this).GetComponent<Projectile>();
			line = ((Component)proj).GetComponentInChildren<LineRenderer>();
			currentScale = ((Component)proj).transform.localScale;
			initialScale = ((Component)proj).transform.localScale;
			targetScale = initialScale * targetScaleMultiplier;
			timeSinceStart = 0f;
			if (scaleBeam)
			{
				currentBeamScale = line.startWidth;
				initialBeamScale = line.startWidth;
				targetBeamScale = initialBeamScale * targetScaleMultiplier;
			}
		}

		public void Update()
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)line == (Object)null)
			{
				scaleBeam = false;
			}
			timeSinceStart += Time.deltaTime;
			if (!(timeSinceStart < delay))
			{
				float num = Mathf.MoveTowards(currentScale.x, targetScale.x, Time.deltaTime * Mathf.Abs(targetScale.x - initialScale.x) / time);
				float num2 = Mathf.MoveTowards(currentScale.y, targetScale.y, Time.deltaTime * Mathf.Abs(targetScale.y - initialScale.y) / time);
				float num3 = Mathf.MoveTowards(currentScale.z, targetScale.z, Time.deltaTime * Mathf.Abs(targetScale.z - initialScale.z) / time);
				((Component)proj).transform.localScale = new Vector3(num, num2, num3);
				currentScale = new Vector3(num, num2, num3);
				if (scaleBeam)
				{
					float num4 = Mathf.MoveTowards(currentBeamScale, targetBeamScale, Time.deltaTime * Mathf.Abs(targetBeamScale - initialBeamScale) / time);
					line.startWidth = num4;
					line.endWidth = num4;
					currentBeamScale = num4;
				}
			}
		}
	}
	internal class ProjectileHeightExplosion : MonoBehaviour
	{
		public float maxDistance = -1f;

		public EnemyTarget target;

		public Projectile proj;

		public void Start()
		{
			proj = ((Component)this).GetComponent<Projectile>();
		}

		public void Update()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (target != null && !(target.position.y > ((Component)this).transform.position.y))
			{
				float num = Vector3.Distance(target.position, ((Component)this).transform.position);
				bool flag = maxDistance > 0f && num <= maxDistance && num > maxDistance / 2f;
				if (maxDistance < 0f || flag)
				{
					proj.Explode();
				}
			}
		}
	}
	public class ProjectileSpeedStutter : MonoBehaviour
	{
		public float cooldownMax = 0.01f;

		public float cooldown = 0f;

		public float targetSpeedMultiplier;

		public float slowRate;

		public bool homing = false;

		public bool explodeWhenClose = false;

		public float explodeDistance;

		public int explodeStutterDelay;

		public int explodeStutterCounter = -2;

		public bool changeColor = false;

		public AudioSource audio = null;

		public Projectile proj;

		public float originalSpeed = -1f;

		public void Start()
		{
			//IL_001f: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			proj = ((Component)this).GetComponent<Projectile>();
			if (homing)
			{
				proj.homingType = (HomingType)4;
			}
			if (changeColor)
			{
				MeshRenderer[] componentsInChildren = ((Component)proj).GetComponentsInChildren<MeshRenderer>();
				MeshRenderer[] array = componentsInChildren;
				foreach (MeshRenderer val in array)
				{
					((Renderer)val).material.color = new Color(1f, 1f, 1f);
					((Renderer)val).material.renderQueue = 3000;
				}
				TrailRenderer component = ((Component)proj).GetComponent<TrailRenderer>();
				component.startColor = new Color(1f, 0.6902f, 0.0196f);
				component.endColor = new Color(1f, 1f, 0.0431f);
				Light component2 = ((Component)proj).GetComponent<Light>();
				component2.color = new Color(1f, 1f, 1f);
			}
		}

		public void Update()
		{
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: 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)
			if (proj.parried)
			{
				return;
			}
			if (homing)
			{
				proj.turnSpeed = 0f;
			}
			cooldown += Time.deltaTime;
			if (cooldown < cooldownMax)
			{
				return;
			}
			cooldown = 0f;
			if (proj.speed == originalSpeed && (Object)(object)audio != (Object)null)
			{
				AudioSourceExtensions.Play(audio, true);
			}
			if (proj.speed > originalSpeed * targetSpeedMultiplier)
			{
				Projectile obj = proj;
				obj.speed -= slowRate;
				return;
			}
			proj.speed = originalSpeed;
			if (homing)
			{
				proj.turningSpeedMultiplier = 100f;
			}
			if (!explodeWhenClose)
			{
				return;
			}
			float num = Vector3.Distance(((Component)MonoSingleton<NewMovement>.Instance).transform.position, ((Component)this).transform.position);
			if (explodeStutterCounter == -2 && num <= explodeDistance)
			{
				explodeStutterCounter = -1;
				return;
			}
			if (explodeStutterCounter >= -1 && changeColor)
			{
				MeshRenderer[] componentsInChildren = ((Component)proj).GetComponentsInChildren<MeshRenderer>();
				MeshRenderer[] array = componentsInChildren;
				foreach (MeshRenderer val in array)
				{
					Color color = ((Renderer)val).material.color;
					((Renderer)val).material.color = new Color(color.r - 1f / ((float)explodeStutterDelay + 1f), color.g, color.b);
					((Renderer)val).material.renderQueue = 3000;
				}
				TrailRenderer component = ((Component)proj).GetComponent<TrailRenderer>();
				Color startColor = component.startColor;
				Color endColor = component.endColor;
				component.startColor = new Color(startColor.r - 1f / ((float)explodeStutterDelay + 1f), startColor.g, startColor.b);
				component.endColor = new Color(endColor.r - 1f / ((float)explodeStutterDelay + 1f), endColor.g, endColor.b);
				Light component2 = ((Component)proj).GetComponent<Light>();
				Color color2 = component2.color;
				component2.color = new Color(color2.r - (float)(1 / (explodeStutterDelay + 1)), color2.g, color2.b);
			}
			if (explodeStutterCounter > explodeStutterDelay - 1)
			{
				proj.Explode();
			}
			else if (explodeStutterCounter >= -1 && explodeStutterCounter < explodeStutterDelay)
			{
				explodeStutterCounter++;
			}
		}
	}
	internal class RemoveOnRespawn : MonoBehaviour
	{
	}
	internal class ShockwaveOnExplode : MonoBehaviour
	{
		public float speed = 50f;

		public float damage = 25f;

		public float maxSize = 75f;

		public float height = 15f;

		public EnemyType enemyType;

		public float totalDamageModifier;

		public void SpawnShockwave(Vector3 position)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(Plugin.Prefabs["PhysicalShockwave"], position, Quaternion.identity);
			Vector3 localScale = val.transform.localScale;
			val.transform.localScale = new Vector3(localScale.x, height, localScale.z);
			PhysicalShockwave component = val.GetComponent<PhysicalShockwave>();
			component.speed = speed;
			component.damage = Mathf.RoundToInt(damage * totalDamageModifier);
			component.maxSize = maxSize;
			component.enemyType = enemyType;
			component.enemy = true;
		}
	}
	public class SlowDownOverTime : MonoBehaviour
	{
		public float slowRate;

		public float cooldownMax = 0.01f;

		public float cooldown = 0f;

		public bool stop = false;

		public Projectile proj;

		public void Start()
		{
			proj = ((Component)this).GetComponent<Projectile>();
		}

		public void Update()
		{
			if (proj.parried || stop)
			{
				return;
			}
			cooldown += Time.deltaTime;
			if (!(cooldown < cooldownMax))
			{
				cooldown = 0f;
				if (proj.speed > 0f)
				{
					Projectile obj = proj;
					obj.speed -= slowRate;
				}
				else
				{
					proj.speed = 0.001f;
					stop = true;
				}
			}
		}
	}
	public class SlowDownOverTimeEase : MonoBehaviour
	{
		public float slowRate;

		public float rateEase;

		public bool makeUnparryableOnStop = false;

		public bool changeColorOnStop = false;

		public bool hasBeam = false;

		public float volumeMultiplier = 1f;

		public Color newProjectileColor;

		public int reverseTimes = 0;

		public float cooldownMax = 0.01f;

		public float cooldown = 0f;

		public bool stop = false;

		public int currentReverseTimes = 1;

		public Projectile proj;

		public LineRenderer line;

		public float initialProjectileSpeed = 0f;

		public float initialSlowRate = 0f;

		public void Start()
		{
			proj = ((Component)this).GetComponent<Projectile>();
			line = ((Component)proj).GetComponentInChildren<LineRenderer>();
			initialProjectileSpeed = proj.speed;
			initialSlowRate = slowRate;
		}

		public void Update()
		{
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			if (proj.parried)
			{
				proj.ignoreEnvironment = false;
				return;
			}
			if ((Object)(object)line == (Object)null)
			{
				hasBeam = false;
			}
			if (stop)
			{
				return;
			}
			cooldown += Time.deltaTime;
			if (cooldown < cooldownMax)
			{
				return;
			}
			cooldown = 0f;
			if (proj.speed > 0f)
			{
				Projectile obj = proj;
				obj.speed -= slowRate;
				slowRate += rateEase;
				return;
			}
			proj.speed = 0.001f;
			proj.enemyDamageMultiplier = 0f;
			if (currentReverseTimes >= reverseTimes)
			{
				stop = true;
			}
			if (makeUnparryableOnStop)
			{
				proj.unparryable = true;
			}
			if (changeColorOnStop)
			{
				MeshRenderer[] componentsInChildren = ((Component)proj).GetComponentsInChildren<MeshRenderer>();
				MeshRenderer[] array = componentsInChildren;
				foreach (MeshRenderer val in array)
				{
					((Renderer)val).material.color = newProjectileColor;
				}
				if (hasBeam)
				{
					line.startColor = newProjectileColor;
					line.endColor = newProjectileColor;
				}
				Light component = ((Component)proj).GetComponent<Light>();
				if ((Object)(object)component != (Object)null)
				{
					component.color = newProjectileColor;
				}
			}
			if (volumeMultiplier != 1f)
			{
				AudioSource[] componentsInChildren2 = ((Component)proj).GetComponentsInChildren<AudioSource>();
				foreach (AudioSource val2 in componentsInChildren2)
				{
					val2.volume *= volumeMultiplier;
				}
			}
			if (currentReverseTimes < reverseTimes)
			{
				currentReverseTimes++;
				((Component)this).transform.Rotate(0f, 180f, 0f);
				slowRate = initialSlowRate;
				proj.speed = initialProjectileSpeed;
			}
		}
	}
	public class TimedRotator : MonoBehaviour
	{
		public float cooldownMax = 0.35f;

		public float angle = 45f;

		public Vector3 spinDirection = new Vector3(0f, 0f, 1f);

		public float cooldown = 0f;

		public void Update()
		{
			//IL_0044: 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)
			cooldown += Time.deltaTime;
			if (!(cooldown < cooldownMax))
			{
				cooldown = 0f;
				((Component)this).transform.Rotate(angle * ((Vector3)(ref spinDirection)).normalized, (Space)1);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}