using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.RocketSurvivorSkills.Primary;
using EntityStates.Toolbot;
using IL.RoR2;
using IL.RoR2.Items;
using LordsItemEdits.ItemEdits;
using LordsItemEdits.ModSupport.RiskyTweaksMod;
using LordsItemEdits.ModSupport.RocketSurvivorGuy;
using LordsItemEdits.ModSupport.Starstorm2;
using LordsItemEdits.MultiItemEdits;
using Microsoft.CodeAnalysis;
using MiscFixes.Modules;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using MonoDetourHooks.EntityStates.RocketSurvivorSkills.Primary.FireRocket;
using MonoDetourHooks.RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM;
using MonoDetourHooks.RoR2.GlobalEventManager;
using MonoDetourHooks.RoR2.HealthComponent;
using MonoDetourHooks.RoR2.Inventory;
using MonoDetourHooks.RoR2.Items.MultiShopCardUtils;
using MonoDetourHooks.RoR2.MissileUtils;
using MonoDetourHooks.SS2.Items.ArmedBackpack.Behavior;
using MonoDetourHooks.SS2.Items.ErraticGadget;
using MonoMod.Cil;
using On.EntityStates.Toolbot;
using On.RoR2;
using On.RoR2.Orbs;
using R2API;
using RiskyTweaks.Tweaks.Survivors.Toolbot;
using RoR2;
using RoR2.CharacterAI;
using RoR2.ContentManagement;
using RoR2.Items;
using RoR2.Orbs;
using RoR2BepInExPack.GameAssetPathsBetter;
using RoR2BepInExPack.Utilities;
using SS2;
using SS2.Items;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MonoDetourHooks.SS2.Items.ErraticGadget
{
	internal static class get_AssetRequest
	{
		public delegate void PrefixSignature(ErraticGadget self);

		public delegate ReturnFlow ControlFlowPrefixSignature(ErraticGadget self, ref SS2AssetRequest returnValue);

		public delegate void PostfixSignature(ErraticGadget self, ref SS2AssetRequest returnValue);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ErraticGadget);
			MethodInfo method = typeFromHandle.GetMethod("get_AssetRequest", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("SS2.Items.ErraticGadget", "get_AssetRequest");
			}
			return method;
		}
	}
	internal static class Initialize
	{
		public delegate void PrefixSignature(ErraticGadget self);

		public delegate ReturnFlow ControlFlowPrefixSignature(ErraticGadget self);

		public delegate void PostfixSignature(ErraticGadget self);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ErraticGadget);
			MethodInfo method = typeFromHandle.GetMethod("Initialize", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("SS2.Items.ErraticGadget", "Initialize");
			}
			return method;
		}
	}
	internal static class LightningOrb_OnArrival
	{
		public delegate void PrefixSignature(ErraticGadget self, ref orig_OnArrival orig, ref LightningOrb self1);

		public delegate ReturnFlow ControlFlowPrefixSignature(ErraticGadget self, ref orig_OnArrival orig, ref LightningOrb self1);

		public delegate void PostfixSignature(ErraticGadget self, ref orig_OnArrival orig, ref LightningOrb self1);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ErraticGadget);
			MethodInfo method = typeFromHandle.GetMethod("LightningOrb_OnArrival", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(orig_OnArrival),
				typeof(LightningOrb)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("SS2.Items.ErraticGadget", "LightningOrb_OnArrival");
			}
			return method;
		}
	}
	internal static class LightningStrikeOrb_OnArrival
	{
		public delegate void PrefixSignature(ErraticGadget self, ref orig_OnArrival orig, ref LightningStrikeOrb self1);

		public delegate ReturnFlow ControlFlowPrefixSignature(ErraticGadget self, ref orig_OnArrival orig, ref LightningStrikeOrb self1);

		public delegate void PostfixSignature(ErraticGadget self, ref orig_OnArrival orig, ref LightningStrikeOrb self1);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ErraticGadget);
			MethodInfo method = typeFromHandle.GetMethod("LightningStrikeOrb_OnArrival", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(orig_OnArrival),
				typeof(LightningStrikeOrb)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("SS2.Items.ErraticGadget", "LightningStrikeOrb_OnArrival");
			}
			return method;
		}
	}
	internal static class SimpleLightningStrikeOrb_OnArrival
	{
		public delegate void PrefixSignature(ErraticGadget self, ref orig_OnArrival orig, ref SimpleLightningStrikeOrb self1);

		public delegate ReturnFlow ControlFlowPrefixSignature(ErraticGadget self, ref orig_OnArrival orig, ref SimpleLightningStrikeOrb self1);

		public delegate void PostfixSignature(ErraticGadget self, ref orig_OnArrival orig, ref SimpleLightningStrikeOrb self1);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ErraticGadget);
			MethodInfo method = typeFromHandle.GetMethod("SimpleLightningStrikeOrb_OnArrival", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(orig_OnArrival),
				typeof(SimpleLightningStrikeOrb)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("SS2.Items.ErraticGadget", "SimpleLightningStrikeOrb_OnArrival");
			}
			return method;
		}
	}
	internal static class VoidLightningOrb_Begin
	{
		public delegate void PrefixSignature(ErraticGadget self, ref orig_Begin orig, ref VoidLightningOrb self1);

		public delegate ReturnFlow ControlFlowPrefixSignature(ErraticGadget self, ref orig_Begin orig, ref VoidLightningOrb self1);

		public delegate void PostfixSignature(ErraticGadget self, ref orig_Begin orig, ref VoidLightningOrb self1);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ErraticGadget);
			MethodInfo method = typeFromHandle.GetMethod("VoidLightningOrb_Begin", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(orig_Begin),
				typeof(VoidLightningOrb)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("SS2.Items.ErraticGadget", "VoidLightningOrb_Begin");
			}
			return method;
		}
	}
	internal static class _ctor
	{
		public delegate void PrefixSignature(ErraticGadget self);

		public delegate ReturnFlow ControlFlowPrefixSignature(ErraticGadget self);

		public delegate void PostfixSignature(ErraticGadget self);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ErraticGadget);
			ConstructorInfo constructor = typeFromHandle.GetConstructor((BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)constructor == null)
			{
				throw new MissingMethodException("SS2.Items.ErraticGadget", ".ctor");
			}
			return constructor;
		}
	}
	internal static class _cctor
	{
		public delegate void PrefixSignature();

		public delegate ReturnFlow ControlFlowPrefixSignature();

		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(), (MethodBase)hook.Method, config, applyByDefault);
		}

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ErraticGadget);
			ConstructorInfo constructor = typeFromHandle.GetConstructor((BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)constructor == null)
			{
				throw new MissingMethodException("SS2.Items.ErraticGadget", ".cctor");
			}
			return constructor;
		}
	}
	internal static class Behavior
	{
		internal static class GetItemDef
		{
			public delegate void PrefixSignature();

			public delegate ReturnFlow ControlFlowPrefixSignature(ref ItemDef returnValue);

			public delegate void PostfixSignature(ref ItemDef returnValue);

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

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

			public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(Behavior);
				MethodInfo method = typeFromHandle.GetMethod("GetItemDef", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
				if ((object)method == null)
				{
					throw new MissingMethodException("SS2.Items.ErraticGadget+Behavior", "GetItemDef");
				}
				return method;
			}
		}

		internal static class GetMuzzleTransform
		{
			public delegate void PrefixSignature(Behavior self);

			public delegate ReturnFlow ControlFlowPrefixSignature(Behavior self, ref Transform returnValue);

			public delegate void PostfixSignature(Behavior self, ref Transform returnValue);

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

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

			public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(Behavior);
				MethodInfo method = typeFromHandle.GetMethod("GetMuzzleTransform", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
				if ((object)method == null)
				{
					throw new MissingMethodException("SS2.Items.ErraticGadget+Behavior", "GetMuzzleTransform");
				}
				return method;
			}
		}

		internal static class OnDamageDealtServer
		{
			public delegate void PrefixSignature(Behavior self, ref DamageReport report);

			public delegate ReturnFlow ControlFlowPrefixSignature(Behavior self, ref DamageReport report);

			public delegate void PostfixSignature(Behavior self, ref DamageReport report);

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

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

			public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(Behavior);
				MethodInfo method = typeFromHandle.GetMethod("OnDamageDealtServer", (BindingFlags)(-1), null, new Type[1] { typeof(DamageReport) }, null);
				if ((object)method == null)
				{
					throw new MissingMethodException("SS2.Items.ErraticGadget+Behavior", "OnDamageDealtServer");
				}
				return method;
			}
		}

		internal static class _ctor
		{
			public delegate void PrefixSignature(Behavior self);

			public delegate ReturnFlow ControlFlowPrefixSignature(Behavior self);

			public delegate void PostfixSignature(Behavior self);

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

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

			public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(Behavior);
				ConstructorInfo constructor = typeFromHandle.GetConstructor((BindingFlags)(-1), null, Array.Empty<Type>(), null);
				if ((object)constructor == null)
				{
					throw new MissingMethodException("SS2.Items.ErraticGadget+Behavior", ".ctor");
				}
				return constructor;
			}
		}
	}
	internal static class GadgetLightningOrb
	{
		internal static class Begin
		{
			public delegate void PrefixSignature(GadgetLightningOrb self);

			public delegate ReturnFlow ControlFlowPrefixSignature(GadgetLightningOrb self);

			public delegate void PostfixSignature(GadgetLightningOrb self);

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

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

			public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GadgetLightningOrb);
				MethodInfo method = typeFromHandle.GetMethod("Begin", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
				if ((object)method == null)
				{
					throw new MissingMethodException("SS2.Items.ErraticGadget+GadgetLightningOrb", "Begin");
				}
				return method;
			}
		}

		internal static class OnArrival
		{
			public delegate void PrefixSignature(GadgetLightningOrb self);

			public delegate ReturnFlow ControlFlowPrefixSignature(GadgetLightningOrb self);

			public delegate void PostfixSignature(GadgetLightningOrb self);

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

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

			public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GadgetLightningOrb);
				MethodInfo method = typeFromHandle.GetMethod("OnArrival", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
				if ((object)method == null)
				{
					throw new MissingMethodException("SS2.Items.ErraticGadget+GadgetLightningOrb", "OnArrival");
				}
				return method;
			}
		}

		internal static class PickNextTarget
		{
			public delegate void PrefixSignature(GadgetLightningOrb self, ref Vector3 position);

			public delegate ReturnFlow ControlFlowPrefixSignature(GadgetLightningOrb self, ref Vector3 position, ref HurtBox returnValue);

			public delegate void PostfixSignature(GadgetLightningOrb self, ref Vector3 position, ref HurtBox returnValue);

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

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

			public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GadgetLightningOrb);
				MethodInfo method = typeFromHandle.GetMethod("PickNextTarget", (BindingFlags)(-1), null, new Type[1] { typeof(Vector3) }, null);
				if ((object)method == null)
				{
					throw new MissingMethodException("SS2.Items.ErraticGadget+GadgetLightningOrb", "PickNextTarget");
				}
				return method;
			}
		}

		internal static class _ctor
		{
			public delegate void PrefixSignature(GadgetLightningOrb self);

			public delegate ReturnFlow ControlFlowPrefixSignature(GadgetLightningOrb self);

			public delegate void PostfixSignature(GadgetLightningOrb self);

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

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

			public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GadgetLightningOrb);
				ConstructorInfo constructor = typeFromHandle.GetConstructor((BindingFlags)(-1), null, Array.Empty<Type>(), null);
				if ((object)constructor == null)
				{
					throw new MissingMethodException("SS2.Items.ErraticGadget+GadgetLightningOrb", ".ctor");
				}
				return constructor;
			}
		}
	}
}
namespace MonoDetourHooks.SS2.Items.ArmedBackpack.Behavior
{
	internal static class GetItemDef
	{
		public delegate void PrefixSignature();

