using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AugmentedVoidReaver;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EnemiesPlus.Content.Beetle;
using EnemiesPlus.Content.Imp;
using EnemiesPlus.Content.Wisp;
using EntityStates;
using EntityStates.AcidLarva;
using EntityStates.ArtifactShell;
using EntityStates.BeetleGuardMonster;
using EntityStates.BeetleMonster;
using EntityStates.BeetleQueenMonster;
using EntityStates.Bell.BellWeapon;
using EntityStates.BigMush;
using EntityStates.Bison;
using EntityStates.BrotherHaunt;
using EntityStates.BrotherMonster;
using EntityStates.BrotherMonster.KarmaSpire;
using EntityStates.BrotherMonster.Weapon;
using EntityStates.ChampRushReaper;
using EntityStates.ChildMonster;
using EntityStates.ClayBoss;
using EntityStates.ClayBoss.ClayBossWeapon;
using EntityStates.ClayBruiser.Weapon;
using EntityStates.ClayGrenadier;
using EntityStates.DefectiveUnit;
using EntityStates.Drone.DroneWeapon;
using EntityStates.ExtractorUnit;
using EntityStates.FalseSonBoss;
using EntityStates.FlyingVermin.Weapon;
using EntityStates.FriendUnit;
using EntityStates.GolemMonster;
using EntityStates.GrandParentBoss;
using EntityStates.GravekeeperBoss;
using EntityStates.GravekeeperMonster.Weapon;
using EntityStates.GreaterWispMonster;
using EntityStates.Gup;
using EntityStates.HermitCrab;
using EntityStates.ImpBossMonster;
using EntityStates.ImpMonster;
using EntityStates.IronHauler.Weapon;
using EntityStates.JellyfishMonster;
using EntityStates.LemurianBruiserMonster;
using EntityStates.LemurianMonster;
using EntityStates.LunarExploderMonster.Weapon;
using EntityStates.LunarGolem;
using EntityStates.LunarWisp;
using EntityStates.Lynx2Monster;
using EntityStates.LynxAmbusher;
using EntityStates.LynxArcher;
using EntityStates.LynxGhostTurret;
using EntityStates.MajorConstruct.Weapon;
using EntityStates.Mimic.Devour;
using EntityStates.Mimic.Monster;
using EntityStates.MiniLynx;
using EntityStates.MiniMushroom;
using EntityStates.MinorConstruct.Weapon;
using EntityStates.NullifierMonster;
using EntityStates.ParentMonster;
using EntityStates.RoboBallBoss.Weapon;
using EntityStates.RoboBallMini.Weapon;
using EntityStates.Scorchling;
using EntityStates.SolusAmalgamator;
using EntityStates.SolusHeart;
using EntityStates.SolusMine;
using EntityStates.SolusWing;
using EntityStates.SpiritMonster;
using EntityStates.Squid.SquidWeapon;
using EntityStates.Swift;
using EntityStates.Tanker;
using EntityStates.Tanker.GreasePuddle;
using EntityStates.TitanMonster;
using EntityStates.Totem;
using EntityStates.Treebot.Weapon;
using EntityStates.UrchinTurret.Weapon;
using EntityStates.VagrantMonster;
using EntityStates.VagrantMonster.Weapon;
using EntityStates.Vermin.Weapon;
using EntityStates.VoidBarnacle.Weapon;
using EntityStates.VoidInfestor;
using EntityStates.VoidJailer.Weapon;
using EntityStates.VoidMegaCrab.BackWeapon;
using EntityStates.VoidMegaCrab.Weapon;
using EntityStates.VoidRaidCrab;
using EntityStates.VoidRaidCrab.Weapon;
using EntityStates.Vulture.Weapon;
using EntityStates.VultureHunter.Body;
using EntityStates.VultureHunter.Weapon;
using EntityStates.Wisp1Monster;
using EntityStates.WorkerUnit;
using Mdh.AugmentedVoidReaver.BetterPortalBomb;
using Mdh.EnemiesPlus.Content.Beetle.BeetleSpit;
using Mdh.EnemiesPlus.Content.Imp.ImpVoidSpike;
using Mdh.EnemiesPlus.Content.Wisp.FireBlast;
using Mdh.EntityStates.AcidLarva.LarvaLeap;
using Mdh.EntityStates.ArtifactShell.FireSolarFlares;
using Mdh.EntityStates.BaseState;
using Mdh.EntityStates.BasicMeleeAttack;
using Mdh.EntityStates.BeetleGuardMonster.FireSunder;
using Mdh.EntityStates.BeetleGuardMonster.GroundSlam;
using Mdh.EntityStates.BeetleMonster.HeadbuttState;
using Mdh.EntityStates.BeetleQueenMonster.FireSpit;
using Mdh.EntityStates.Bell.BellWeapon.ChargeTrioBomb;
using Mdh.EntityStates.BigMush.Proliferate;
using Mdh.EntityStates.BigMush.Regrowth;
using Mdh.EntityStates.BigMush.SporeCoat;
using Mdh.EntityStates.Bison.Charge;
using Mdh.EntityStates.Bison.Headbutt;
using Mdh.EntityStates.BrotherHaunt.FireRandomProjectiles;
using Mdh.EntityStates.BrotherMonster.BaseSlideState;
using Mdh.EntityStates.BrotherMonster.ExitSkyLeap;
using Mdh.EntityStates.BrotherMonster.FistSlam;
using Mdh.EntityStates.BrotherMonster.KarmaSpire.FireProjectile;
using Mdh.EntityStates.BrotherMonster.SkyLeapBomb;
using Mdh.EntityStates.BrotherMonster.SprintBash;
using Mdh.EntityStates.BrotherMonster.Weapon.FireLunarShards;
using Mdh.EntityStates.BrotherMonster.Weapon.LunarExploderMortarStorm;
using Mdh.EntityStates.BrotherMonster.WeaponSlam;
using Mdh.EntityStates.ChampRushReaper.AssailState;
using Mdh.EntityStates.ChampRushReaper.FireBrambles;
using Mdh.EntityStates.ChampRushReaper.Haunt4CastEnter;
using Mdh.EntityStates.ChampRushReaper.Reap2;
using Mdh.EntityStates.ChildMonster.SparkBallFire;
using Mdh.EntityStates.ClayBoss.ClayBossWeapon.FireBombardment;
using Mdh.EntityStates.ClayBoss.FireTarball;
using Mdh.EntityStates.ClayBruiser.Weapon.MinigunFire;
using Mdh.EntityStates.ClayBruiser.Weapon.MinigunState;
using Mdh.EntityStates.ClayGrenadier.FaceSlam;
using Mdh.EntityStates.DefectiveUnit.Denial;
using Mdh.EntityStates.DefectiveUnit.DenialProjectile;
using Mdh.EntityStates.DefectiveUnit.Detonate;
using Mdh.EntityStates.Drone.DroneWeapon.FireGatling;
using Mdh.EntityStates.FalseSonBoss.CorruptedPaths;
using Mdh.EntityStates.FalseSonBoss.CorruptedPathsDash;
using Mdh.EntityStates.FalseSonBoss.FalseSonBossGenericStateWithSwing;
using Mdh.EntityStates.FalseSonBoss.FissureSlam;
using Mdh.EntityStates.FalseSonBoss.LunarRain;
using Mdh.EntityStates.FalseSonBoss.PrimeDevastator;
using Mdh.EntityStates.FalseSonBoss.TaintedOffering;
using Mdh.EntityStates.FlyingVermin.Weapon.Spit;
using Mdh.EntityStates.FriendUnit.FinalSacrifice;
using Mdh.EntityStates.GenericProjectileBaseState;
using Mdh.EntityStates.GolemMonster.ClapState;
using Mdh.EntityStates.GolemMonster.FireLaser;
using Mdh.EntityStates.GrandParentBoss.GroundSwipe;
using Mdh.EntityStates.GravekeeperBoss.FireHook;
using Mdh.EntityStates.GravekeeperMonster.Weapon.GravekeeperBarrage;
using Mdh.EntityStates.GreaterWispMonster.FireCannons;
using Mdh.EntityStates.HermitCrab.FireMortar;
using Mdh.EntityStates.ImpBossMonster.BlinkState;
using Mdh.EntityStates.ImpBossMonster.FireVoidspikes;
using Mdh.EntityStates.ImpBossMonster.GroundPound;
using Mdh.EntityStates.ImpMonster.DoubleSlash;
using Mdh.EntityStates.JellyfishMonster.JellyNova;
using Mdh.EntityStates.LemurianBruiserMonster.FireMegaFireball;
using Mdh.EntityStates.LemurianBruiserMonster.Flamebreath;
using Mdh.EntityStates.LemurianMonster.Bite;
using Mdh.EntityStates.LemurianMonster.FireFireball;
using Mdh.EntityStates.LunarGolem.FireTwinShots;
using Mdh.EntityStates.LunarWisp.FireLunarGuns;
using Mdh.EntityStates.LunarWisp.SeekingBomb;
using Mdh.EntityStates.Lynx2Monster.FrenziedUpsetPoundSlamState;
using Mdh.EntityStates.Lynx2Monster.TwoSwipes;
using Mdh.EntityStates.LynxAmbusher.HunterHurlThrow;
using Mdh.EntityStates.LynxAmbusher.SpearStrike;
using Mdh.EntityStates.LynxAmbusher.SpearStrikeStationary;
using Mdh.EntityStates.LynxGhostTurret.GhostArrow;
using Mdh.EntityStates.MajorConstruct.Weapon.FireLaser;
using Mdh.EntityStates.MajorConstruct.Weapon.TerminateLaser;
using Mdh.EntityStates.Mimic.Devour.DevouredBody;
using Mdh.EntityStates.Mimic.Monster.Lick;
using Mdh.EntityStates.MiniLynx.Nibble;
using Mdh.EntityStates.MiniMushroom.SporeGrenade;
using Mdh.EntityStates.NullifierMonster.FirePortalBomb;
using Mdh.EntityStates.ParentMonster.GroundSlam;
using Mdh.EntityStates.RoboBallBoss.Weapon.FireDelayKnockup;
using Mdh.EntityStates.RoboBallBoss.Weapon.FireEyeBlast;
using Mdh.EntityStates.RoboBallMini.Weapon.FireEyeBeam;
using Mdh.EntityStates.Scorchling.ScorchlingBreach;
using Mdh.EntityStates.Scorchling.ScorchlingLavaBomb;
using Mdh.EntityStates.SolusAmalgamator.ArtilleryStrike;
using Mdh.EntityStates.SolusAmalgamator.FlamethrowerCannon;
using Mdh.EntityStates.SolusAmalgamator.FlamethrowerTurret;
using Mdh.EntityStates.SolusAmalgamator.ShockArmor;
using Mdh.EntityStates.SolusHeart.DDOS;
using Mdh.EntityStates.SolusHeart.FireOrbitalStrike;
using Mdh.EntityStates.SolusHeart.GroundSlamState;
using Mdh.EntityStates.SolusHeart.Underclock;
using Mdh.EntityStates.SolusMine.Detonate;
using Mdh.EntityStates.SolusWing.ExpandingLaserBase;
using Mdh.EntityStates.SolusWing.GravPulse;
using Mdh.EntityStates.SolusWing.SuppressionFire;
using Mdh.EntityStates.SpiritMonster.RingOfFire;
using Mdh.EntityStates.Squid.SquidWeapon.FireSpine;
using Mdh.EntityStates.Swift.FlyingToDive;
using Mdh.EntityStates.Swift.Stuck;
using Mdh.EntityStates.Tanker.Accelerant;
using Mdh.EntityStates.Tanker.GreasePuddle.IgniteGrease;
using Mdh.EntityStates.Tanker.Ignite;
using Mdh.EntityStates.TitanMonster.FireFist;
using Mdh.EntityStates.TitanMonster.FireGoldMegaLaser;
using Mdh.EntityStates.Totem.GroundPound;
using Mdh.EntityStates.Totem.SacrificeSuccess;
using Mdh.EntityStates.Totem.SoulBlast;
using Mdh.EntityStates.UrchinTurret.Weapon.MinigunFire;
using Mdh.EntityStates.VagrantMonster.FireTrackingBomb;
using Mdh.EntityStates.VagrantMonster.Weapon.JellyBarrage;
using Mdh.EntityStates.Vermin.Weapon.TongueLash;
using Mdh.EntityStates.VoidInfestor.Infest;
using Mdh.EntityStates.VoidJailer.Weapon.Capture2;
using Mdh.EntityStates.VoidMegaCrab.BackWeapon.FireVoidMissiles;
using Mdh.EntityStates.VoidMegaCrab.Weapon.FireCrabCannonBase;
using Mdh.EntityStates.VoidRaidCrab.SpinBeamAttack;
using Mdh.EntityStates.VoidRaidCrab.Weapon.BaseFireMultiBeam;
using Mdh.EntityStates.VoidRaidCrab.Weapon.FireMissiles;
using Mdh.EntityStates.Vulture.Weapon.FireWindblade;
using Mdh.EntityStates.VultureHunter.Body.BombingRun;
using Mdh.EntityStates.VultureHunter.Body.BombingRunLaser;
using Mdh.EntityStates.VultureHunter.Body.ThrowSpear;
using Mdh.EntityStates.VultureHunter.Body.ThrowTeleportSpear;
using Mdh.EntityStates.VultureHunter.Weapon.Calldown;
using Mdh.EntityStates.VultureHunter.Weapon.FireSolusLaser;
using Mdh.EntityStates.Wisp1Monster.FireEmbers;
using Mdh.EntityStates.WorkerUnit.FireDrillDash;
using Mdh.RoR2.BrotherUltUtils;
using Mdh.RoR2.JailerTetherController;
using Mdh.RoR2.Projectile.MegacrabProjectileController;
using Mdh.RoR2.Projectile.ProjectileFireChildren;
using Mdh.RoR2.TarTetherController;
using Mdh.RoR2.TitanRockController;
using Mdh.RoR2.WormBodyPositions2;
using Microsoft.CodeAnalysis;
using MiscFixes.Modules;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.Cil.Analysis;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using MonoMod.Cil;
using RoR2;
using RoR2.ContentManagement;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2BepInExPack.GameAssetPathsBetter;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("AugmentedVoidReaver")]
[assembly: IgnoresAccessChecksTo("EnemiesPlus")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Lordryn.DamageSourceForEnemies")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.1.1.0")]
[assembly: AssemblyInformationalVersion("2.1.1+dc556d82c806889aef54cbd27feb0b740a170e3d")]
[assembly: AssemblyProduct("Lordryn.DamageSourceForEnemies")]
[assembly: AssemblyTitle("DamageSourceForEnemies")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

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

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

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

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

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

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

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

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

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

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

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

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

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

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

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

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Mdh.EnemiesPlus.Content.Imp.ImpVoidSpike
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(ImpVoidSpike self);

		public delegate void PostfixSignature(ImpVoidSpike self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(ImpVoidSpike);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Imp.ImpVoidSpike", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
		public delegate void PrefixSignature(ImpVoidSpike self);

		public delegate void PostfixSignature(ImpVoidSpike self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(ImpVoidSpike);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Imp.ImpVoidSpike", "OnEnter");
			}
			return method;
		}
	}
	internal static class OnExit
	{
		public delegate void PrefixSignature(ImpVoidSpike self);

		public delegate void PostfixSignature(ImpVoidSpike self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(ImpVoidSpike);
			MethodInfo method = typeFromHandle.GetMethod("OnExit", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Imp.ImpVoidSpike", "OnExit");
			}
			return method;
		}
	}
	internal static class HandleSlash
	{
		public delegate void PrefixSignature(ImpVoidSpike self, ref string animatorParamName, ref string muzzleName);

		public delegate void PostfixSignature(ImpVoidSpike self, ref string animatorParamName, ref string muzzleName);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(ImpVoidSpike);
			MethodInfo method = typeFromHandle.GetMethod("HandleSlash", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Imp.ImpVoidSpike", "HandleSlash");
			}
			return method;
		}
	}
}
namespace Mdh.EnemiesPlus.Content.Wisp.FireBlast
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(FireBlast self);

		public delegate void PostfixSignature(FireBlast self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(FireBlast);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Wisp.FireBlast", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
		public delegate void PrefixSignature(FireBlast self);

		public delegate void PostfixSignature(FireBlast self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(FireBlast);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Wisp.FireBlast", "OnEnter");
			}
			return method;
		}
	}
	internal static class Fire
	{
		public delegate void PrefixSignature(FireBlast self);

		public delegate void PostfixSignature(FireBlast self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(FireBlast);
			MethodInfo method = typeFromHandle.GetMethod("Fire", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Wisp.FireBlast", "Fire");
			}
			return method;
		}
	}
}
namespace Mdh.EnemiesPlus.Content.Beetle.BeetleSpit
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(BeetleSpit self);

		public delegate void PostfixSignature(BeetleSpit self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BeetleSpit);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Beetle.BeetleSpit", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
		public delegate void PrefixSignature(BeetleSpit self);

		public delegate void PostfixSignature(BeetleSpit self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BeetleSpit);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Beetle.BeetleSpit", "OnEnter");
			}
			return method;
		}
	}
	internal static class OnExit
	{
		public delegate void PrefixSignature(BeetleSpit self);

		public delegate void PostfixSignature(BeetleSpit self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BeetleSpit);
			MethodInfo method = typeFromHandle.GetMethod("OnExit", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Beetle.BeetleSpit", "OnExit");
			}
			return method;
		}
	}
	internal static class Fire
	{
		public delegate void PrefixSignature(BeetleSpit self);

		public delegate void PostfixSignature(BeetleSpit self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BeetleSpit);
			MethodInfo method = typeFromHandle.GetMethod("Fire", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EnemiesPlus.Content.Beetle.BeetleSpit", "Fire");
			}
			return method;
		}
	}
}
namespace Mdh.AugmentedVoidReaver.BetterPortalBomb
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(BetterPortalBomb self);

		public delegate void PostfixSignature(BetterPortalBomb self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BetterPortalBomb);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("AugmentedVoidReaver.BetterPortalBomb", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
		public delegate void PrefixSignature(BetterPortalBomb self);

		public delegate void PostfixSignature(BetterPortalBomb self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BetterPortalBomb);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("AugmentedVoidReaver.BetterPortalBomb", "OnEnter");
			}
			return method;
		}
	}
	internal static class FireBomb
	{
		public delegate void PrefixSignature(BetterPortalBomb self, ref Vector3 targetPos);

		public delegate void PostfixSignature(BetterPortalBomb self, ref Vector3 targetPos);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BetterPortalBomb);
			MethodInfo method = typeFromHandle.GetMethod("FireBomb", (BindingFlags)(-1), null, new Type[1] { typeof(Vector3) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("AugmentedVoidReaver.BetterPortalBomb", "FireBomb");
			}
			return method;
		}
	}
}
namespace Mdh.RoR2.BrotherUltUtils
{
	internal static class EvaluatePattern
	{
		public delegate void PrefixSignature(ref BrotherUltPattern pattern, ref BrotherUltContext context);

