using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using Configgy;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("v1yapper")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+ba864e6b88ebbf6f61405c5716c96da76be64dac")]
[assembly: AssemblyProduct("v1yapper")]
[assembly: AssemblyTitle("v1yapper")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace v1yapper
{
	[BepInPlugin("arandomdumbass.ultrakill.v1yapper", "V1 Yapper", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public enum v1voices
		{
			SAM
		}

		[HarmonyPatch(typeof(MenuEsc))]
		[HarmonyPatch("OnDisable")]
		public class Patch_Tutorial
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_006f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0079: Expected O, but got Unknown
					//IL_009a: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a4: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("VOCAL INTERFACE CONNECTED. ESTABLISHING CONNECTION WITH THINKING PROCESS");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("tutorial.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(6.5f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Well");
						<>2__current = (object)new WaitForSeconds(0.9f);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						Subtitle("Here I am");
						return false;
					}
				}

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

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

			private static void Postfix(MenuEsc __instance)
			{
				if (!(SceneHelper.CurrentScene != "Tutorial"))
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(ObjectActivator))]
		[HarmonyPatch("OnEnable")]
		public class Patch_idkwhatcausesthecerbcutscene
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0061: Unknown result type (might be due to invalid IL or missing references)
					//IL_006b: Expected O, but got Unknown
					//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c6: Expected O, but got Unknown
					//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f1: Expected O, but got Unknown
					//IL_0142: Unknown result type (might be due to invalid IL or missing references)
					//IL_014c: Expected O, but got Unknown
					//IL_016d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0177: Expected O, but got Unknown
					//IL_0198: Unknown result type (might be due to invalid IL or missing references)
					//IL_01a2: Expected O, but got Unknown
					//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
					//IL_01cd: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(0.2f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Huh, theres text on this door");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cerberus1.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(1.78f);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						Subtitle("Let me scan it for a second...");
						<>2__current = (object)new WaitForSeconds(2.25f);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cerberus2.wav");
						audio.Play();
						Subtitle("Damn");
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 4;
						return true;
					case 4:
						<>1__state = -1;
						Subtitle("This door's message is irrelevant");
						<>2__current = (object)new WaitForSeconds(2f);
						<>1__state = 5;
						return true;
					case 5:
						<>1__state = -1;
						Subtitle("Is there a way to get this thing open-");
						<>2__current = (object)new WaitForSeconds(1.95f);
						<>1__state = 6;
						return true;
					case 6:
						<>1__state = -1;
						Subtitle("Wait who the-");
						<>2__current = (object)new WaitForSeconds(0.45f);
						<>1__state = 7;
						return true;
					case 7:
						<>1__state = -1;
						Subtitle("God damn it, I have to fight for my life again");
						return false;
					}
				}

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

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

			private static void Postfix(ObjectActivator __instance)
			{
				if (SceneHelper.CurrentScene == "Level 0-5" && __instance.delay == 0f && !(((Object)((Component)__instance).gameObject).name != "Cube") && Object.op_Implicit((Object)(object)((Component)__instance).gameObject.GetComponent("ActivateArena")) && ((ConfigValueElement<bool>)(object)cerblinetoggle).Value)
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(ObjectActivator))]
		[HarmonyPatch("Activate", new Type[] { typeof(bool) })]
		public class Patch_Activations
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutineEartmover>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutineEartmover>d__2(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(1.25f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("It was about time you showed up");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("earthmoverintro.wav");
						audio.Play();
						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 <V1ResponseRoutineGun>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutineGun>d__1(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(1f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Gosh, it's filthy in here");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("preludeintro.wav");
						audio.Play();
						return false;
					}
				}

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

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

			private static void Postfix(ObjectActivator __instance)
			{
				if (((Object)((Component)__instance).gameObject).name == "Centaur Full")
				{
					if (!((ConfigValueElement<bool>)(object)earthlinetoggle).Value)
					{
						return;
					}
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineEartmover());
				}
				if (((Object)((Component)__instance).gameObject).name == "RevolverPickUp")
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineGun());
				}
			}

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

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

		[HarmonyPatch(typeof(V2))]
		[HarmonyPatch("Start")]
		public class Patch_V2
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0046: Unknown result type (might be due to invalid IL or missing references)
					//IL_0050: Expected O, but got Unknown
					//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ab: Expected O, but got Unknown
					//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00df: Expected O, but got Unknown
					//IL_0109: Unknown result type (might be due to invalid IL or missing references)
					//IL_0113: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(0.2f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Oh who do you think you are?");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2intro.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(1.78f);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						if (ishouldreallystopmakingthese)
						{
							Subtitle("A machine with a near identical design to me?");
						}
						<>2__current = (object)new WaitForSeconds(2.6f);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						if (ishouldreallystopmakingthese)
						{
							Subtitle("Well I wont tolerate that at all");
						}
						<>2__current = (object)new WaitForSeconds(1.7f);
						<>1__state = 4;
						return true;
					case 4:
						<>1__state = -1;
						if (ishouldreallystopmakingthese)
						{
							Subtitle("Time to settle this you dirty bootleg!");
						}
						return false;
					}
				}

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

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

			private static void Postfix(V2 __instance)
			{
				if (__instance.inIntro && ((ConfigValueElement<bool>)(object)v2linetoggle).Value)
				{
					ishouldreallystopmakingthese = true;
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(V2))]
		[HarmonyPatch("KnockedOut")]
		public class Patch_V2CoinCheeze
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0067: Unknown result type (might be due to invalid IL or missing references)
					//IL_0071: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						ishouldreallystopmakingthese = false;
						Subtitle("Your good at setting the tone");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("fuckyoulol.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(1.3f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("for someone in coin punching distance");
						return false;
					}
				}

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

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

			private static void Prefix(V2 __instance)
			{
				if (__instance.inIntro)
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(WeaponPickUp))]
		[HarmonyPatch("GotActivated")]
		public class Patch_WeaponPickups
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutineKnuckleblaster>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0061: Unknown result type (might be due to invalid IL or missing references)
					//IL_006b: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("Not sure if they knew they dropped this when escaping");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2armtake.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(3.55f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Oh well, its cool");
						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 <V1ResponseRoutineNailgun>d__3 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0061: Unknown result type (might be due to invalid IL or missing references)
					//IL_006b: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("Another toy to kill people with");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("nailgunpickup.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(2.4f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Wow!");
						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 <V1ResponseRoutineRocketLauncher>d__4 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0061: Unknown result type (might be due to invalid IL or missing references)
					//IL_006b: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("Haven't seen these things since my first test");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("rocketpickup.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(2.5f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Nice to have them back on my hands");
						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 <V1ResponseRoutineWhiplash>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0061: Unknown result type (might be due to invalid IL or missing references)
					//IL_006b: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("Such good potential put to waste");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2armtake2.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(2.1f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("and I know I wont put it to waste");
						return false;
					}
				}

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

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

			private static void Postfix(WeaponPickUp __instance)
			{
				if (((Object)__instance).name == "RedArmPickup" && SceneHelper.CurrentScene == "Level 1-4")
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineKnuckleblaster());
				}
				if (((Object)__instance).name == "RedArmPickup" && SceneHelper.CurrentScene == "Level 4-4")
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineWhiplash());
				}
				if (((Object)__instance).name == "ShotgunPickUp")
				{
					Subtitle("Ooh a new weapon!");
					audio.Stop();
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("shotgunpickup.wav");
					audio.Play();
				}
				if (((Object)__instance).name == "Weapon Pickup")
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineNailgun());
				}
				if (((Object)__instance).name == "Railcannon (1)")
				{
					Subtitle("Oh yeah thats the ticket!");
					audio.Stop();
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("railcannonpickup.wav");
					audio.Play();
				}
				if (((Object)__instance).name == "WeaponPickUp")
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutineRocketLauncher());
				}
			}

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

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

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

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

		[HarmonyPatch(typeof(SlowMo))]
		[HarmonyPatch("OnEnable")]
		public class Patch_ReconstructWHAT
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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(1f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Goodnight you sweet and ugly prince");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2die.wav");
						audio.Play();
						return false;
					}
				}

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

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

			private static void Postfix(SlowMo __instance)
			{
				if (((Object)__instance).name == "ToActivate" && SceneHelper.CurrentScene == "Level 4-4")
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(Animator))]
		[HarmonyPatch("Play", new Type[]
		{
			typeof(string),
			typeof(int),
			typeof(float)
		})]
		public class Patch_V22
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0055: Unknown result type (might be due to invalid IL or missing references)
					//IL_005f: Expected O, but got Unknown
					//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ba: Expected O, but got Unknown
					//IL_00db: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e5: Expected O, but got Unknown
					//IL_0106: Unknown result type (might be due to invalid IL or missing references)
					//IL_0110: Expected O, but got Unknown
					//IL_0131: Unknown result type (might be due to invalid IL or missing references)
					//IL_013b: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						specificvariablesothatv1doesnotrepeathimself = true;
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("You again?");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2intro2.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(0.97f);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						Subtitle("What?");
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						Subtitle("You want to get your little arm that I rightfully earned and stole from you?");
						<>2__current = (object)new WaitForSeconds(5.35f);
						<>1__state = 4;
						return true;
					case 4:
						<>1__state = -1;
						Subtitle("Well...");
						<>2__current = (object)new WaitForSeconds(0.95f);
						<>1__state = 5;
						return true;
					case 5:
						<>1__state = -1;
						Subtitle("Come and get it!");
						return false;
					}
				}

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

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

			private static void Postfix(Animator __instance)
			{
				if (!(((Object)((Component)__instance).gameObject).name != "v2_GreenArm") && !specificvariablesothatv1doesnotrepeathimself && ((ConfigValueElement<bool>)(object)v2linetoggle).Value)
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(V2))]
		[HarmonyPatch("InstaEnrage")]
		public class Patch_FuckYouV2
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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_008c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0096: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						audio.Stop();
						Subtitle("Why'd you do that?");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("v2enrage.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						Subtitle("Hahahaha");
						whyareyourepeatingenragevoicelinestopthat = 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();
				}
			}

			private static void Postfix(V2 __instance)
			{
				if (!audio.isPlaying && !whyareyourepeatingenragevoicelinestopthat)
				{
					whyareyourepeatingenragevoicelinestopthat = true;
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(HudMessage))]
		[HarmonyPatch("PlayMessage")]
		public class Patch_maxor
		{
			private static void Postfix(ref string ___message)
			{
				if (___message == "You're not getting away this time.")
				{
					audio.Stop();
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("yournotgettingawaythistime.wav");
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(SubtitledAudioSource))]
		[HarmonyPatch("OnEnable")]
		public class Patch_Gab1Intro1
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine2>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0046: Unknown result type (might be due to invalid IL or missing references)
					//IL_0050: Expected O, but got Unknown
					//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ab: Expected O, but got Unknown
					//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d6: Expected O, but got Unknown
					//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
					//IL_0101: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(2.5f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("I think I've heard of you");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel2.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(1.9f);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						Subtitle("Perhaps Archangel Gabriel?");
						<>2__current = (object)new WaitForSeconds(2.35f);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						Subtitle("No matter the less, you know whats coming");
						<>2__current = (object)new WaitForSeconds(2.9f);
						<>1__state = 4;
						return true;
					case 4:
						<>1__state = -1;
						Subtitle("and you will exchange with me");
						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 <V1ResponseRoutine3>d__3 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine3>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(2f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("And shall the angel's blood run red");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel3.wav");
						audio.Play();
						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 <V1ResponseRoutine4>d__4 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_0030: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Good morning, angel");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel21.wav");
						audio.Play();
						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 <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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(4.5f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Can't comply with that request as of now");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel1.wav");
						audio.Play();
						return false;
					}
				}

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

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

			private static void Postfix(SubtitledAudioSource __instance)
			{
				if (((ConfigValueElement<bool>)(object)gabelinetoggle).Value)
				{
					if (((Object)((Component)__instance).gameObject).name == "gab_Intro1")
					{
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
					}
					if (((Object)((Component)__instance).gameObject).name == "gab_Intro2")
					{
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine2());
					}
					if (((Object)((Component)__instance).gameObject).name == "gab_Intro3")
					{
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine3());
					}
					if (((Object)((Component)__instance).gameObject).name == "Speech" && !specificvariablesothatv1doesnotrepeathimself)
					{
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine4());
					}
				}
			}

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

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

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

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

		[HarmonyPatch(typeof(GabrielOutro))]
		[HarmonyPatch("Disappear")]
		public class Patch_Gab1Outro
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<>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_011f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0129: Expected O, but got Unknown
					//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
					//IL_00fe: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(2f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						audio.Stop();
						if (SceneHelper.CurrentScene == "Level 3-2")
						{
							Subtitle("I think that \"Gabriel\" guy has problems");
							audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel4.wav");
							audio.Play();
						}
						if (SceneHelper.CurrentScene == "Level 6-2")
						{
							audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel23.wav");
							audio.Play();
							Subtitle("Okay");
							<>2__current = (object)new WaitForSeconds(0.6f);
							<>1__state = 2;
							return true;
						}
						break;
					case 2:
						<>1__state = -1;
						Subtitle("STATUS UPDATE:");
						<>2__current = (object)new WaitForSeconds(1.35f);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						Subtitle("Mr \"Archangel Gabriel\" is not okay in the head");
						break;
					}
					return false;
				}

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

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

			private static void Postfix(GabrielIntro __instance)
			{
				((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
			}

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

		[HarmonyPatch(typeof(GabrielBase))]
		[HarmonyPatch("EnrageNow")]
		public class Patch_GabEnrage
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine2>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine2>d__2(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.25f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("I'd like to see you try");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel22.wav");
						audio.Play();
						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 <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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;
						Subtitle("Oh. Is baby archangel Gabriel getting a bit cranky now?");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabrieltaunt.wav");
						audio.Play();
						return false;
					}
				}

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

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

			private static void Postfix(GabrielBase __instance)
			{
				if (SceneHelper.CurrentScene == "Level 3-2")
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
				if (SceneHelper.CurrentScene == "Level 6-2")
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine2());
				}
			}

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

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

		[HarmonyPatch(typeof(GabrielBase))]
		[HarmonyPatch("UnEnrage")]
		public class Patch_GabUnenrage
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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;
						Subtitle("What the hell are you doing?");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("gabriel2taunt.wav");
						audio.Play();
						return false;
					}
				}

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

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

			private static void Postfix(GabrielBase __instance)
			{
				((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
			}

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

		[HarmonyPatch(typeof(AddStylePoints))]
		[HarmonyPatch("Activate")]
		public class Patch_EarthmoverOutro
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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(1f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Au revoir, vieil ami");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("earthmoveroutro.wav");
						audio.Play();
						return false;
					}
				}

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

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

			private static void Postfix(AddStylePoints __instance)
			{
				if (!(__instance.styleName != "RAISON D'ETRE"))
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(FleshPrison))]
		[HarmonyPatch("Start")]
		public class Patch_FleshIntro
		{
			private static void Postfix(FleshPrison __instance)
			{
				audio.Stop();
				if (!__instance.altVersion)
				{
					Subtitle("WHAT IN THE ACTUAL FUCK IS THAT THING?!");
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("flesh1.wav");
				}
				else
				{
					Subtitle("OH GOOD LORD");
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("flesh2.wav");
				}
				audio.Play();
			}
		}

		[HarmonyPatch(typeof(MinosPrime))]
		[HarmonyPatch("Start")]
		public class Patch_MPIntro
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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.25f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("And yet it will be your punishment aswell");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("minosintro.wav");
						audio.Play();
						return false;
					}
				}

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

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

			private static void Postfix(MinosPrime __instance)
			{
				Traverse val = Traverse.Create((object)__instance);
				if (!val.Field("bossVersion").GetValue().Equals(false))
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(MinosPrime))]
		[HarmonyPatch("OutroEnd")]
		public class Patch_MPOutro
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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_008c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0096: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Goodnight, Minos");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("minosoutro.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(1.75f);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						Subtitle("You put up a good fight for someone who died as the king of lust");
						return false;
					}
				}

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

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

			private static void Postfix(MinosPrime __instance)
			{
				Traverse val = Traverse.Create((object)__instance);
				if (!val.Field("bossVersion").GetValue().Equals(false))
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(SisyphusPrime))]
		[HarmonyPatch("Start")]
		public class Patch_SPIntro
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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.25f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("OH GOD OH FUCK WAIT NONONONONO, I DONT WANT TO FIGHT YOU I JUST WANTED SOME BLOOD PLEASE GOD NO");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("sisyintro.wav");
						audio.Play();
						return false;
					}
				}

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

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

			private static void Postfix(SisyphusPrime __instance)
			{
				Traverse val = Traverse.Create((object)__instance);
				if (!val.Field("bossVersion").GetValue().Equals(false))
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(SisyphusPrime))]
		[HarmonyPatch("OutroEnd")]
		public class Patch_SPOutro
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					//IL_004f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0059: Expected O, but got Unknown
					//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b4: Expected O, but got Unknown
					//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00df: Expected O, but got Unknown
					//IL_0100: Unknown result type (might be due to invalid IL or missing references)
					//IL_010a: Expected O, but got Unknown
					//IL_012b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0135: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("Honestly");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("sisyoutro.wav");
						audio.Play();
						<>2__current = (object)new WaitForSeconds(0.85f);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						Subtitle("That guy");
						<>2__current = (object)new WaitForSeconds(0.75f);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -1;
						Subtitle("Sisyphus?");
						<>2__current = (object)new WaitForSeconds(0.85f);
						<>1__state = 4;
						return true;
					case 4:
						<>1__state = -1;
						Subtitle("I dont like him");
						<>2__current = (object)new WaitForSeconds(1.5f);
						<>1__state = 5;
						return true;
					case 5:
						<>1__state = -1;
						Subtitle("Fuck him");
						return false;
					}
				}

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

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

			private static void Postfix(SisyphusPrime __instance)
			{
				Traverse val = Traverse.Create((object)__instance);
				if (!val.Field("bossVersion").GetValue().Equals(false))
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(LevelNameActivator))]
		[HarmonyPatch("Start")]
		public class Patch_disintergrationloop
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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.25f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("What the fuck?");
						audio.Stop();
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("wtf.wav");
						audio.Play();
						return false;
					}
				}

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

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

			private static void Postfix(LevelNameActivator __instance)
			{
				if (!(SceneHelper.CurrentScene != "Level 8-3"))
				{
					((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
				}
			}

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

		[HarmonyPatch(typeof(HellMap))]
		[HarmonyPatch("Start")]
		public class Patch_LevelEnter
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("Must nothing stop me");
						<>2__current = (object)new WaitForSeconds(1.6f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("I need to keep going");
						return false;
					}
				}

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

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

			private static void Postfix(HellMap __instance)
			{
				specificvariablesothatv1doesnotrepeathimself = false;
				anotherspecificvarfor2ndgabfight = false;
				Log.LogInfo((object)SceneHelper.CurrentScene);
				if (SceneHelper.CurrentScene == "uk_construct" || SceneHelper.CurrentScene == "Level 0-S" || SceneHelper.CurrentScene == "Level 1-S" || SceneHelper.CurrentScene == "Level 4-S" || SceneHelper.CurrentScene == "Level 5-S" || SceneHelper.CurrentScene == "Level 7-S" || SceneHelper.CurrentScene == "Level 8-S")
				{
					Subtitle("Lets take a look");
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("secretlevel.wav");
				}
				else if (SceneHelper.CurrentScene == "Endless")
				{
					int num = Random.Range(1, 5);
					if (num == 1)
					{
						Subtitle("Oh boy");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cybergrind1.wav");
					}
					if (num == 2)
					{
						Subtitle("Training time");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cybergrind2.wav");
					}
					if (num == 3)
					{
						Subtitle("Can I reach a new high though?");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cybergrind3.wav");
					}
					if (num == 4)
					{
						Subtitle("Sometimes I just need a break from all this");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("cybergrind4.wav");
					}
				}
				else
				{
					int num2 = Random.Range(1, 11);
					if (num2 == 1)
					{
						Subtitle("Still going...");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("There needs to be more for me");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("What do we have in store today?");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend3.wav");
					}
					if (num2 == 4)
					{
						Subtitle("I starve for more");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend4.wav");
					}
					if (num2 == 5)
					{
						Subtitle("Already?");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend5.wav");
					}
					if (num2 == 6)
					{
						Subtitle("Again?");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend6.wav");
					}
					if (num2 == 7)
					{
						Subtitle("No longer can I keep sleep");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend7.wav");
					}
					if (num2 == 8)
					{
						Subtitle("I just might get there");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend8.wav");
					}
					if (num2 == 9)
					{
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend9.wav");
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
					}
					if (num2 == 10)
					{
						Subtitle("Sometimes I dream of eternal sleep");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("descend10.wav");
					}
				}
				audio.Play();
			}

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

		[HarmonyPatch(typeof(StyleHUD))]
		[HarmonyPatch("AscendRank")]
		public class Patch_ULTRAKILL
		{
			private static void Postfix(StyleHUD __instance)
			{
				if (__instance.rankIndex != 7 || audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, 6);
				if (num == 1)
				{
					if (((ConfigValueElement<bool>)(object)colortoggle).Value)
					{
						MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("<color=#0464ff>I cannot be stopped. You will all be</color> <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
					}
					else
					{
						MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("I cannot be stopped. You will all be <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
					}
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ultrakill1.wav");
				}
				if (num == 2)
				{
					if (((ConfigValueElement<bool>)(object)colortoggle).Value)
					{
						MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("<color=#0464ff>You. Have. Been.</color> <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
					}
					else
					{
						MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("You. Have. Been. <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
					}
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ultrakill2.wav");
				}
				if (num == 3)
				{
					if (((ConfigValueElement<bool>)(object)colortoggle).Value)
					{
						MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("<color=#0464ff>Have you not learned a single thing? In this world it's </color><color=#ff0000>ULTRAKILL</color><color=#0464ff> or BE </color><color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
					}
					else
					{
						MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("Have you not learned a single thing? In this world it's  <color=#ff0000>ULTRAKILL</color> or BE <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
					}
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ultrakill3.wav");
				}
				if (num == 4)
				{
					if (((ConfigValueElement<bool>)(object)colortoggle).Value)
					{
						MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("<color=#ff0000>ULTRAKILLING </color><color=#0464ff>Style!</color>", (AudioSource)null, false);
					}
					else
					{
						MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("<color=#ff0000>ULTRAKILLING </color>Style!", (AudioSource)null, false);
					}
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ultrakill4.wav");
				}
				if (num == 5)
				{
					if (((ConfigValueElement<bool>)(object)colortoggle).Value)
					{
						MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("<color=#0464ff>Looks like someone just got </color><color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
					}
					else
					{
						MonoSingleton<SubtitleController>.Instance.DisplaySubtitle("Looks like someone just got <color=#ff0000>ULTRAKILLED</color>", (AudioSource)null, false);
					}
					audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ultrakill5.wav");
				}
				audio.Play();
			}
		}

		[HarmonyPatch(typeof(NewMovement))]
		[HarmonyPatch("TryDash")]
		public class Patch_Dash
		{
			private static void Postfix(NewMovement __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)dashlinechance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 6);
					if (num2 == 1)
					{
						Subtitle("Vroom!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("dash1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Yikes!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("dash2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("Whoosh");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("dash3.wav");
					}
					if (num2 == 4)
					{
						Subtitle("Relocating");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("dash4.wav");
					}
					if (num2 == 5)
					{
						Subtitle("Adjusting");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("dash5.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(NewMovement))]
		[HarmonyPatch("TryStartSlam")]
		public class Patch_Slam
		{
			private static void Postfix(NewMovement __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)slamlinechance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 6);
					if (num2 == 1)
					{
						Subtitle("Incoming");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("slam1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Here I come");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("slam2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("Slam!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("slam3.wav");
					}
					if (num2 == 4)
					{
						Subtitle("Look out below");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("slam4.wav");
					}
					if (num2 == 5)
					{
						Subtitle("My spot");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("slam5.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(PlayOnAwakeTracker))]
		[HarmonyPatch("OnEnable")]
		public class Patch_DashJump
		{
			private static void Postfix(PlayOnAwakeTracker __instance)
			{
				if (!((Object)((Component)__instance).gameObject).name.Contains("DashJumpSound") || audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)dashjumplinechance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 4);
					if (num2 == 1)
					{
						Subtitle("Weeeeee!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ssj1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Covering long distance");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ssj2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("Gotta move");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ssj3.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(NewMovement))]
		[HarmonyPatch("Parry")]
		public class Patch_Parry
		{
			private static void Postfix(NewMovement __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)parrylinechance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 6);
					if (num2 == 1)
					{
						Subtitle("Nuh uh!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("parry1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Parry!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("parry2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("Denied");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("parry3.wav");
					}
					if (num2 == 4)
					{
						Subtitle("Too bad");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("parry4.wav");
					}
					if (num2 == 5)
					{
						Subtitle("Back to you");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("parry5.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(NewMovement))]
		[HarmonyPatch("GetHurt")]
		public class Patch_Hurt
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine2>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine2>d__2(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
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("YOU CANT...");
						<>2__current = (object)new WaitForSeconds(1.2f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("I CANT...");
						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 <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("JUST...");
						<>2__current = (object)new WaitForSeconds(0.95f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("LET ME BE...");
						return false;
					}
				}

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

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

			private static void Postfix(NewMovement __instance)
			{
				if (__instance.dead)
				{
					audio.Stop();
					return;
				}
				int num = 0;
				num = ((__instance.hp >= 35) ? Random.Range(1, ((ConfigValueElement<int>)(object)hurtlinechance).Value + 1) : Random.Range(1, ((ConfigValueElement<int>)(object)crithurtlinechance).Value + 1));
				if (num != 1 || audio.isPlaying)
				{
					return;
				}
				int num2 = Random.Range(1, 6);
				if (__instance.hp < 35)
				{
					if (num2 == 1)
					{
						Subtitle("STOP IT...");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("lowhphurt1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("WHAT ARE YOU DOING...?");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("lowhphurt2.wav");
					}
					if (num2 == 3)
					{
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("lowhphurt3.wav");
					}
					if (num2 == 4)
					{
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine2());
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("lowhphurt4.wav");
					}
					if (num2 == 5)
					{
						Subtitle("NOT YET...");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("lowhphurt5.wav");
					}
				}
				else
				{
					if (num2 == 1)
					{
						Subtitle("Ow! You bitch!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("hurt1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Stop trying");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("hurt2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("My god, just die already");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("hurt3.wav");
					}
					if (num2 == 4)
					{
						Subtitle("Oh... That didn't feel very good");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("hurt4.wav");
					}
					if (num2 == 5)
					{
						Subtitle("No, no, Stop it");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("hurt5.wav");
					}
				}
				audio.Play();
			}

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

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

		[HarmonyPatch(typeof(Punch))]
		[HarmonyPatch("ForceHold")]
		public class Patch_Pickup
		{
			private static void Postfix(Punch __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)pickupchance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 4);
					if (num2 == 1)
					{
						Subtitle("This'll do");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pickup1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("I'll be taking that");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pickup2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("This'll come in handy");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pickup3.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(Punch))]
		[HarmonyPatch("CoinFlip")]
		public class Patch_Coinflip
		{
			private static void Postfix(Punch __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)coinchance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 6);
					if (num2 == 1)
					{
						Subtitle("Here's some payment");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("coin1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Watch out");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("coin2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("Take bit of this");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("coin3.wav");
					}
					if (num2 == 4)
					{
						Subtitle("Raining some money");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("coin4.wav");
					}
					if (num2 == 5)
					{
						Subtitle("You deserve some of this!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("coin5.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(Shotgun))]
		[HarmonyPatch("ShootSaw", new Type[] { })]
		public class Patch_Saw
		{
			private static void Postfix(Shotgun __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)sawchance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 4);
					if (num2 == 1)
					{
						Subtitle("I hope you went to the dentist");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Just a bit of this too");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("Meet my pal");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw3.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(Shotgun))]
		[HarmonyPatch("Pump", new Type[] { })]
		public class Patch_Pump
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine2>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine2>d__2(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
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("You aren't getting out of my target value");
						<>2__current = (object)new WaitForSeconds(2f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("You fucking blood canister");
						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 <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("I will shit fury all over you");
						<>2__current = (object)new WaitForSeconds(1.45f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("and you will drown in it");
						return false;
					}
				}

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

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

			private static void Postfix(Shotgun __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)pumpchance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 6);
					if (num2 == 1)
					{
						Subtitle("Oh i'm gonna fuck your face so hard your brains will shit itself all over the place");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("I'm gonna make you feel my wrath, fucker");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump2.wav");
					}
					if (num2 == 3)
					{
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump3.wav");
						Subtitle("I'm gonna send you back to being a unmoving bitch");
					}
					if (num2 == 4)
					{
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump4.wav");
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
					}
					if (num2 == 5)
					{
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump5.wav");
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine2());
					}
					audio.Play();
				}
			}

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

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

		[HarmonyPatch(typeof(ShotgunHammer))]
		[HarmonyPatch("ShootSaw", new Type[] { })]
		public class Patch_Saw2
		{
			private static void Postfix(Shotgun __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)sawchance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 4);
					if (num2 == 1)
					{
						Subtitle("I hope you went to the dentist");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Just a bit of this too");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("Meet my pal");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("saw3.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(ShotgunHammer))]
		[HarmonyPatch("Pump", new Type[] { })]
		public class Patch_Pump2
		{
			[CompilerGenerated]
			private sealed class <V1ResponseRoutine2>d__2 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine2>d__2(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
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("You aren't getting out of my target value");
						<>2__current = (object)new WaitForSeconds(2f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("You fucking blood canister");
						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 <V1ResponseRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

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

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

				[DebuggerHidden]
				public <V1ResponseRoutine>d__1(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
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						Subtitle("I will shit fury all over you");
						<>2__current = (object)new WaitForSeconds(1.45f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						Subtitle("and you will drown in it");
						return false;
					}
				}

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

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

			private static void Postfix(Shotgun __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)pumpchance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 6);
					if (num2 == 1)
					{
						Subtitle("Oh i'm gonna fuck your face so hard your brains will shit itself all over the place");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("I'm gonna make you feel my wrath, fucker");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump2.wav");
					}
					if (num2 == 3)
					{
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump3.wav");
						Subtitle("I'm gonna send you back to being a unmoving bitch");
					}
					if (num2 == 4)
					{
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump4.wav");
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine());
					}
					if (num2 == 5)
					{
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("pump5.wav");
						((MonoBehaviour)me).StartCoroutine(V1ResponseRoutine2());
					}
					audio.Play();
				}
			}

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

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

		[HarmonyPatch(typeof(Railcannon))]
		[HarmonyPatch("OnEnable", new Type[] { })]
		public class Patch_Railcannon
		{
			private static void Postfix(Railcannon __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)railchance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 5);
					if (num2 == 1)
					{
						Subtitle("Stand still...");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("railcannon1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Suprise!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("railcannon2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("More firepower is required");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("railcannon3.wav");
					}
					if (num2 == 4)
					{
						Subtitle("You'll make a fine meal");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("railcannon4.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(RocketLauncher))]
		[HarmonyPatch("FreezeRockets")]
		public class Patch_RLFreeze
		{
			private static void Postfix(RocketLauncher __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)freezechance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 4);
					if (num2 == 1)
					{
						Subtitle("Hold...");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("freeze1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Wait...");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("freeze2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("Just give me a break...");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("freeze3.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(RocketLauncher))]
		[HarmonyPatch("UnfreezeRockets")]
		public class Patch_RLUnFreeze
		{
			private static void Postfix(RocketLauncher __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)freezechance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 4);
					if (num2 == 1)
					{
						Subtitle("All done");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("unfreeze1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Continue");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("unfreeze2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("Breaks over");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("unfreeze3.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(RocketLauncher))]
		[HarmonyPatch("ShootCannonball")]
		public class Patch_RLCannonball
		{
			private static void Postfix(RocketLauncher __instance)
			{
				if (audio.isPlaying)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)deezballschance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 4);
					if (num2 == 1)
					{
						Subtitle("Time out");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ball1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Play ball!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ball2.wav");
					}
					if (num2 == 3)
					{
						Subtitle("Now lets play");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("ball3.wav");
					}
					audio.Play();
				}
			}
		}

		[HarmonyPatch(typeof(Punch))]
		[HarmonyPatch("ParryProjectile")]
		public class Patch_Boost
		{
			private static void Postfix(Projectile proj)
			{
				if (audio.isPlaying || !proj.boosted)
				{
					return;
				}
				int num = Random.Range(1, ((ConfigValueElement<int>)(object)pjboostchance).Value + 1);
				if (num == 1)
				{
					int num2 = Random.Range(1, 6);
					if (num2 == 1)
					{
						Subtitle("Bet you cant do this!");
						audio.clip = V1AssetBundle.LoadAsset<AudioClip>("boost1.wav");
					}
					if (num2 == 2)
					{
						Subtitle("Ex