		public delegate void PostfixSignature(ref ItemDef returnValue);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(Behavior);
			MethodInfo method = typeFromHandle.GetMethod("GetItemDef", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("SS2.Items.ArmedBackpack+Behavior", "GetItemDef");
			}
			return method;
		}
	}
	internal static class OnTakeDamageServer
	{
		public delegate void PrefixSignature(Behavior self, ref DamageReport damageReport);

		public delegate void PostfixSignature(Behavior self, ref DamageReport damageReport);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(Behavior);
			MethodInfo method = typeFromHandle.GetMethod("OnTakeDamageServer", (BindingFlags)(-1), null, new Type[1] { typeof(DamageReport) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("SS2.Items.ArmedBackpack+Behavior", "OnTakeDamageServer");
			}
			return method;
		}
	}
	internal static class _ctor
	{
		public delegate void PrefixSignature(Behavior self);

		public delegate void PostfixSignature(Behavior self);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(Behavior);
			ConstructorInfo constructor = typeFromHandle.GetConstructor((BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)constructor == null)
			{
				throw new MissingMethodException("SS2.Items.ArmedBackpack+Behavior", ".ctor");
			}
			return constructor;
		}
	}
}
namespace MonoDetourHooks.EntityStates.RocketSurvivorSkills.Primary.FireRocket
{
	internal static class OnEnter
	{
		public delegate void PrefixSignature(FireRocket self);