		public delegate void PostfixSignature(ref BrotherUltPattern pattern, ref BrotherUltContext context);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BrotherUltUtils);
			MethodInfo method = typeFromHandle.GetMethod("EvaluatePattern", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(BrotherUltPattern),
				typeof(BrotherUltContext)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.BrotherUltUtils", "EvaluatePattern");
			}
			return method;
		}
	}
	internal static class Init
	{
		public delegate void PrefixSignature();

		public delegate void PostfixSignature();

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BrotherUltUtils);
			MethodInfo method = typeFromHandle.GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.BrotherUltUtils", "Init");
			}
			return method;
		}
	}
}
namespace Mdh.RoR2.ProvidenceController
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(ProvidenceController self);

		public delegate void PostfixSignature(ProvidenceController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(ProvidenceController);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.ProvidenceController", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnDestroy
	{
		public delegate void PrefixSignature(ProvidenceController self);

		public delegate void PostfixSignature(ProvidenceController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(ProvidenceController);
			MethodInfo method = typeFromHandle.GetMethod("OnDestroy", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.ProvidenceController", "OnDestroy");
			}
			return method;
		}
	}
}
namespace Mdh.RoR2.Projectile.ProjectileFireChildren
{
	internal static class FireChild
	{
		public delegate void PrefixSignature(ProjectileFireChildren self);

