Decompiled source of MMHOOK v1.0.0

MMHOOK_Assembly-UnityScript.dll

Decompiled 2 hours ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;
using Boo.Lang;
using MonoMod.Cil;
using MonoMod.RuntimeDetour.HookGen;
using On;
using UnityEngine;

[assembly: AssemblyVersion("0.0.0.0")]
namespace On
{
	public static class Deatha
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(Deatha self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, Deatha self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Start(Deatha self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Start(orig_Start orig, Deatha self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Main(Deatha self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Main(orig_Main orig, Deatha self);

		public static class $Start$1127
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<WaitForSeconds> self, Deatha self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<WaitForSeconds> self, Deatha self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> orig_GetEnumerator(GenericGenerator<WaitForSeconds> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<WaitForSeconds> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<WaitForSeconds> self, Deatha self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<WaitForSeconds> self, Deatha self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<WaitForSeconds> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<WaitForSeconds> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
		}

		public static event hook_Main Main
		{
			add
			{
				HookEndpointManager.Add<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
		}
	}
}
namespace IL
{
	public static class Deatha
	{
		public static class $Start$1127
		{
			public static class $
			{
				public static event Manipulator ctor
				{
					add
					{
						HookEndpointManager.Modify<On.Deatha.$Start$1127.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.Deatha.$Start$1127.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}

				public static event Manipulator MoveNext
				{
					add
					{
						HookEndpointManager.Modify<On.Deatha.$Start$1127.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.Deatha.$Start$1127.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}
			}

			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.Deatha.$Start$1127.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.Deatha.$Start$1127.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}

			public static event Manipulator GetEnumerator
			{
				add
				{
					HookEndpointManager.Modify<On.Deatha.$Start$1127.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.Deatha.$Start$1127.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.Deatha.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.Deatha.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.Deatha.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.Deatha.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Main
		{
			add
			{
				HookEndpointManager.Modify<On.Deatha.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.Deatha.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}
	}
}
namespace On
{
	public static class FireParticles4
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(FireParticles4 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, FireParticles4 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(FireParticles4 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, FireParticles4 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Main(FireParticles4 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Main(orig_Main orig, FireParticles4 self);

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Update);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Update);
			}
		}

		public static event hook_Main Main
		{
			add
			{
				HookEndpointManager.Add<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
		}
	}
}
namespace IL
{
	public static class FireParticles4
	{
		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.FireParticles4.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.FireParticles4.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.FireParticles4.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.FireParticles4.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Main
		{
			add
			{
				HookEndpointManager.Modify<On.FireParticles4.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.FireParticles4.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}
	}
}
namespace On
{
	public static class txtAltar
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(txtAltar self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, txtAltar self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(txtAltar self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, txtAltar self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Set(txtAltar self, int a);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Set(orig_Set orig, txtAltar self, int a);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Main(txtAltar self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Main(orig_Main orig, txtAltar self);

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
		}

		public static event hook_Set Set
		{
			add
			{
				HookEndpointManager.Add<hook_Set>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Set);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Set>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Set);
			}
		}

		public static event hook_Main Main
		{
			add
			{
				HookEndpointManager.Add<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
		}
	}
}
namespace IL
{
	public static class txtAltar
	{
		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.txtAltar.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.txtAltar.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.txtAltar.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.txtAltar.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Set
		{
			add
			{
				HookEndpointManager.Modify<On.txtAltar.hook_Set>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.txtAltar.hook_Set>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Main
		{
			add
			{
				HookEndpointManager.Modify<On.txtAltar.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.txtAltar.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}
	}
}
namespace On
{
	public static class PoisonParent
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(PoisonParent self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, PoisonParent self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(PoisonParent self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, PoisonParent self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Exile(PoisonParent self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Exile(orig_Exile orig, PoisonParent self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Main(PoisonParent self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Main(orig_Main orig, PoisonParent self);

		public static class $Exile$1130
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<WaitForSeconds> self, PoisonParent self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<WaitForSeconds> self, PoisonParent self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> orig_GetEnumerator(GenericGenerator<WaitForSeconds> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<WaitForSeconds> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<WaitForSeconds> self, PoisonParent self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<WaitForSeconds> self, PoisonParent self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<WaitForSeconds> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<WaitForSeconds> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
		}

		public static event hook_Exile Exile
		{
			add
			{
				HookEndpointManager.Add<hook_Exile>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Exile);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Exile>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Exile);
			}
		}

		public static event hook_Main Main
		{
			add
			{
				HookEndpointManager.Add<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
		}
	}
}
namespace IL
{
	public static class PoisonParent
	{
		public static class $Exile$1130
		{
			public static class $
			{
				public static event Manipulator ctor
				{
					add
					{
						HookEndpointManager.Modify<On.PoisonParent.$Exile$1130.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.PoisonParent.$Exile$1130.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}

				public static event Manipulator MoveNext
				{
					add
					{
						HookEndpointManager.Modify<On.PoisonParent.$Exile$1130.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.PoisonParent.$Exile$1130.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}
			}

			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.PoisonParent.$Exile$1130.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.PoisonParent.$Exile$1130.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}

			public static event Manipulator GetEnumerator
			{
				add
				{
					HookEndpointManager.Modify<On.PoisonParent.$Exile$1130.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.PoisonParent.$Exile$1130.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.PoisonParent.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.PoisonParent.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.PoisonParent.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.PoisonParent.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Exile
		{
			add
			{
				HookEndpointManager.Modify<On.PoisonParent.hook_Exile>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.PoisonParent.hook_Exile>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Main
		{
			add
			{
				HookEndpointManager.Modify<On.PoisonParent.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.PoisonParent.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}
	}
}
namespace On
{
	public static class HazTrig
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(HazTrig self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, HazTrig self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnTriggerEnter(HazTrig self, Collider c);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnTriggerEnter(orig_OnTriggerEnter orig, HazTrig self, Collider c);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SetH(HazTrig self, int a);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SetH(orig_SetH orig, HazTrig self, int a);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SetHH(HazTrig self, int a);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SetHH(orig_SetHH orig, HazTrig self, int a);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Main(HazTrig self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Main(orig_Main orig, HazTrig self);

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
		}

		public static event hook_OnTriggerEnter OnTriggerEnter
		{
			add
			{
				HookEndpointManager.Add<hook_OnTriggerEnter>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_OnTriggerEnter);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnTriggerEnter>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_OnTriggerEnter);
			}
		}

		public static event hook_SetH SetH
		{
			add
			{
				HookEndpointManager.Add<hook_SetH>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_SetH);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SetH>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_SetH);
			}
		}

		public static event hook_SetHH SetHH
		{
			add
			{
				HookEndpointManager.Add<hook_SetHH>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_SetHH);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SetHH>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_SetHH);
			}
		}

		public static event hook_Main Main
		{
			add
			{
				HookEndpointManager.Add<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
		}
	}
}
namespace IL
{
	public static class HazTrig
	{
		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.HazTrig.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.HazTrig.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator OnTriggerEnter
		{
			add
			{
				HookEndpointManager.Modify<On.HazTrig.hook_OnTriggerEnter>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.HazTrig.hook_OnTriggerEnter>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator SetH
		{
			add
			{
				HookEndpointManager.Modify<On.HazTrig.hook_SetH>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.HazTrig.hook_SetH>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator SetHH
		{
			add
			{
				HookEndpointManager.Modify<On.HazTrig.hook_SetHH>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.HazTrig.hook_SetHH>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Main
		{
			add
			{
				HookEndpointManager.Modify<On.HazTrig.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.HazTrig.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}
	}
}
namespace On
{
	public static class MerchantScript
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Awake(MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Awake(orig_Awake orig, MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Knock22(MerchantScript self, Vector3 a);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Knock22(orig_Knock22 orig, MerchantScript self, Vector3 a);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Start(MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Start(orig_Start orig, MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate string orig_GetRandomText(MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate string hook_GetRandomText(orig_GetRandomText orig, MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Talkn(MerchantScript self, string s);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Talkn(orig_Talkn orig, MerchantScript self, string s);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnDestroy(MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnDestroy(orig_OnDestroy orig, MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SetItems(MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SetItems(orig_SetItems orig, MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SetGear(MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SetGear(orig_SetGear orig, MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_RefreshItemsRPC(MerchantScript self, int id1, int id2, int id3, int id4);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_RefreshItemsRPC(orig_RefreshItemsRPC orig, MerchantScript self, int id1, int id2, int id3, int id4);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_RefreshItems(MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_RefreshItems(orig_RefreshItems orig, MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate int orig_GetItemPrice(MerchantScript self, int id);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate int hook_GetItemPrice(orig_GetItemPrice orig, MerchantScript self, int id);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Main(MerchantScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Main(orig_Main orig, MerchantScript self);

		public static class $Start$1133
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<WaitForSeconds> self, MerchantScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<WaitForSeconds> self, MerchantScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> orig_GetEnumerator(GenericGenerator<WaitForSeconds> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<WaitForSeconds> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<WaitForSeconds> self, MerchantScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<WaitForSeconds> self, MerchantScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<WaitForSeconds> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<WaitForSeconds> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static class $Talkn$1136
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<WaitForSeconds> self, string s, MerchantScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<WaitForSeconds> self, string s, MerchantScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> orig_GetEnumerator(GenericGenerator<WaitForSeconds> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<WaitForSeconds> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<WaitForSeconds> self, string s, MerchantScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<WaitForSeconds> self, string s, MerchantScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<WaitForSeconds> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<WaitForSeconds> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
		}

		public static event hook_Awake Awake
		{
			add
			{
				HookEndpointManager.Add<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Awake);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Awake);
			}
		}

		public static event hook_Knock22 Knock22
		{
			add
			{
				HookEndpointManager.Add<hook_Knock22>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Knock);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Knock22>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Knock);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
		}

		public static event hook_GetRandomText GetRandomText
		{
			add
			{
				HookEndpointManager.Add<hook_GetRandomText>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetRandomText);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetRandomText>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetRandomText);
			}
		}

		public static event hook_Talkn Talkn
		{
			add
			{
				HookEndpointManager.Add<hook_Talkn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Talkn);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Talkn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Talkn);
			}
		}

		public static event hook_OnDestroy OnDestroy
		{
			add
			{
				HookEndpointManager.Add<hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_OnDestroy);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_OnDestroy);
			}
		}

		public static event hook_SetItems SetItems
		{
			add
			{
				HookEndpointManager.Add<hook_SetItems>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_SetItems);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SetItems>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_SetItems);
			}
		}

		public static event hook_SetGear SetGear
		{
			add
			{
				HookEndpointManager.Add<hook_SetGear>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_SetGear);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SetGear>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_SetGear);
			}
		}

		public static event hook_RefreshItemsRPC RefreshItemsRPC
		{
			add
			{
				HookEndpointManager.Add<hook_RefreshItemsRPC>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_RefreshItemsRPC);
			}
			remove
			{
				HookEndpointManager.Remove<hook_RefreshItemsRPC>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_RefreshItemsRPC);
			}
		}

		public static event hook_RefreshItems RefreshItems
		{
			add
			{
				HookEndpointManager.Add<hook_RefreshItems>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_RefreshItems);
			}
			remove
			{
				HookEndpointManager.Remove<hook_RefreshItems>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_RefreshItems);
			}
		}

		public static event hook_GetItemPrice GetItemPrice
		{
			add
			{
				HookEndpointManager.Add<hook_GetItemPrice>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetItemPrice);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetItemPrice>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetItemPrice);
			}
		}

		public static event hook_Main Main
		{
			add
			{
				HookEndpointManager.Add<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
		}
	}
}
namespace IL
{
	public static class MerchantScript
	{
		public static class $Start$1133
		{
			public static class $
			{
				public static event Manipulator ctor
				{
					add
					{
						HookEndpointManager.Modify<On.MerchantScript.$Start$1133.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.MerchantScript.$Start$1133.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}

				public static event Manipulator MoveNext
				{
					add
					{
						HookEndpointManager.Modify<On.MerchantScript.$Start$1133.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.MerchantScript.$Start$1133.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}
			}

			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.MerchantScript.$Start$1133.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.MerchantScript.$Start$1133.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}

			public static event Manipulator GetEnumerator
			{
				add
				{
					HookEndpointManager.Modify<On.MerchantScript.$Start$1133.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.MerchantScript.$Start$1133.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}
		}

		public static class $Talkn$1136
		{
			public static class $
			{
				public static event Manipulator ctor
				{
					add
					{
						HookEndpointManager.Modify<On.MerchantScript.$Talkn$1136.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.MerchantScript.$Talkn$1136.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}

				public static event Manipulator MoveNext
				{
					add
					{
						HookEndpointManager.Modify<On.MerchantScript.$Talkn$1136.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.MerchantScript.$Talkn$1136.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}
			}

			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.MerchantScript.$Talkn$1136.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.MerchantScript.$Talkn$1136.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}

			public static event Manipulator GetEnumerator
			{
				add
				{
					HookEndpointManager.Modify<On.MerchantScript.$Talkn$1136.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.MerchantScript.$Talkn$1136.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Awake
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Knock22
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_Knock22>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_Knock22>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator GetRandomText
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_GetRandomText>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_GetRandomText>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Talkn
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_Talkn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_Talkn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator OnDestroy
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator SetItems
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_SetItems>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_SetItems>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator SetGear
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_SetGear>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_SetGear>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator RefreshItemsRPC
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_RefreshItemsRPC>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_RefreshItemsRPC>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator RefreshItems
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_RefreshItems>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_RefreshItems>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator GetItemPrice
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_GetItemPrice>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_GetItemPrice>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Main
		{
			add
			{
				HookEndpointManager.Modify<On.MerchantScript.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.MerchantScript.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}
	}
}
namespace On
{
	public static class AbyssalTitan
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(AbyssalTitan self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, AbyssalTitan self);

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
		}
	}
}
namespace IL
{
	public static class AbyssalTitan
	{
		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.AbyssalTitan.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AbyssalTitan.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}
	}
}
namespace On
{
	public static class Animate
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(Animate self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, Animate self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Start(Animate self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Start(orig_Start orig, Animate self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Main(Animate self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Main(orig_Main orig, Animate self);

		public static class $Start$1141
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<WaitForSeconds> self, Animate self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<WaitForSeconds> self, Animate self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> orig_GetEnumerator(GenericGenerator<WaitForSeconds> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<WaitForSeconds> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<WaitForSeconds> self, Animate self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<WaitForSeconds> self, Animate self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<WaitForSeconds> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<WaitForSeconds> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
		}

		public static event hook_Main Main
		{
			add
			{
				HookEndpointManager.Add<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
		}
	}
}
namespace IL
{
	public static class Animate
	{
		public static class $Start$1141
		{
			public static class $
			{
				public static event Manipulator ctor
				{
					add
					{
						HookEndpointManager.Modify<On.Animate.$Start$1141.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.Animate.$Start$1141.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}

				public static event Manipulator MoveNext
				{
					add
					{
						HookEndpointManager.Modify<On.Animate.$Start$1141.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.Animate.$Start$1141.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}
			}

			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.Animate.$Start$1141.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.Animate.$Start$1141.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}

			public static event Manipulator GetEnumerator
			{
				add
				{
					HookEndpointManager.Modify<On.Animate.$Start$1141.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.Animate.$Start$1141.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.Animate.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.Animate.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.Animate.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.Animate.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Main
		{
			add
			{
				HookEndpointManager.Modify<On.Animate.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.Animate.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}
	}
}
namespace On
{
	public static class AnimateScript
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(AnimateScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, AnimateScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Start(AnimateScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Start(orig_Start orig, AnimateScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Die(AnimateScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Die(orig_Die orig, AnimateScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Main(AnimateScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Main(orig_Main orig, AnimateScript self);

		public static class $Start$1147
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<WaitForSeconds> self, AnimateScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<WaitForSeconds> self, AnimateScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> orig_GetEnumerator(GenericGenerator<WaitForSeconds> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<WaitForSeconds> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<WaitForSeconds> self, AnimateScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<WaitForSeconds> self, AnimateScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<WaitForSeconds> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<WaitForSeconds> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static class $Die$1152
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<WaitForSeconds> self, AnimateScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<WaitForSeconds> self, AnimateScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> orig_GetEnumerator(GenericGenerator<WaitForSeconds> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<WaitForSeconds> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<WaitForSeconds> self, AnimateScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<WaitForSeconds> self, AnimateScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<WaitForSeconds> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<WaitForSeconds> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
		}

		public static event hook_Die Die
		{
			add
			{
				HookEndpointManager.Add<hook_Die>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Die);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Die>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Die);
			}
		}

		public static event hook_Main Main
		{
			add
			{
				HookEndpointManager.Add<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
		}
	}
}
namespace IL
{
	public static class AnimateScript
	{
		public static class $Start$1147
		{
			public static class $
			{
				public static event Manipulator ctor
				{
					add
					{
						HookEndpointManager.Modify<On.AnimateScript.$Start$1147.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.AnimateScript.$Start$1147.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}

				public static event Manipulator MoveNext
				{
					add
					{
						HookEndpointManager.Modify<On.AnimateScript.$Start$1147.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.AnimateScript.$Start$1147.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}
			}

			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.AnimateScript.$Start$1147.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.AnimateScript.$Start$1147.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}

			public static event Manipulator GetEnumerator
			{
				add
				{
					HookEndpointManager.Modify<On.AnimateScript.$Start$1147.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.AnimateScript.$Start$1147.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}
		}

		public static class $Die$1152
		{
			public static class $
			{
				public static event Manipulator ctor
				{
					add
					{
						HookEndpointManager.Modify<On.AnimateScript.$Die$1152.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.AnimateScript.$Die$1152.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}

				public static event Manipulator MoveNext
				{
					add
					{
						HookEndpointManager.Modify<On.AnimateScript.$Die$1152.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.AnimateScript.$Die$1152.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}
			}

			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.AnimateScript.$Die$1152.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.AnimateScript.$Die$1152.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}

			public static event Manipulator GetEnumerator
			{
				add
				{
					HookEndpointManager.Modify<On.AnimateScript.$Die$1152.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.AnimateScript.$Die$1152.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.AnimateScript.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AnimateScript.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.AnimateScript.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AnimateScript.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Die
		{
			add
			{
				HookEndpointManager.Modify<On.AnimateScript.hook_Die>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AnimateScript.hook_Die>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}

		public static event Manipulator Main
		{
			add
			{
				HookEndpointManager.Modify<On.AnimateScript.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AnimateScript.hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
			}
		}
	}
}
namespace On
{
	public static class ArcherScript
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Start(ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Start(orig_Start orig, ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_AttackCheck(ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_AttackCheck(orig_AttackCheck orig, ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_MoveCheck(ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_MoveCheck(orig_MoveCheck orig, ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_ATK(ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_ATK(orig_ATK orig, ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Main(ArcherScript self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Main(orig_Main orig, ArcherScript self);

		public static class $Start$1155
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<Coroutine> self, ArcherScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<Coroutine> self, ArcherScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<Coroutine> orig_GetEnumerator(GenericGenerator<Coroutine> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<Coroutine> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<Coroutine> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<Coroutine> self, ArcherScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<Coroutine> self, ArcherScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<Coroutine> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<Coroutine> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static class $AttackCheck$1159
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<YieldInstruction> self, ArcherScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<YieldInstruction> self, ArcherScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<YieldInstruction> orig_GetEnumerator(GenericGenerator<YieldInstruction> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<YieldInstruction> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<YieldInstruction> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<YieldInstruction> self, ArcherScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<YieldInstruction> self, ArcherScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<YieldInstruction> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<YieldInstruction> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static class $MoveCheck$1175
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<WaitForSeconds> self, ArcherScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<WaitForSeconds> self, ArcherScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> orig_GetEnumerator(GenericGenerator<WaitForSeconds> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<WaitForSeconds> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<WaitForSeconds> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<WaitForSeconds> self, ArcherScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<WaitForSeconds> self, ArcherScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<WaitForSeconds> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<WaitForSeconds> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static class $ATK$1182
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(GenericGenerator<YieldInstruction> self, ArcherScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, GenericGenerator<YieldInstruction> self, ArcherScript self_);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<YieldInstruction> orig_GetEnumerator(GenericGenerator<YieldInstruction> self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate IEnumerator<YieldInstruction> hook_GetEnumerator(orig_GetEnumerator orig, GenericGenerator<YieldInstruction> self);

			public static class $
			{
				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void orig_ctor(GenericGeneratorEnumerator<YieldInstruction> self, ArcherScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate void hook_ctor(orig_ctor orig, GenericGeneratorEnumerator<YieldInstruction> self, ArcherScript self_);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool orig_MoveNext(GenericGeneratorEnumerator<YieldInstruction> self);

				[EditorBrowsable(EditorBrowsableState.Never)]
				public delegate bool hook_MoveNext(orig_MoveNext orig, GenericGeneratorEnumerator<YieldInstruction> self);

				public static event hook_ctor ctor
				{
					add
					{
						HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
					remove
					{
						HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
					}
				}

				public static event hook_MoveNext MoveNext
				{
					add
					{
						HookEndpointManager.Add<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
					remove
					{
						HookEndpointManager.Remove<hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveNext);
					}
				}
			}

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
				}
			}

			public static event hook_GetEnumerator GetEnumerator
			{
				add
				{
					HookEndpointManager.Add<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
				remove
				{
					HookEndpointManager.Remove<hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_GetEnumerator);
				}
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ctor);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Start);
			}
		}

		public static event hook_AttackCheck AttackCheck
		{
			add
			{
				HookEndpointManager.Add<hook_AttackCheck>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_AttackCheck);
			}
			remove
			{
				HookEndpointManager.Remove<hook_AttackCheck>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_AttackCheck);
			}
		}

		public static event hook_MoveCheck MoveCheck
		{
			add
			{
				HookEndpointManager.Add<hook_MoveCheck>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveCheck);
			}
			remove
			{
				HookEndpointManager.Remove<hook_MoveCheck>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_MoveCheck);
			}
		}

		public static event hook_ATK ATK
		{
			add
			{
				HookEndpointManager.Add<hook_ATK>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ATK);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ATK>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_ATK);
			}
		}

		public static event hook_Main Main
		{
			add
			{
				HookEndpointManager.Add<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Main>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)hook_Main);
			}
		}
	}
}
namespace IL
{
	public static class ArcherScript
	{
		public static class $Start$1155
		{
			public static class $
			{
				public static event Manipulator ctor
				{
					add
					{
						HookEndpointManager.Modify<On.ArcherScript.$Start$1155.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.ArcherScript.$Start$1155.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}

				public static event Manipulator MoveNext
				{
					add
					{
						HookEndpointManager.Modify<On.ArcherScript.$Start$1155.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.ArcherScript.$Start$1155.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}
			}

			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.ArcherScript.$Start$1155.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.ArcherScript.$Start$1155.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}

			public static event Manipulator GetEnumerator
			{
				add
				{
					HookEndpointManager.Modify<On.ArcherScript.$Start$1155.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.ArcherScript.$Start$1155.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}
		}

		public static class $AttackCheck$1159
		{
			public static class $
			{
				public static event Manipulator ctor
				{
					add
					{
						HookEndpointManager.Modify<On.ArcherScript.$AttackCheck$1159.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.ArcherScript.$AttackCheck$1159.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}

				public static event Manipulator MoveNext
				{
					add
					{
						HookEndpointManager.Modify<On.ArcherScript.$AttackCheck$1159.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.ArcherScript.$AttackCheck$1159.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}
			}

			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.ArcherScript.$AttackCheck$1159.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.ArcherScript.$AttackCheck$1159.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}

			public static event Manipulator GetEnumerator
			{
				add
				{
					HookEndpointManager.Modify<On.ArcherScript.$AttackCheck$1159.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.ArcherScript.$AttackCheck$1159.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}
		}

		public static class $MoveCheck$1175
		{
			public static class $
			{
				public static event Manipulator ctor
				{
					add
					{
						HookEndpointManager.Modify<On.ArcherScript.$MoveCheck$1175.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.ArcherScript.$MoveCheck$1175.$.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}

				public static event Manipulator MoveNext
				{
					add
					{
						HookEndpointManager.Modify<On.ArcherScript.$MoveCheck$1175.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
					remove
					{
						HookEndpointManager.Unmodify<On.ArcherScript.$MoveCheck$1175.$.hook_MoveNext>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
					}
				}
			}

			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.ArcherScript.$MoveCheck$1175.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.ArcherScript.$MoveCheck$1175.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)val);
				}
			}

			public static event Manipulator GetEnumerator
			{
				add
				{
					HookEndpointManager.Modify<On.ArcherScript.$MoveCheck$1175.hook_GetEnumerator>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not support