		public delegate void PostfixSignature(FireRocket self);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(FireRocket);
			MethodInfo method = typeFromHandle.GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.RocketSurvivorSkills.Primary.FireRocket", "OnEnter");
			}
			return method;
		}
	}
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(FireRocket self);

		public delegate void PostfixSignature(FireRocket self);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(FireRocket);
			MethodInfo method = typeFromHandle.GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.RocketSurvivorSkills.Primary.FireRocket", "FixedUpdate");
			}
			return method;
		}
	}
	internal static class GetMinimumInterruptPriority
	{
		public delegate void PrefixSignature(FireRocket self);

		public delegate void PostfixSignature(FireRocket self, ref InterruptPriority returnValue);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(FireRocket);
			MethodInfo method = typeFromHandle.GetMethod("GetMinimumInterruptPriority", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.RocketSurvivorSkills.Primary.FireRocket", "GetMinimumInterruptPriority");
			}
			return method;
		}
	}
	internal static class _ctor
	{
		public delegate void PrefixSignature(FireRocket self);

		public delegate void PostfixSignature(FireRocket self);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(FireRocket);
			ConstructorInfo constructor = typeFromHandle.GetConstructor((BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)constructor == null)
			{
				throw new MissingMethodException("EntityStates.RocketSurvivorSkills.Primary.FireRocket", ".ctor");
			}
			return constructor;
		}
	}
	internal static class _cctor
	{
		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(), (MethodBase)hook.Method, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(FireRocket);
			ConstructorInfo constructor = typeFromHandle.GetConstructor((BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)constructor == null)
			{
				throw new MissingMethodException("EntityStates.RocketSurvivorSkills.Primary.FireRocket", ".cctor");
			}
			return constructor;
		}
	}
}
namespace MonoDetourHooks.RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM
{
	internal static class get_ConfigCategoryString
	{
		public delegate void PrefixSignature(ScrapICBM self);