		public delegate void PostfixSignature(ProjectileFireChildren self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(ProjectileFireChildren);
			MethodInfo method = typeFromHandle.GetMethod("FireChild", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.Projectile.ProjectileFireChildren", "FireChild");
			}
			return method;
		}
	}
}
namespace Mdh.RoR2.Projectile.MegacrabProjectileController
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(MegacrabProjectileController self);

		public delegate void PostfixSignature(MegacrabProjectileController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(MegacrabProjectileController);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.Projectile.MegacrabProjectileController", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnDestroy
	{
		public delegate void PrefixSignature(MegacrabProjectileController self);

		public delegate void PostfixSignature(MegacrabProjectileController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(MegacrabProjectileController);
			MethodInfo method = typeFromHandle.GetMethod("OnDestroy", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.Projectile.MegacrabProjectileController", "OnDestroy");
			}
			return method;
		}
	}
}
namespace Mdh.RoR2.JailerTetherController
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(JailerTetherController self);

		public delegate void PostfixSignature(JailerTetherController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(JailerTetherController);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.JailerTetherController", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class DoDamageTick
	{
		public delegate void PrefixSignature(JailerTetherController self);

		public delegate void PostfixSignature(JailerTetherController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(JailerTetherController);
			MethodInfo method = typeFromHandle.GetMethod("DoDamageTick", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.JailerTetherController", "DoDamageTick");
			}
			return method;
		}
	}
	internal static class RemoveBuff
	{
		public delegate void PrefixSignature(JailerTetherController self);

		public delegate void PostfixSignature(JailerTetherController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(JailerTetherController);
			MethodInfo method = typeFromHandle.GetMethod("RemoveBuff", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.JailerTetherController", "RemoveBuff");
			}
			return method;
		}
	}
}
namespace Mdh.RoR2.TitanRockController
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(TitanRockController self);

		public delegate void PostfixSignature(TitanRockController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(TitanRockController);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.TitanRockController", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class Fire
	{
		public delegate void PrefixSignature(TitanRockController self);

		public delegate void PostfixSignature(TitanRockController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(TitanRockController);
			MethodInfo method = typeFromHandle.GetMethod("Fire", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.TitanRockController", "Fire");
			}
			return method;
		}
	}
}
namespace Mdh.RoR2.WormBodyPositions2
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(WormBodyPositions2 self);

		public delegate void PostfixSignature(WormBodyPositions2 self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(WormBodyPositions2);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.WormBodyPositions2", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class FireImpactBlastAttack
	{
		public delegate void PrefixSignature(WormBodyPositions2 self, ref Vector3 impactPosition);

		public delegate void PostfixSignature(WormBodyPositions2 self, ref Vector3 impactPosition);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(WormBodyPositions2);
			MethodInfo method = typeFromHandle.GetMethod("FireImpactBlastAttack", (BindingFlags)(-1), null, new Type[1] { typeof(Vector3) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.WormBodyPositions2", "FireImpactBlastAttack");
			}
			return method;
		}
	}
	internal static class FireMeatballs
	{
		public delegate void PrefixSignature(WormBodyPositions2 self, ref Vector3 impactNormal, ref Vector3 impactPosition, ref Vector3 forward, ref int meatballCount, ref float meatballAngle, ref float meatballForce);

		public delegate void PostfixSignature(WormBodyPositions2 self, ref Vector3 impactNormal, ref Vector3 impactPosition, ref Vector3 forward, ref int meatballCount, ref float meatballAngle, ref float meatballForce);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(WormBodyPositions2);
			MethodInfo method = typeFromHandle.GetMethod("FireMeatballs", (BindingFlags)(-1), null, new Type[6]
			{
				typeof(Vector3),
				typeof(Vector3),
				typeof(Vector3),
				typeof(int),
				typeof(float),
				typeof(float)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.WormBodyPositions2", "FireMeatballs");
			}
			return method;
		}
	}
	internal static class OnDestroy
	{
		public delegate void PrefixSignature(WormBodyPositions2 self);

		public delegate void PostfixSignature(WormBodyPositions2 self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(WormBodyPositions2);
			MethodInfo method = typeFromHandle.GetMethod("OnDestroy", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.WormBodyPositions2", "OnDestroy");
			}
			return method;
		}
	}
}
namespace Mdh.RoR2.TarTetherController
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(TarTetherController self);

		public delegate void PostfixSignature(TarTetherController self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(TarTetherController);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.TarTetherController", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class DoDamageTick
	{
		public delegate void PrefixSignature(TarTetherController self, ref bool mulch);

		public delegate void PostfixSignature(TarTetherController self, ref bool mulch);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(TarTetherController);
			MethodInfo method = typeFromHandle.GetMethod("DoDamageTick", (BindingFlags)(-1), null, new Type[1] { typeof(bool) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.TarTetherController", "DoDamageTick");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.RoboBallMini.Weapon.FireEyeBeam
{
	internal static class ModifyBullet
	{
		public delegate void PrefixSignature(FireEyeBeam self, ref BulletAttack bulletAttack);

		public delegate void PostfixSignature(FireEyeBeam self, ref BulletAttack bulletAttack);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(FireEyeBeam);
			MethodInfo method = typeFromHandle.GetMethod("ModifyBullet", (BindingFlags)(-1), null, new Type[1] { typeof(BulletAttack) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.RoboBallMini.Weapon.FireEyeBeam", "ModifyBullet");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.MiniLynx.Nibble
{
	internal static class AuthorityModifyOverlapAttack
	{
		public delegate void PrefixSignature(Nibble self, ref OverlapAttack overlapAttack);

		public delegate void PostfixSignature(Nibble self, ref OverlapAttack overlapAttack);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Nibble);
			MethodInfo method = typeFromHandle.GetMethod("AuthorityModifyOverlapAttack", (BindingFlags)(-1), null, new Type[1] { typeof(OverlapAttack) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.MiniLynx.Nibble", "AuthorityModifyOverlapAttack");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.Vermin.Weapon.TongueLash
{
	internal static class AuthorityModifyOverlapAttack
	{
		public delegate void PrefixSignature(TongueLash self, ref OverlapAttack overlapAttack);

		public delegate void PostfixSignature(TongueLash self, ref OverlapAttack overlapAttack);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(TongueLash);
			MethodInfo method = typeFromHandle.GetMethod("AuthorityModifyOverlapAttack", (BindingFlags)(-1), null, new Type[1] { typeof(OverlapAttack) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.Vermin.Weapon.TongueLash", "AuthorityModifyOverlapAttack");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.BaseState
{
	internal static class OnEnter
	{
		public delegate void PrefixSignature(BaseState self);

		public delegate void PostfixSignature(BaseState self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BaseState);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.BaseState", "OnEnter");
			}
			return method;
		}
	}
	internal static class InitMeleeOverlap
	{
		public delegate void PrefixSignature(BaseState self, ref float damageCoefficient, ref GameObject hitEffectPrefab, ref Transform modelTransform, ref string hitboxGroupName);

		public delegate void PostfixSignature(BaseState self, ref float damageCoefficient, ref GameObject hitEffectPrefab, ref Transform modelTransform, ref string hitboxGroupName, ref OverlapAttack returnValue);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BaseState);
			MethodInfo method = typeFromHandle.GetMethod("InitMeleeOverlap", (BindingFlags)(-1), null, new Type[4]
			{
				typeof(float),
				typeof(GameObject),
				typeof(Transform),
				typeof(string)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.BaseState", "InitMeleeOverlap");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.SolusMine.Detonate
{
	internal static class OnEnter
	{
		public delegate void PrefixSignature(Detonate self);

		public delegate void PostfixSignature(Detonate self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Detonate);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.SolusMine.Detonate", "OnEnter");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.FlyingVermin.Weapon.Spit
{
	internal static class OnEnter
	{
		public delegate void PrefixSignature(Spit self);

		public delegate void PostfixSignature(Spit self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Spit);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.FlyingVermin.Weapon.Spit", "OnEnter");
			}
			return method;
		}
	}
	internal static class FireProjectile
	{
		public delegate void PrefixSignature(Spit self);

		public delegate void PostfixSignature(Spit self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Spit);
			MethodInfo method = typeFromHandle.GetMethod("FireProjectile", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.FlyingVermin.Weapon.Spit", "FireProjectile");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.GenericProjectileBaseState
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(GenericProjectileBaseState self);

		public delegate void PostfixSignature(GenericProjectileBaseState self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(GenericProjectileBaseState);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.GenericProjectileBaseState", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
		public delegate void PrefixSignature(GenericProjectileBaseState self);

		public delegate void PostfixSignature(GenericProjectileBaseState self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(GenericProjectileBaseState);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.GenericProjectileBaseState", "OnEnter");
			}
			return method;
		}
	}
	internal static class FireProjectile
	{
		public delegate void PrefixSignature(GenericProjectileBaseState self);

		public delegate void PostfixSignature(GenericProjectileBaseState self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(GenericProjectileBaseState);
			MethodInfo method = typeFromHandle.GetMethod("FireProjectile", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.GenericProjectileBaseState", "FireProjectile");
			}
			return method;
		}
	}
	internal static class OnExit
	{
		public delegate void PrefixSignature(GenericProjectileBaseState self);

		public delegate void PostfixSignature(GenericProjectileBaseState self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(GenericProjectileBaseState);
			MethodInfo method = typeFromHandle.GetMethod("OnExit", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.GenericProjectileBaseState", "OnExit");
			}
			return method;
		}
	}
	internal static class ModifyProjectileInfo
	{
		public delegate void PrefixSignature(GenericProjectileBaseState self, ref FireProjectileInfo fireProjectileInfo);

		public delegate void PostfixSignature(GenericProjectileBaseState self, ref FireProjectileInfo fireProjectileInfo);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(GenericProjectileBaseState);
			MethodInfo method = typeFromHandle.GetMethod("ModifyProjectileInfo", (BindingFlags)(-1), null, new Type[1] { typeof(FireProjectileInfo).MakeByRefType() }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.GenericProjectileBaseState", "ModifyProjectileInfo");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.BasicMeleeAttack
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(BasicMeleeAttack self);

		public delegate void PostfixSignature(BasicMeleeAttack self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BasicMeleeAttack);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.BasicMeleeAttack", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
		public delegate void PrefixSignature(BasicMeleeAttack self);

		public delegate void PostfixSignature(BasicMeleeAttack self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BasicMeleeAttack);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.BasicMeleeAttack", "OnEnter");
			}
			return method;
		}
	}
	internal static class AuthorityFireAttack
	{
		public delegate void PrefixSignature(BasicMeleeAttack self);

		public delegate void PostfixSignature(BasicMeleeAttack self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BasicMeleeAttack);
			MethodInfo method = typeFromHandle.GetMethod("AuthorityFireAttack", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.BasicMeleeAttack", "AuthorityFireAttack");
			}
			return method;
		}
	}
	internal static class AuthorityModifyOverlapAttack
	{
		public delegate void PrefixSignature(BasicMeleeAttack self, ref OverlapAttack overlapAttack);

		public delegate void PostfixSignature(BasicMeleeAttack self, ref OverlapAttack overlapAttack);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BasicMeleeAttack);
			MethodInfo method = typeFromHandle.GetMethod("AuthorityModifyOverlapAttack", (BindingFlags)(-1), null, new Type[1] { typeof(OverlapAttack) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.BasicMeleeAttack", "AuthorityModifyOverlapAttack");
			}
			return method;
		}
	}
	internal static class OnExit
	{
		public delegate void PrefixSignature(BasicMeleeAttack self);

		public delegate void PostfixSignature(BasicMeleeAttack self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(BasicMeleeAttack);
			MethodInfo method = typeFromHandle.GetMethod("OnExit", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.BasicMeleeAttack", "OnExit");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.Swift.Stuck
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(Stuck self);

		public delegate void PostfixSignature(Stuck self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Stuck);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.Swift.Stuck", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
		public delegate void PrefixSignature(Stuck self);

		public delegate void PostfixSignature(Stuck self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Stuck);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.Swift.Stuck", "OnEnter");
			}
			return method;
		}
	}
	internal static class OnExit
	{
		public delegate void PrefixSignature(Stuck self);

		public delegate void PostfixSignature(Stuck self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Stuck);
			MethodInfo method = typeFromHandle.GetMethod("OnExit", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.Swift.Stuck", "OnExit");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.Swift.FlyingToDive
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(FlyingToDive self);

		public delegate void PostfixSignature(FlyingToDive self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(FlyingToDive);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.Swift.FlyingToDive", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
		public delegate void PrefixSignature(FlyingToDive self);

		public delegate void PostfixSignature(FlyingToDive self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(FlyingToDive);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.Swift.FlyingToDive", "OnEnter");
			}
			return method;
		}
	}
	internal static class OnExit
	{
		public delegate void PrefixSignature(FlyingToDive self);

		public delegate void PostfixSignature(FlyingToDive self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(FlyingToDive);
			MethodInfo method = typeFromHandle.GetMethod("OnExit", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.Swift.FlyingToDive", "OnExit");
			}
			return method;
		}
	}
	internal static class ExecuteSlamEffect
	{
		public delegate void PrefixSignature(FlyingToDive self, ref Vector3 vector3);

		public delegate void PostfixSignature(FlyingToDive self, ref Vector3 vector3);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(FlyingToDive);
			MethodInfo method = typeFromHandle.GetMethod("ExecuteSlamEffect", (BindingFlags)(-1), null, new Type[1] { typeof(Vector3) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.Swift.FlyingToDive", "ExecuteSlamEffect");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.ChampRushReaper.Haunt4CastEnter
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(Haunt4CastEnter self);

		public delegate void PostfixSignature(Haunt4CastEnter self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Haunt4CastEnter);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.ChampRushReaper.Haunt4CastEnter", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
		public delegate void PrefixSignature(Haunt4CastEnter self);

		public delegate void PostfixSignature(Haunt4CastEnter self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Haunt4CastEnter);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.ChampRushReaper.Haunt4CastEnter", "OnEnter");
			}
			return method;
		}
	}
	internal static class OnExit
	{
		public delegate void PrefixSignature(Haunt4CastEnter self);

		public delegate void PostfixSignature(Haunt4CastEnter self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Haunt4CastEnter);
			MethodInfo method = typeFromHandle.GetMethod("OnExit", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.ChampRushReaper.Haunt4CastEnter", "OnExit");
			}
			return method;
		}
	}
}
namespace Mdh.EntityStates.ChampRushReaper.Reap2
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(Reap2 self);

		public d