		public delegate ReturnFlow ControlFlowPrefixSignature(ScrapICBM self, ref string returnValue);

		public delegate void PostfixSignature(ScrapICBM self, ref string returnValue);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ScrapICBM);
			MethodInfo method = typeFromHandle.GetMethod("get_ConfigCategoryString", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM", "get_ConfigCategoryString");
			}
			return method;
		}
	}
	internal static class get_ConfigOptionName
	{
		public delegate void PrefixSignature(ScrapICBM self);

		public delegate ReturnFlow ControlFlowPrefixSignature(ScrapICBM self, ref string returnValue);

		public delegate void PostfixSignature(ScrapICBM self, ref string returnValue);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ScrapICBM);
			MethodInfo method = typeFromHandle.GetMethod("get_ConfigOptionName", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM", "get_ConfigOptionName");
			}
			return method;
		}
	}
	internal static class get_ConfigDescriptionString
	{
		public delegate void PrefixSignature(ScrapICBM self);

		public delegate ReturnFlow ControlFlowPrefixSignature(ScrapICBM self, ref string returnValue);

		public delegate void PostfixSignature(ScrapICBM self, ref string returnValue);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ScrapICBM);
			MethodInfo method = typeFromHandle.GetMethod("get_ConfigDescriptionString", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM", "get_ConfigDescriptionString");
			}
			return method;
		}
	}
	internal static class get_StopLoadOnConfigDisable
	{
		public delegate void PrefixSignature(ScrapICBM self);

		public delegate ReturnFlow ControlFlowPrefixSignature(ScrapICBM self, ref bool returnValue);

		public delegate void PostfixSignature(ScrapICBM self, ref bool returnValue);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ScrapICBM);
			MethodInfo method = typeFromHandle.GetMethod("get_StopLoadOnConfigDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM", "get_StopLoadOnConfigDisable");
			}
			return method;
		}
	}
	internal static class ApplyChanges
	{
		public delegate void PrefixSignature(ScrapICBM self);

		public delegate ReturnFlow ControlFlowPrefixSignature(ScrapICBM self);

		public delegate void PostfixSignature(ScrapICBM self);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ScrapICBM);
			MethodInfo method = typeFromHandle.GetMethod("ApplyChanges", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM", "ApplyChanges");
			}
			return method;
		}
	}
	internal static class FireGrenadeLauncher_ModifyProjectileAimRay
	{
		public delegate void PrefixSignature(ScrapICBM self, ref orig_ModifyProjectileAimRay orig, ref FireGrenadeLauncher self1, ref Ray aimRay);

		public delegate ReturnFlow ControlFlowPrefixSignature(ScrapICBM self, ref orig_ModifyProjectileAimRay orig, ref FireGrenadeLauncher self1, ref Ray aimRay, ref Ray returnValue);

		public delegate void PostfixSignature(ScrapICBM self, ref orig_ModifyProjectileAimRay orig, ref FireGrenadeLauncher self1, ref Ray aimRay, ref Ray returnValue);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ScrapICBM);
			MethodInfo method = typeFromHandle.GetMethod("FireGrenadeLauncher_ModifyProjectileAimRay", (BindingFlags)(-1), null, new Type[3]
			{
				typeof(orig_ModifyProjectileAimRay),
				typeof(FireGrenadeLauncher),
				typeof(Ray)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM", "FireGrenadeLauncher_ModifyProjectileAimRay");
			}
			return method;
		}
	}
	internal static class _ctor
	{
		public delegate void PrefixSignature(ScrapICBM self);

		public delegate ReturnFlow ControlFlowPrefixSignature(ScrapICBM self);

		public delegate void PostfixSignature(ScrapICBM self);

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

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(ScrapICBM);
			ConstructorInfo constructor = typeFromHandle.GetConstructor((BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)constructor == null)
			{
				throw new MissingMethodException("RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM", ".ctor");
			}
			return constructor;
		}
	}
}
namespace MonoDetourHooks.RoR2.MissileUtils
{
	internal static class FireMissile_UnityEngine_Vector3_RoR2_CharacterBody_RoR2_ProcChainMask_UnityEngine_GameObject_System_Single_System_Boolean_UnityEngine_GameObject_RoR2_DamageColorIndex_System_Boolean
	{
		public delegate void PrefixSignature(ref Vector3 position, ref CharacterBody attackerBody, ref ProcChainMask procChainMask, ref GameObject victim, ref float missileDamage, ref bool isCrit, ref GameObject projectilePrefab, ref DamageColorIndex damageColorIndex, ref bool addMissileProc);

		public delegate void PostfixSignature(ref Vector3 position, ref CharacterBody attackerBody, ref ProcChainMask procChainMask, ref GameObject victim, ref float missileDamage, ref bool isCrit, ref GameObject projectilePrefab, ref DamageColorIndex damageColorIndex, ref bool addMissileProc);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(MissileUtils);
			MethodInfo method = typeFromHandle.GetMethod("FireMissile", (BindingFlags)(-1), null, new Type[9]
			{
				typeof(Vector3),
				typeof(CharacterBody),
				typeof(ProcChainMask),
				typeof(GameObject),
				typeof(float),
				typeof(bool),
				typeof(GameObject),
				typeof(DamageColorIndex),
				typeof(bool)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.MissileUtils", "FireMissile");
			}
			return method;
		}
	}
	internal static class FireMissile_UnityEngine_Vector3_RoR2_CharacterBody_RoR2_ProcChainMask_UnityEngine_GameObject_System_Single_System_Boolean_UnityEngine_GameObject_RoR2_DamageColorIndex_UnityEngine_Vector3_System_Single_System_Boolean
	{
		public delegate void PrefixSignature(ref Vector3 position, ref CharacterBody attackerBody, ref ProcChainMask procChainMask, ref GameObject victim, ref float missileDamage, ref bool isCrit, ref GameObject projectilePrefab, ref DamageColorIndex damageColorIndex, ref Vector3 initialDirection, ref float force, ref bool addMissileProc);

		public delegate void PostfixSignature(ref Vector3 position, ref CharacterBody attackerBody, ref ProcChainMask procChainMask, ref GameObject victim, ref float missileDamage, ref bool isCrit, ref GameObject projectilePrefab, ref DamageColorIndex damageColorIndex, ref Vector3 initialDirection, ref float force, ref bool addMissileProc);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(MissileUtils);
			MethodInfo method = typeFromHandle.GetMethod("FireMissile", (BindingFlags)(-1), null, new Type[11]
			{
				typeof(Vector3),
				typeof(CharacterBody),
				typeof(ProcChainMask),
				typeof(GameObject),
				typeof(float),
				typeof(bool),
				typeof(GameObject),
				typeof(DamageColorIndex),
				typeof(Vector3),
				typeof(float),
				typeof(bool)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.MissileUtils", "FireMissile");
			}
			return method;
		}
	}
}
namespace MonoDetourHooks.RoR2.GlobalEventManager
{
	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(), (MethodBase)hook.Method, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "Init");
			}
			return method;
		}
	}
	internal static class OnEnable
	{
		public delegate void PrefixSignature(GlobalEventManager self);

		public delegate void PostfixSignature(GlobalEventManager self);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnEnable", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnEnable");
			}
			return method;
		}
	}
	internal static class OnDisable
	{
		public delegate void PrefixSignature(GlobalEventManager self);

		public delegate void PostfixSignature(GlobalEventManager self);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnDisable");
			}
			return method;
		}
	}
	internal static class IsImmuneToFallDamage
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref CharacterBody body);

		public delegate void PostfixSignature(GlobalEventManager self, ref CharacterBody body, ref bool returnValue);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("IsImmuneToFallDamage", (BindingFlags)(-1), null, new Type[1] { typeof(CharacterBody) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "IsImmuneToFallDamage");
			}
			return method;
		}
	}
	internal static class OnHitEnemy
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject victim);

		public delegate void PostfixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject victim);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnHitEnemy", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(DamageInfo),
				typeof(GameObject)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnHitEnemy");
			}
			return method;
		}
	}
	internal static class ProcessHitEnemy
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject victim);

		public delegate void PostfixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject victim);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("ProcessHitEnemy", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(DamageInfo),
				typeof(GameObject)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "ProcessHitEnemy");
			}
			return method;
		}
	}
	internal static class ProcDeathMark
	{
		public delegate void PrefixSignature(ref GameObject victim, ref CharacterBody victimBody, ref CharacterMaster attackerMaster);

		public delegate void PostfixSignature(ref GameObject victim, ref CharacterBody victimBody, ref CharacterMaster attackerMaster);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("ProcDeathMark", (BindingFlags)(-1), null, new Type[3]
			{
				typeof(GameObject),
				typeof(CharacterBody),
				typeof(CharacterMaster)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "ProcDeathMark");
			}
			return method;
		}
	}
	internal static class FrozenExplosion
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref float explosionRadius, ref CharacterBody victimBody);

		public delegate void PostfixSignature(GlobalEventManager self, ref float explosionRadius, ref CharacterBody victimBody);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("FrozenExplosion", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(float),
				typeof(CharacterBody)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "FrozenExplosion");
			}
			return method;
		}
	}
	internal static class HandleDamageWithNoAttacker
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject victim);

		public delegate void PostfixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject victim);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("HandleDamageWithNoAttacker", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(DamageInfo),
				typeof(GameObject)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "HandleDamageWithNoAttacker");
			}
			return method;
		}
	}
	internal static class OnCharacterHitGroundServer
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref CharacterBody characterBody, ref HitGroundInfo hitGroundInfo);

		public delegate void PostfixSignature(GlobalEventManager self, ref CharacterBody characterBody, ref HitGroundInfo hitGroundInfo);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnCharacterHitGroundServer", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(CharacterBody),
				typeof(HitGroundInfo)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnCharacterHitGroundServer");
			}
			return method;
		}
	}
	internal static class OnCharacterHitGroundSFX
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref CharacterBody characterBody, ref HitGroundInfo hitGroundInfo, ref bool tookFallDamage);

		public delegate void PostfixSignature(GlobalEventManager self, ref CharacterBody characterBody, ref HitGroundInfo hitGroundInfo, ref bool tookFallDamage);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnCharacterHitGroundSFX", (BindingFlags)(-1), null, new Type[3]
			{
				typeof(CharacterBody),
				typeof(HitGroundInfo),
				typeof(bool)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnCharacterHitGroundSFX");
			}
			return method;
		}
	}
	internal static class OnCharacterHitGround
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref CharacterBody characterBody, ref Vector3 impactVelocity);

		public delegate void PostfixSignature(GlobalEventManager self, ref CharacterBody characterBody, ref Vector3 impactVelocity);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnCharacterHitGround", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(CharacterBody),
				typeof(Vector3)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnCharacterHitGround");
			}
			return method;
		}
	}
	internal static class OnPlayerCharacterDeath
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref DamageReport damageReport, ref NetworkUser victimNetworkUser);

		public delegate void PostfixSignature(GlobalEventManager self, ref DamageReport damageReport, ref NetworkUser victimNetworkUser);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnPlayerCharacterDeath", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(DamageReport),
				typeof(NetworkUser)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnPlayerCharacterDeath");
			}
			return method;
		}
	}
	internal static class add_onCharacterDeathGlobal
	{
		public delegate void PrefixSignature(ref Action<DamageReport> value);

		public delegate void PostfixSignature(ref Action<DamageReport> value);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("add_onCharacterDeathGlobal", (BindingFlags)(-1), null, new Type[1] { typeof(Action<DamageReport>) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "add_onCharacterDeathGlobal");
			}
			return method;
		}
	}
	internal static class remove_onCharacterDeathGlobal
	{
		public delegate void PrefixSignature(ref Action<DamageReport> value);

		public delegate void PostfixSignature(ref Action<DamageReport> value);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("remove_onCharacterDeathGlobal", (BindingFlags)(-1), null, new Type[1] { typeof(Action<DamageReport>) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "remove_onCharacterDeathGlobal");
			}
			return method;
		}
	}
	internal static class ProcIgniteOnKill
	{
		public delegate void PrefixSignature(ref DamageReport damageReport, ref int igniteOnKillCount, ref CharacterBody victimBody, ref TeamIndex attackerTeamIndex);

		public delegate void PostfixSignature(ref DamageReport damageReport, ref int igniteOnKillCount, ref CharacterBody victimBody, ref TeamIndex attackerTeamIndex);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("ProcIgniteOnKill", (BindingFlags)(-1), null, new Type[4]
			{
				typeof(DamageReport),
				typeof(int),
				typeof(CharacterBody),
				typeof(TeamIndex)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "ProcIgniteOnKill");
			}
			return method;
		}
	}
	internal static class OnCharacterDeath
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref DamageReport damageReport);

		public delegate void PostfixSignature(GlobalEventManager self, ref DamageReport damageReport);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnCharacterDeath", (BindingFlags)(-1), null, new Type[1] { typeof(DamageReport) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnCharacterDeath");
			}
			return method;
		}
	}
	internal static class OnHitAll
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject hitObject);

		public delegate void PostfixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject hitObject);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnHitAll", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(DamageInfo),
				typeof(GameObject)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnHitAll");
			}
			return method;
		}
	}
	internal static class OnHitAllProcess
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject hitObject);

		public delegate void PostfixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject hitObject);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnHitAllProcess", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(DamageInfo),
				typeof(GameObject)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnHitAllProcess");
			}
			return method;
		}
	}
	internal static class OnCrit
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref CharacterBody body, ref DamageInfo damageInfo, ref CharacterMaster master, ref float procCoefficient, ref ProcChainMask procChainMask);

		public delegate void PostfixSignature(GlobalEventManager self, ref CharacterBody body, ref DamageInfo damageInfo, ref CharacterMaster master, ref float procCoefficient, ref ProcChainMask procChainMask);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnCrit", (BindingFlags)(-1), null, new Type[5]
			{
				typeof(CharacterBody),
				typeof(DamageInfo),
				typeof(CharacterMaster),
				typeof(float),
				typeof(ProcChainMask)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnCrit");
			}
			return method;
		}
	}
	internal static class OnTeamLevelUp
	{
		public delegate void PrefixSignature(ref TeamIndex teamIndex);

		public delegate void PostfixSignature(ref TeamIndex teamIndex);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnTeamLevelUp", (BindingFlags)(-1), null, new Type[1] { typeof(TeamIndex) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnTeamLevelUp");
			}
			return method;
		}
	}
	internal static class add_onTeamLevelUp
	{
		public delegate void PrefixSignature(ref Action<TeamIndex> value);

		public delegate void PostfixSignature(ref Action<TeamIndex> value);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("add_onTeamLevelUp", (BindingFlags)(-1), null, new Type[1] { typeof(Action<TeamIndex>) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "add_onTeamLevelUp");
			}
			return method;
		}
	}
	internal static class remove_onTeamLevelUp
	{
		public delegate void PrefixSignature(ref Action<TeamIndex> value);

		public delegate void PostfixSignature(ref Action<TeamIndex> value);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("remove_onTeamLevelUp", (BindingFlags)(-1), null, new Type[1] { typeof(Action<TeamIndex>) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "remove_onTeamLevelUp");
			}
			return method;
		}
	}
	internal static class OnCharacterLevelUp
	{
		public delegate void PrefixSignature(ref CharacterBody characterBody);

		public delegate void PostfixSignature(ref CharacterBody characterBody);

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

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (MethodBase)hook.Method, 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(GlobalEventManager);
			MethodInfo method = typeFromHandle.GetMethod("OnCharacterLevelUp", (BindingFlags)(-1), null, new Type[1] { typeof(CharacterBody) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.GlobalEventManager", "OnCharacterLevelUp");
			}
			return method;
		}
	}
	internal static class add_onCharacterLevelUp
	{
		public delegate void PrefixSignature(ref Action<CharacterBody> value);

		public delegate void PostfixSignature(ref Action<CharacterBody> value);

		publi