using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates.GoldGat;
using EntityStates.QuestVolatileBattery;
using Mdh.EntityStates.GoldGat.GoldGatFire;
using Mdh.EntityStates.QuestVolatileBattery.CountDown;
using Mdh.RoR2.AffixAurelioniteBehavior;
using Mdh.RoR2.CharacterBody;
using Mdh.RoR2.DamageTrail;
using Mdh.RoR2.EquipmentSlot;
using Mdh.RoR2.FireballVehicle;
using Mdh.RoR2.GlobalEventManager;
using Mdh.RoR2.MissileUtils;
using Mdh.RoR2.Orbs.LightningStrikeOrb;
using Microsoft.CodeAnalysis;
using MiscFixes.Modules;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.Cil.Analysis;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using MonoMod.Cil;
using R2API;
using RoR2;
using RoR2.ContentManagement;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2BepInExPack.GameAssetPathsBetter;
using RoR2BepInExPack.Utilities;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

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

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

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

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

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

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

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

	bool ICollection<T>.IsReadOnly => true;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Mdh.EntityStates.GoldGat.GoldGatFire
{
	internal static class FireBullet
	{
		public delegate void PrefixSignature(GoldGatFire self);

		public delegate void PostfixSignature(GoldGatFire self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(GoldGatFire);
			MethodInfo method = typeFromHandle.GetMethod("FireBullet", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.GoldGat.GoldGatFire", "FireBullet");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
	}
	internal static class Update
	{
	}
	internal static class OnExit
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
}
namespace Mdh.EntityStates.QuestVolatileBattery.CountDown
{
	internal static class Detonate
	{
		public delegate void PrefixSignature(CountDown self);

		public delegate void PostfixSignature(CountDown self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(CountDown);
			MethodInfo method = typeFromHandle.GetMethod("Detonate", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("EntityStates.QuestVolatileBattery.CountDown", "Detonate");
			}
			return method;
		}
	}
	internal static class OnEnter
	{
	}
	internal static class OnExit
	{
	}
	internal static class FixedUpdate
	{
	}
	internal static class FixedUpdateServer
	{
	}
	internal static class _ctor
	{
	}
}
namespace Mdh.RoR2.Orbs.LightningStrikeOrb
{
	internal static class OnArrival
	{
		public delegate void PrefixSignature(LightningStrikeOrb self);

		public delegate void PostfixSignature(LightningStrikeOrb self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(LightningStrikeOrb);
			MethodInfo method = typeFromHandle.GetMethod("OnArrival", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.Orbs.LightningStrikeOrb", "OnArrival");
			}
			return method;
		}
	}
	internal static class Begin
	{
	}
	internal static class GetOrbEffect
	{
	}
	internal static class FixedUpdate
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
}
namespace Mdh.RoR2.MissileUtils
{
	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(), (Delegate)hook, config, applyByDefault);
		}

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(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;
		}
	}
	internal static class GetMoreMissileDamageMultiplier
	{
	}
	internal static class FireMissile_UnityEngine_Vector3_RoR2_CharacterBody_RoR2_ProcChainMask_UnityEngine_GameObject_System_Single_System_Boolean_UnityEngine_GameObject_RoR2_DamageColorIndex_System_Boolean
	{
	}
}
namespace Mdh.RoR2.EquipmentSlot
{
	internal static class FireMissile
	{
		public delegate void PrefixSignature(EquipmentSlot self);

		public delegate void PostfixSignature(EquipmentSlot self);

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

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

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

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

		public delegate void PostfixSignature(EquipmentSlot 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(), (Delegate)hook, config, applyByDefault);
		}

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

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

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

		public delegate void PostfixSignature(EquipmentSlot self, ref float deltaTime);

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

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

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

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

		public delegate void PostfixSignature(EquipmentSlot 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(), (Delegate)hook, config, applyByDefault);
		}

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(EquipmentSlot);
			MethodInfo method = typeFromHandle.GetMethod("FireVendingMachine", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.EquipmentSlot", "FireVendingMachine");
			}
			return method;
		}
	}
	internal static class _FireSaw_g__FireSingleSaw_107_0
	{
		public delegate void PrefixSignature(EquipmentSlot self, ref CharacterBody firingCharacterBody, ref Vector3 origin, ref Quaternion rotation);

		public delegate void PostfixSignature(EquipmentSlot self, ref CharacterBody firingCharacterBody, ref Vector3 origin, ref Quaternion rotation);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(EquipmentSlot);
			MethodInfo method = typeFromHandle.GetMethod("<FireSaw>g__FireSingleSaw|107_0", (BindingFlags)(-1), null, new Type[3]
			{
				typeof(CharacterBody),
				typeof(Vector3),
				typeof(Quaternion)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.EquipmentSlot", "<FireSaw>g__FireSingleSaw|107_0");
			}
			return method;
		}
	}
	internal static class get_activeEquipmentSlot
	{
	}
	internal static class get_activeEquipmentSet
	{
	}
	internal static class get_activeEquipmentLocation
	{
	}
	internal static class set_activeEquipmentLocation
	{
	}
	internal static class get_equipmentIndex
	{
	}
	internal static class set_equipmentIndex
	{
	}
	internal static class get_stock
	{
	}
	internal static class set_stock
	{
	}
	internal static class get_maxStock
	{
	}
	internal static class set_maxStock
	{
	}
	internal static class get_equipmentDisabled
	{
	}
	internal static class OnStartServer
	{
	}
	internal static class OnStartAuthority
	{
	}
	internal static class OnStopAuthority
	{
	}
	internal static class UpdateAuthority
	{
	}
	internal static class UpdateInventory
	{
	}
	internal static class get_characterBody
	{
	}
	internal static class set_characterBody
	{
	}
	internal static class UpdateGoldGat
	{
	}
	internal static class get_cooldownTimer
	{
	}
	internal static class FindActiveEquipmentDisplay
	{
	}
	internal static class RpcOnClientEquipmentActivationRecieved
	{
	}
	internal static class Start
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class FixedUpdate
	{
	}
	internal static class CmdExecuteAllIfReady
	{
	}
	internal static class ExecuteAllIfReady
	{
	}
	internal static class CmdExecuteIfReady
	{
	}
	internal static class ExecuteIfReady
	{
	}
	internal static class Execute
	{
	}
	internal static class CmdOnEquipmentExecuted
	{
	}
	internal static class OnEquipmentExecuted
	{
	}
	internal static class OnEquipmentExecuted_System_Byte_System_Byte_RoR2_EquipmentIndex
	{
	}
	internal static class OnEquipmentExecuted_in_RoR2_EquipmentLocation_RoR2_EquipmentIndex
	{
	}
	internal static class add_onServerEquipmentActivated
	{
	}
	internal static class remove_onServerEquipmentActivated
	{
	}
	internal static class add_onServerEquipmentActivatedDetailed
	{
	}
	internal static class remove_onServerEquipmentActivatedDetailed
	{
	}
	internal static class PerformEquipmentAction
	{
	}
	internal static class GetAimRay
	{
	}
	internal static class SummonMaster
	{
	}
	internal static class ConfigureTargetFinderBase
	{
	}
	internal static class ConfigureTargetFinderForEnemies
	{
	}
	internal static class ConfigureTargetFinderForBossesWithRewards
	{
	}
	internal static class ConfigureTargetFinderForFriendlies
	{
	}
	internal static class InvalidateCurrentTarget
	{
	}
	internal static class UpdateTargets
	{
	}
	internal static class FindPickupController
	{
	}
	internal static class Update
	{
	}
	internal static class SetFireEquipmentResult
	{
	}
	internal static class FireCommandMissile
	{
	}
	internal static class FireFruit
	{
	}
	internal static class FireDroneBackup
	{
	}
	internal static class FireMeteor
	{
	}
	internal static class FireBlackhole
	{
	}
	internal static class FireSaw
	{
	}
	internal static class FireOrbitalLaser
	{
	}
	internal static class FireGhostGun
	{
	}
	internal static class FireCritOnUse
	{
	}
	internal static class FireBfg
	{
	}
	internal static class FireJetpack
	{
	}
	internal static class FireLightning
	{
	}
	internal static class FireBossHunter
	{
	}
	internal static class RpcBrotherParryBossHunter
	{
	}
	internal static class FireBossHunterConsumed
	{
	}
	internal static class FirePassiveHealing
	{
	}
	internal static class FireBurnNearby
	{
	}
	internal static class FireSoulCorruptor
	{
	}
	internal static class FireScanner
	{
	}
	internal static class FireCrippleWard
	{
	}
	internal static class FireTonic
	{
	}
	internal static class FireCleanse
	{
	}
	internal static class FireFireBallDash
	{
	}
	internal static class FireGainArmor
	{
	}
	internal static class FireRecycle
	{
	}
	internal static class FireGateway
	{
	}
	internal static class FireLifeStealOnHit
	{
	}
	internal static class FireTeamWarCry
	{
	}
	internal static class FireDeathProjectile
	{
	}
	internal static class FireGummyClone
	{
	}
	internal static class FireLunarPortalOnUse
	{
	}
	internal static class FireHealAndRevive
	{
	}
	internal static class FireGroundEnemies
	{
	}
	internal static class FireDroneShockDamage
	{
	}
	internal static class FireSpawnAltarPlacement
	{
	}
	internal static class FireSpawnAltarConsumed
	{
	}
	internal static class FireSproutOfLife
	{
	}
	internal static class FireParry
	{
	}
	internal static class FireAurelioniteSpike
	{
	}
	internal static class FireCollectivePulse
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class _FireGateway_g__ToggleAttackSpeedPerNearbyCollider_127_0
	{
	}
	internal static class UNetVersion
	{
	}
	internal static class InvokeCmdCmdExecuteAllIfReady
	{
	}
	internal static class InvokeCmdCmdExecuteIfReady
	{
	}
	internal static class InvokeCmdCmdOnEquipmentExecuted
	{
	}
	internal static class CallCmdExecuteAllIfReady
	{
	}
	internal static class CallCmdExecuteIfReady
	{
	}
	internal static class CallCmdOnEquipmentExecuted
	{
	}
	internal static class InvokeRpcRpcOnClientEquipmentActivationRecieved
	{
	}
	internal static class InvokeRpcRpcBrotherParryBossHunter
	{
	}
	internal static class CallRpcOnClientEquipmentActivationRecieved
	{
	}
	internal static class CallRpcBrotherParryBossHunter
	{
	}
	internal static class OnSerialize
	{
	}
	internal static class OnDeserialize
	{
	}
	internal static class PreStartClient
	{
	}
	internal static class FireEquipmentResult
	{
		internal static class _ctor
		{
		}
	}
	internal static class EquipmentActivatedDetailedDelegate
	{
		internal static class _ctor
		{
		}

		internal static class Invoke
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class NetUserTargetInfo
	{
		internal static class _ctor
		{
		}

		internal static class get_childIndex
		{
		}

		internal static class set_childIndex
		{
		}

		internal static class CreateFrom
		{
		}

		internal static class TryResolveTargetInfo
		{
		}

		internal static class _cctor
		{
		}
	}
	internal static class UserTargetInfo
	{
		internal static class _ctor
		{
		}

		internal static class _ctor_UnityEngine_GameObject
		{
		}

		internal static class _ctor_ChildLocator_System_Int32
		{
		}

		internal static class _ctor_RoR2_HurtBox
		{
		}

		internal static class _ctor_RoR2_GenericPickupController
		{
		}
	}
	internal static class UserTargetType
	{
		internal static class _ctor
		{
		}
	}
	internal static class HealAndReviveLock
	{
		internal static class FixedUpdate
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass126_0
	{
		internal static class _ctor
		{
		}

		internal static class _FireRecycle_b__0
		{
		}
	}
	internal static class __c__DisplayClass127_0
	{
		internal static class _ctor
		{
		}
	}
}
namespace Mdh.RoR2.GlobalEventManager
{
	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(), (Delegate)hook, config, applyByDefault);
		}

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(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 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(), (Delegate)hook, config, applyByDefault);
		}

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(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 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(), (Delegate)hook, config, applyByDefault);
		}

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(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 Init
	{
		public delegate void PrefixSignature();

		public delegate void PostfixSignature();

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(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
	{
	}
	internal static class IsImmuneToFallDamage
	{
	}
	internal static class OnHitEnemy
	{
	}
	internal static class ProcessHitEnemy
	{
	}
	internal static class ProcDeathMark
	{
	}
	internal static class FrozenExplosion
	{
	}
	internal static class HandleDamageWithNoAttacker
	{
	}
	internal static class CalculateImpactOverspeed_System_Single_RoR2_CharacterBody
	{
	}
	internal static class CalculateImpactOverspeed_System_Single_System_Single
	{
	}
	internal static class OnCharacterHitGroundServer
	{
	}
	internal static class OnCharacterHitGroundSFX
	{
	}
	internal static class OnCharacterHitGround
	{
	}
	internal static class OnPlayerCharacterDeath
	{
	}
	internal static class add_onCharacterDeathGlobal
	{
	}
	internal static class remove_onCharacterDeathGlobal
	{
	}
	internal static class add_onDeathProcServer
	{
	}
	internal static class remove_onDeathProcServer
	{
	}
	internal static class add_onCharacterDeathServer
	{
	}
	internal static class remove_onCharacterDeathServer
	{
	}
	internal static class ProcIgniteOnKill
	{
	}
	internal static class ProcBarrierEnemiesOnKill
	{
	}
	internal static class TriggerCharacterDeathProc
	{
	}
	internal static class HandleCharacterDeath
	{
	}
	internal static class OnHitAll
	{
	}
	internal static class OnCrit
	{
	}
	internal static class OnTeamLevelUp
	{
	}
	internal static class add_onTeamLevelUp
	{
	}
	internal static class remove_onTeamLevelUp
	{
	}
	internal static class OnCharacterLevelUp
	{
	}
	internal static class add_onCharacterLevelUp
	{
	}
	internal static class remove_onCharacterLevelUp
	{
	}
	internal static class OnCharacterPickupItem
	{
	}
	internal static class add_onCharacterPickupItem
	{
	}
	internal static class remove_onCharacterPickupItem
	{
	}
	internal static class add_OnInteractionsGlobal
	{
	}
	internal static class remove_OnInteractionsGlobal
	{
	}
	internal static class add_OnInteractionsPermittedForSpawnGlobal
	{
	}
	internal static class remove_OnInteractionsPermittedForSpawnGlobal
	{
	}
	internal static class OnInteractionBegin
	{
	}
	internal static class InteractableIsPermittedForSpawn_UnityEngine_MonoBehaviour
	{
	}
	internal static class InteractableIsPermittedForSpawn_UnityEngine_MonoBehaviour_RoR2_InteractionProcFilter
	{
	}
	internal static class add_onClientDamageNotified
	{
	}
	internal static class remove_onClientDamageNotified
	{
	}
	internal static class ClientDamageNotified
	{
	}
	internal static class add_onServerDamageDealt
	{
	}
	internal static class remove_onServerDamageDealt
	{
	}
	internal static class ServerDamageDealt
	{
	}
	internal static class add_onServerCharacterExecuted
	{
	}
	internal static class remove_onServerCharacterExecuted
	{
	}
	internal static class ServerCharacterExecuted
	{
	}
	internal static class add_onCharacterDepossessed
	{
	}
	internal static class remove_onCharacterDepossessed
	{
	}
	internal static class CharacterDepossessed
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class _ProcessHitEnemy_g__LocalCheckRoll_10_0
	{
	}
	internal static class _OnCharacterDeath_g__LocalCheckRoll_37_0
	{
	}
	internal static class CommonAssets
	{
		internal static class Load
		{
		}

		internal static class __c
		{
			internal static class _cctor
			{
			}

			internal static class _ctor
			{
			}

			internal static class _Load_b__23_0
			{
			}

			internal static class _Load_b__23_1
			{
			}

			internal static class _Load_b__23_2
			{
			}

			internal static class _Load_b__23_3
			{
			}

			internal static class _Load_b__23_4
			{
			}

			internal static class _Load_b__23_5
			{
			}

			internal static class _Load_b__23_6
			{
			}

			internal static class _Load_b__23_7
			{
			}

			internal static class _Load_b__23_8
			{
			}

			internal static class _Load_b__23_9
			{
			}

			internal static class _Load_b__23_10
			{
			}

			internal static class _Load_b__23_11
			{
			}

			internal static class _Load_b__23_12
			{
			}

			internal static class _Load_b__23_13
			{
			}

			internal static class _Load_b__23_14
			{
			}

			internal static class _Load_b__23_15
			{
			}

			internal static class _Load_b__23_16
			{
			}

			internal static class _Load_b__23_17
			{
			}

			internal static class _Load_b__23_18
			{
			}

			internal static class _Load_b__23_19
			{
			}

			internal static class _Load_b__23_20
			{
			}

			internal static class _Load_b__23_21
			{
			}

			internal static class _Load_b__23_22
			{
			}
		}
	}
	internal static class __c__DisplayClass10_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass37_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass37_1
	{
		internal static class _ctor
		{
		}

		internal static class _OnCharacterDeath_b__1
		{
		}
	}
	internal static class __c__DisplayClass61_0
	{
		internal static class _ctor
		{
		}

		internal static class _OnInteractionBegin_b__0
		{
		}
	}
	internal static class __c
	{
		internal static class _cctor
		{
		}

		internal static class _ctor
		{
		}

		internal static class __cctor_b__81_0
		{
		}

		internal static class __cctor_b__81_1
		{
		}
	}
}
namespace Mdh.RoR2.FireballVehicle
{
	internal static class Awake
	{
		public delegate void PrefixSignature(FireballVehicle self);

		public delegate void PostfixSignature(FireballVehicle self);

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

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

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

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

		public delegate void PostfixSignature(FireballVehicle self, ref GameObject passenger);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(FireballVehicle);
			MethodInfo method = typeFromHandle.GetMethod("OnPassengerEnter", (BindingFlags)(-1), null, new Type[1] { typeof(GameObject) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.FireballVehicle", "OnPassengerEnter");
			}
			return method;
		}
	}
	internal static class DetonateServer
	{
		public delegate void PrefixSignature(FireballVehicle self);

		public delegate void PostfixSignature(FireballVehicle self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(FireballVehicle);
			MethodInfo method = typeFromHandle.GetMethod("DetonateServer", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.FireballVehicle", "DetonateServer");
			}
			return method;
		}
	}
	internal static class OnPassengerExit
	{
	}
	internal static class FixedUpdate
	{
	}
	internal static class OnCollisionEnter
	{
	}
	internal static class GetCameraState
	{
	}
	internal static class IsUserLookAllowed
	{
	}
	internal static class IsUserControlAllowed
	{
	}
	internal static class IsHudAllowed
	{
	}
	internal static class _ctor
	{
	}
}
namespace Mdh.RoR2.CharacterBody
{
	internal static class Awake
	{
		public delegate void PrefixSignature(CharacterBody self);

		public delegate void PostfixSignature(CharacterBody self);

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

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

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

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

			public delegate void PostfixSignature(AffixEchoBehavior self);

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

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

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

			public static MethodBase Target()
			{
				Type typeFromHandle = typeof(AffixEchoBehavior);
				MethodInfo method = typeFromHandle.GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
				if ((object)method == null)
				{
					throw new MissingMethodException("RoR2.CharacterBody+AffixEchoBehavior", "Awake");
				}
				return method;
			}
		}

		internal static class OnDisable
		{
			public delegate void PrefixSignature(AffixEchoBehavior self);

			public delegate void PostfixSignature(AffixEchoBehavior self);

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

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

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

			public static MethodBase Target()
			{
				Type typeFromHandle = typeof(AffixEchoBehavior);
				MethodInfo method = typeFromHandle.GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
				if ((object)method == null)
				{
					throw new MissingMethodException("RoR2.CharacterBody+AffixEchoBehavior", "OnDisable");
				}
				return method;
			}
		}

		internal static class FixedUpdate
		{
		}

		internal static class OnEnable
		{
		}

		internal static class CreateSpawners
		{
		}

		internal static class DestroySpawners
		{
		}

		internal static class OnMinionSpawnedServer
		{
		}

		internal static class _ctor
		{
		}

		internal static class _CreateSpawners_g__CreateSpawner_7_0
		{
		}

		internal static class __c__DisplayClass7_0
		{
			internal static class _ctor
			{
			}
		}

		internal static class __c__DisplayClass10_0
		{
			internal static class _ctor
			{
			}

			internal static class _OnMinionSpawnedServer_b__0
			{
			}
		}
	}
	internal static class OnDisable
	{
		public delegate void PrefixSignature(CharacterBody self);

		public delegate void PostfixSignature(CharacterBody self);

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

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

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

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

			public delegate void PostfixSignature(AffixHauntedBehavior self);

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

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

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

			public static MethodBase Target()
			{
				Type typeFromHandle = typeof(AffixHauntedBehavior);
				MethodInfo method = typeFromHandle.GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
				if ((object)method == null)
				{
					throw new MissingMethodException("RoR2.CharacterBody+AffixHauntedBehavior", "OnDisable");
				}
				return method;
			}
		}

		internal static class FixedUpdate
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class UpdateFireTrail
	{
		public delegate void PrefixSignature(CharacterBody self);

		public delegate void PostfixSignature(CharacterBody self);

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

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

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

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

		public delegate void PostfixSignature(CharacterBody self, ref float deltaTime);

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

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

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

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

		public delegate void PostfixSignature();

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

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

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

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

			public delegate void PostfixSignature();

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

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

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

			public static MethodBase Target()
			{
				Type typeFromHandle = typeof(ScaleTransitionManager);
				MethodInfo method = typeFromHandle.GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
				if ((object)method == null)
				{
					throw new MissingMethodException("RoR2.CharacterBody+ScaleTransitionManager", "Init");
				}
				return method;
			}
		}

		internal static class CharacterBody_onBodyStartGlobal
		{
		}

		internal static class StaticFixedUpdate
		{
		}

		internal static class TryGetTransitionIndexByBody
		{
		}

		internal static class GetTransitionIndexForValidBody
		{
		}

		internal static class StartScaleTransition
		{
		}

		internal static class _cctor
		{
		}

		internal static class ScaleTransitionInfo
		{
			internal static class _ctor
			{
			}
		}
	}
	internal static class GetBody
	{
	}
	internal static class add_onRecalculateStats
	{
	}
	internal static class remove_onRecalculateStats
	{
	}
	internal static class DebugDrawLine
	{
	}
	internal static class LoadCommonAssets
	{
	}
	internal static class GetDisplayName
	{
	}
	internal static class GetSubtitle
	{
	}
	internal static class GetUserName
	{
	}
	internal static class GetColoredUserName
	{
	}
	internal static class add_OnJump
	{
	}
	internal static class remove_OnJump
	{
	}
	internal static class TriggerJumpEventGlobally
	{
	}
	internal static class RpcTriggerJumpEvent
	{
	}
	internal static class CmdTriggerJumpEvent
	{
	}
	internal static class WriteMiscStats
	{
	}
	internal static class ReadMiscStats
	{
	}
	internal static class WriteBuffs
	{
	}
	internal static class ReadBuffs
	{
	}
	internal static class AddBuffAuthority
	{
	}
	internal static class CmdAddBuffAuthority
	{
	}
	internal static class AddBuff_RoR2_BuffIndex
	{
	}
	internal static class AddBuff_RoR2_BuffDef
	{
	}
	internal static class RemoveBuff_RoR2_BuffIndex
	{
	}
	internal static class RemoveBuffInternal
	{
	}
	internal static class RemoveBuff_RoR2_BuffDef
	{
	}
	internal static class RemoveBuffAuthority
	{
	}
	internal static class CmdRemoveBuffAuthority
	{
	}
	internal static class AddUnmanagedBuff_RoR2_BuffIndex_System_Int32
	{
	}
	internal static class AddUnmanagedBuff_RoR2_BuffDef_System_Int32
	{
	}
	internal static class RemoveUnmanagedBuff_RoR2_BuffIndex_System_Int32
	{
	}
	internal static class RemoveUnmanagedBuff_RoR2_BuffDef_System_Int32
	{
	}
	internal static class SetBuffCount
	{
	}
	internal static class CacheBuffs
	{
	}
	internal static class ApplyCacheBuffsServer
	{
	}
	internal static class add_onBuffFirstStackGained
	{
	}
	internal static class remove_onBuffFirstStackGained
	{
	}
	internal static class OnBuffFirstStackGained
	{
	}
	internal static class add_onBuffFinalStackLost
	{
	}
	internal static class remove_onBuffFinalStackLost
	{
	}
	internal static class OnBuffFinalStackLost
	{
	}
	internal static class HandleCascadingBuffs
	{
	}
	internal static class AddOrRemoveEliteItemBehavior
	{
	}
	internal static class GetBuffCount_RoR2_BuffIndex
	{
	}
	internal static class GetBuffCount_RoR2_BuffDef
	{
	}
	internal static class HasBuff_RoR2_BuffIndex
	{
	}
	internal static class HasBuff_RoR2_BuffDef
	{
	}
	internal static class HasUnmanagedBuff_RoR2_BuffIndex
	{
	}
	internal static class HasUnmanagedBuff_RoR2_BuffDef
	{
	}
	internal static class AddTimedBuffAuthority
	{
	}
	internal static class CmdAddTimedBuff
	{
	}
	internal static class AddTimedBuff_RoR2_BuffDef_System_Single_System_Int32
	{
	}
	internal static class AddTimedBuffDontRefreshDuration
	{
	}
	internal static class ExtendTimedBuffIfPresent_RoR2_BuffDef_System_Single
	{
	}
	internal static class SetTimedBuffDurationIfPresent
	{
	}
	internal static class ExtendTimedBuffIfPresent_RoR2_BuffDef_System_Single_System_Single
	{
	}
	internal static class AddTimedBuff_RoR2_BuffDef_System_Single
	{
	}
	internal static class AddTimedBuffInternal
	{
	}
	internal static class AddTimedBuff_RoR2_BuffIndex_System_Single
	{
	}
	internal static class TryGetTimedBuffHighestTotalDuration
	{
	}
	internal static class GetTimedBuffTotalDurationForIndex
	{
	}
	internal static class ClearTimedBuffs_RoR2_BuffIndex
	{
	}
	internal static class ClearTimedBuffs_RoR2_BuffDef
	{
	}
	internal static class RemoveOldestTimedBuff_RoR2_BuffIndex
	{
	}
	internal static class RemoveOldestTimedBuff_RoR2_BuffDef
	{
	}
	internal static class UpdateBuffs
	{
	}
	internal static class OnClientBuffsChanged
	{
	}
	internal static class get_master
	{
	}
	internal static class GetMasterObjectId
	{
	}
	internal static class get_inventory
	{
	}
	internal static class set_inventory
	{
	}
	internal static class get_keyItemSlot
	{
	}
	internal static class set_keyItemSlot
	{
	}
	internal static class get_isPlayerControlled
	{
	}
	internal static class set_isPlayerControlled
	{
	}
	internal static class get_executeEliteHealthFraction
	{
	}
	internal static class set_executeEliteHealthFraction
	{
	}
	internal static class get_IsDrone
	{
	}
	internal static class get_isRemoteOp
	{
	}
	internal static class set_isRemoteOp
	{
	}
	internal static class CheckHandlingConfig
	{
	}
	internal static class GetOwnerBody
	{
	}
	internal static class GetMinionBodies
	{
	}
	internal static class GetSelectedCharacterType
	{
	}
	internal static class UpdateHurtBoxesEnabled
	{
	}
	internal static class OnInventoryChanged
	{
	}
	internal static class ReplaceSkillIfItemPresent
	{
	}
	internal static class OnEquipmentLost
	{
	}
	internal static class OnEquipmentGained
	{
	}
	internal static class add_onInventoryChanged
	{
	}
	internal static class remove_onInventoryChanged
	{
	}
	internal static class get_masterObject
	{
	}
	internal static class set_masterObject
	{
	}
	internal static class UpdateMasterLink
	{
	}
	internal static class SetNewMaster
	{
	}
	internal static class get_rigidbody
	{
	}
	internal static class set_rigidbody
	{
	}
	internal static class get_networkIdentity
	{
	}
	internal static class set_networkIdentity
	{
	}
	internal static class get_characterMotor
	{
	}
	internal static class set_characterMotor
	{
	}
	internal static class get_characterDirection
	{
	}
	internal static class set_characterDirection
	{
	}
	internal static class get_teamComponent
	{
	}
	internal static class set_teamComponent
	{
	}
	internal static class get_healthComponent
	{
	}
	internal static class set_healthComponent
	{
	}
	internal static class get_equipmentSlot
	{
	}
	internal static class set_equipmentSlot
	{
	}
	internal static class get_inputBank
	{
	}
	internal static class set_inputBank
	{
	}
	internal static class get_skillLocator
	{
	}
	internal static class set_skillLocator
	{
	}
	internal static class get_sfxLocator
	{
	}
	internal static class set_sfxLocator
	{
	}
	internal static class get_modelLocator
	{
	}
	internal static class set_modelLocator
	{
	}
	internal static class get_hurtBoxGroup
	{
	}
	internal static class set_hurtBoxGroup
	{
	}
	internal static class get_mainHurtBox
	{
	}
	internal static class set_mainHurtBox
	{
	}
	internal static class get_coreTransform
	{
	}
	internal static class set_coreTransform
	{
	}
	internal static class OnModelChanged
	{
	}
	internal static class Start
	{
	}
	internal static class Update
	{
	}
	internal static class UpdateNotMoving
	{
	}
	internal static class DoItemUpdates
	{
	}
	internal static class UpdateOutOfCombatAndDanger
	{
	}
	internal static class CmdSetInLava
	{
	}
	internal static class SetInLava
	{
	}
	internal static class InflictLavaDamage
	{
	}
	internal static class HandleLavaDamage
	{
	}
	internal static class UpdateItemAvailability
	{
	}
	internal static class FixedUpdate
	{
	}
	internal static class OnDeathStart
	{
	}
	internal static class OnTakeDamageServer
	{
	}
	internal static class add_onSkillActivatedServer
	{
	}
	internal static class remove_onSkillActivatedServer
	{
	}
	internal static class add_onSkillActivatedAuthority
	{
	}
	internal static class remove_onSkillActivatedAuthority
	{
	}
	internal static class ForceSkillActivatedAction
	{
	}
	internal static class OnSkillActivated
	{
	}
	internal static class OnSkillCooldown
	{
	}
	internal static class add_onReleaseBodyTriggeredServer
	{
	}
	internal static class remove_onReleaseBodyTriggeredServer
	{
	}
	internal static class OnReleaseBodyTriggered
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class DebugCollectInventory
	{
	}
	internal static class GetNormalizedThreatValue
	{
	}
	internal static class OnEnable
	{
	}
	internal static class OnValidate
	{
	}
	internal static class add_onBodyAwakeGlobal
	{
	}
	internal static class remove_onBodyAwakeGlobal
	{
	}
	internal static class add_onBodyDestroyGlobal
	{
	}
	internal static class remove_onBodyDestroyGlobal
	{
	}
	internal static class add_onBodyStartGlobal
	{
	}
	internal static class remove_onBodyStartGlobal
	{
	}
	internal static class add_onBodyInventoryChangedGlobal
	{
	}
	internal static class remove_onBodyInventoryChangedGlobal
	{
	}
	internal static class get_hasEffectiveAuthority
	{
	}
	internal static class set_hasEffectiveAuthority
	{
	}
	internal static class UpdateAuthority
	{
	}
	internal static class OnStartAuthority
	{
	}
	internal static class OnStopAuthority
	{
	}
	internal static class add_onSprintChanged
	{
	}
	internal static class remove_onSprintChanged
	{
	}
	internal static class get_isSprinting
	{
	}
	internal static class set_isSprinting
	{
	}
	internal static class OnSprintChanged
	{
	}
	internal static class OnSprintStart
	{
	}
	internal static class OnSprintStop
	{
	}
	internal static class CmdUpdateSprint
	{
	}
	internal static class CmdOnSkillActivated
	{
	}
	internal static class get_speedOnPickupLimit
	{
	}
	internal static class add_onPickupServer
	{
	}
	internal static class remove_onPickupServer
	{
	}
	internal static class OnPickup
	{
	}
	internal static class RpcPlaySoundSpeedOnPickup
	{
	}
	internal static class get_outOfCombat
	{
	}
	internal static class set_outOfCombat
	{
	}
	internal static class get_outOfDanger
	{
	}
	internal static class set_outOfDanger
	{
	}
	internal static class OnOutOfDangerChanged
	{
	}
	internal static class OnOutOfCombatAndDangerServer
	{
	}
	internal static class GetNotMoving
	{
	}
	internal static class PerformAutoCalculateLevelStats
	{
	}
	internal static class get_experience
	{
	}
	internal static class set_experience
	{
	}
	internal static class get_level
	{
	}
	internal static class set_level
	{
	}
	internal static class get_maxHealth
	{
	}
	internal static class set_maxHealth
	{
	}
	internal static class get_maxBarrier
	{
	}
	internal static class set_maxBarrier
	{
	}
	internal static class get_barrierDecayRate
	{
	}
	internal static class set_barrierDecayRate
	{
	}
	internal static class get_maxHull
	{
	}
	internal static class set_maxHull
	{
	}
	internal static class get_regen
	{
	}
	internal static class set_regen
	{
	}
	internal static class get_maxShield
	{
	}
	internal static class set_maxShield
	{
	}
	internal static class get_moveSpeed
	{
	}
	internal static class set_moveSpeed
	{
	}
	internal static class get_acceleration
	{
	}
	internal static class set_acceleration
	{
	}
	internal static class get_surfaceSpeedBoost
	{
	}
	internal static class set_surfaceSpeedBoost
	{
	}
	internal static class get_jumpPower
	{
	}
	internal static class set_jumpPower
	{
	}
	internal static class get_maxJumpCount
	{
	}
	internal static class set_maxJumpCount
	{
	}
	internal static class get_maxJumpHeight
	{
	}
	internal static class set_maxJumpHeight
	{
	}
	internal static class get_damage
	{
	}
	internal static class set_damage
	{
	}
	internal static class get_attackSpeed
	{
	}
	internal static class set_attackSpeed
	{
	}
	internal static class get_crit
	{
	}
	internal static class set_crit
	{
	}
	internal static class get_critMultiplier
	{
	}
	internal static class set_critMultiplier
	{
	}
	internal static class get_bleedChance
	{
	}
	internal static class set_bleedChance
	{
	}
	internal static class get_armor
	{
	}
	internal static class set_armor
	{
	}
	internal static class get_visionDistance
	{
	}
	internal static class set_visionDistance
	{
	}
	internal static class get_critHeal
	{
	}
	internal static class set_critHeal
	{
	}
	internal static class get_cursePenalty
	{
	}
	internal static class set_cursePenalty
	{
	}
	internal static class get_hasOneShotProtection
	{
	}
	internal static class set_hasOneShotProtection
	{
	}
	internal static class get_isGlass
	{
	}
	internal static class set_isGlass
	{
	}
	internal static class get_oneShotProtectionFraction
	{
	}
	internal static class set_oneShotProtectionFraction
	{
	}
	internal static class get_canPerformBackstab
	{
	}
	internal static class set_canPerformBackstab
	{
	}
	internal static class get_canReceiveBackstab
	{
	}
	internal static class set_canReceiveBackstab
	{
	}
	internal static class get_maxBonusHealth
	{
	}
	internal static class set_maxBonusHealth
	{
	}
	internal static class get_currentScale
	{
	}
	internal static class set_currentScale
	{
	}
	internal static class get_invCurrentScale
	{
	}
	internal static class set_invCurrentScale
	{
	}
	internal static class get_desiredScale
	{
	}
	internal static class set_desiredScale
	{
	}
	internal static class MarkAllStatsDirty
	{
	}
	internal static class SetMaxHealth
	{
	}
	internal static class RecalculateStats
	{
	}
	internal static class HandleDisableAllSkillsDebuff
	{
	}
	internal static class OnTeamLevelChanged
	{
	}
	internal static class OnCalculatedLevelChanged
	{
	}
	internal static class OnLevelUp
	{
	}
	internal static class TryGiveFreeUnlockWhenLevelUp
	{
	}
	internal static class SetAimTimer
	{
	}
	internal static class get_shouldAim
	{
	}
	internal static class get_originalLayer
	{
	}
	internal static class set_originalLayer
	{
	}
	internal static class get_fakeActorCounter
	{
	}
	internal static class set_fakeActorCounter
	{
	}
	internal static class RestoreLayer
	{
	}
	internal static class SetFakeActor
	{
	}
	internal static class OnDeserialize
	{
	}
	internal static class OnSerialize
	{
	}
	internal static class TransmitItemBehavior
	{
	}
	internal static class ServerTransmitItemBehavior
	{
	}
	internal static class CmdTransmitItemBehavior
	{
	}
	internal static class RpcTransmitItemBehavior
	{
	}
	internal static class RpcTransmitItemBehaviorReliable
	{
	}
	internal static class InternalTransmitItemBehavior
	{
	}
	internal static class get_killCountServer
	{
	}
	internal static class set_killCountServer
	{
	}
	internal static class HandleOnKillEffectsServer
	{
	}
	internal static class OnKilledOtherServer
	{
	}
	internal static class AddHelfireDuration
	{
	}
	internal static class UpdateHelfire
	{
	}
	internal static class UpdateAffixLunar
	{
	}
	internal static class SetMoveSpeedOverride
	{
	}
	internal static class UpdateAllTemporaryVisualEffects
	{
	}
	internal static class UpdateSingleTemporaryVisualEffect_ref_RoR2_TemporaryVisualEffect_System_String_System_Single_System_Boolean_System_String
	{
	}
	internal static class UpdateSingleTemporaryVisualEffect_ref_RoR2_TemporaryVisualEffect_UnityEngine_GameObject_System_Single_System_Boolean_System_String
	{
	}
	internal static class get_hasCloakBuff
	{
	}
	internal static class get_hasUntargetableBuff
	{
	}
	internal static class HasUntargetableBuff
	{
	}
	internal static class GetVisibilityLevel_RoR2_CharacterBody
	{
	}
	internal static class GetVisibilityLevel_RoR2_TeamIndex
	{
	}
	internal static class AddSpreadBloom
	{
	}
	internal static class SetSpreadBloom
	{
	}
	internal static class UpdateSpreadBloom
	{
	}
	internal static class get_spreadBloomAngle
	{
	}
	internal static class get_defaultCrosshairPrefab
	{
	}
	internal static class set_defaultCrosshairPrefab
	{
	}
	internal static class SendConstructTurret
	{
	}
	internal static class HandleConstructTurret
	{
	}
	internal static class get_multiKillCount
	{
	}
	internal static class set_multiKillCount
	{
	}
	internal static class GetMaxIncreasedDamageMultiKillBuffsForCharacter
	{
	}
	internal static class GetIncreasedDamageFromMultiKillBuffsForCharacter
	{
	}
	internal static class get_increasedDamageKillCount
	{
	}
	internal static class set_increasedDamageKillCount
	{
	}
	internal static class get_increasedDamageKillCountBuff
	{
	}
	internal static class set_increasedDamageKillCountBuff
	{
	}
	internal static class AddIncreasedDamageMultiKillTime
	{
	}
	internal static class AddMultiKill
	{
	}
	internal static class UpdateMultiKill
	{
	}
	internal static class SetReapingBuffStatIncreases
	{
	}
	internal static class AddIncreasePrimaryDamageStack
	{
	}
	internal static class ResetIncreasePrimaryDamage
	{
	}
	internal static class UpdateDelayedDamage
	{
	}
	internal static class SpawnDelayedDamageEffect
	{
	}
	internal static class ServerSpawnDelayedDamageEffect
	{
	}
	internal static class CmdSpawnDelayedDamageEffect
	{
	}
	internal static class SecondHalfOfDelayedDamage
	{
	}
	internal static class UpdateSecondHalfOfDamage
	{
	}
	internal static class UpdateKnockBackHitVisualsAndGracePeriod
	{
	}
	internal static class UpdateKnockBackHitVisualsAndGracePeriod_System_Int32_System_Int32
	{
	}
	internal static class RpcTeleportWithLocalAuthority
	{
	}
	internal static class TeleportAwayFrom
	{
	}
	internal static class RunicLensUpdateVariables
	{
	}
	internal static class get_isSpawnPickupsMaxed
	{
	}
	internal static class add_onShardSpawnedEvent
	{
	}
	internal static class remove_onShardSpawnedEvent
	{
	}
	internal static class GetElusiveAntlersCurrentMaxStack
	{
	}
	internal static class RpcRequestShardInfoClient
	{
	}
	internal static class CmdSpawnShard
	{
	}
	internal static class SpawnShard
	{
	}
	internal static class RpcOnShardSpawnedClient
	{
	}
	internal static class OnShardDestroyed
	{
	}
	internal static class TriggerEnemyDebuffs
	{
	}
	internal static class CreateVineOrbChain
	{
	}
	internal static class ComputeTamperedHeartBonus
	{
	}
	internal static class AddFreeChestBuff
	{
	}
	internal static class get_hitOnJumpReady
	{
	}
	internal static class set_hitOnJumpReady
	{
	}
	internal static class DoHitOnJumpDamage
	{
	}
	internal static class CmdDoHitOnJumpDamage
	{
	}
	internal static class get_corePosition
	{
	}
	internal static class get_footPosition
	{
	}
	internal static class get_temporaryPathfindingFootpositionDoNotUseWillBePatchedOut
	{
	}
	internal static class get_baseRadius
	{
	}
	internal static class set_baseRadius
	{
	}
	internal static class get_radius
	{
	}
	internal static class set_radius
	{
	}
	internal static class get_baseHeight
	{
	}
	internal static class set_baseHeight
	{
	}
	internal static class get_height
	{
	}
	internal static class set_height
	{
	}
	internal static class get_bestFitRadius
	{
	}
	internal static class set_bestFitRadius
	{
	}
	internal static class get_bestFitActualRadius
	{
	}
	internal static class set_bestFitActualRadius
	{
	}
	internal static class get_bestFitRadiusSqrt
	{
	}
	internal static class set_bestFitRadiusSqrt
	{
	}
	internal static class UpdateSizeProperties
	{
	}
	internal static class get_aimOrigin
	{
	}
	internal static class get_isElite
	{
	}
	internal static class set_isElite
	{
	}
	internal static class get_isBoss
	{
	}
	internal static class get_isFlying
	{
	}
	internal static class RpcBark
	{
	}
	internal static class CmdRequestVehicleEjection
	{
	}
	internal static class RollCrit
	{
	}
	internal static class IsCullable
	{
	}
	internal static class IsActivelyCullable
	{
	}
	internal static class NearAnyPlayers
	{
	}
	internal static class CheckDroneHasItems
	{
	}
	internal static class RpcUsePreferredInitialStateType
	{
	}
	internal static class SetBodyStateToPreferredInitialState
	{
	}
	internal static class SetLoadoutServer
	{
	}
	internal static class ClearAllBuffs
	{
	}
	internal static class PreloadAssets
	{
	}
	internal static class get_localStartTime
	{
	}
	internal static class set_localStartTime
	{
	}
	internal static class get_hasStarted
	{
	}
	internal static class get_acceptEquipmentInput
	{
	}
	internal static class get_acceptKeyItemInput
	{
	}
	internal static class get_isEquipmentActivationAllowed
	{
	}
	internal static class get_isKeyItemActivationAllowed
	{
	}
	internal static class IsGhost
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class _ReadBuffs_g__ZeroBuffIndexRange_43_0
	{
	}
	internal static class _AddTimedBuffInternal_g__DefaultBehavior_84_0
	{
	}
	internal static class _AddTimedBuffInternal_g__RefreshStacks_84_1
	{
	}
	internal static class _RecalculateStats_g__CalculateAppliedBeadStats_490_0
	{
	}
	internal static class _HandleDisableAllSkillsDebuff_g__HandleSkillDisableState_491_0
	{
	}
	internal static class _UpdateKnockBackHitVisualsAndGracePeriod_g__Clear_709_0
	{
	}
	internal static class UNetVersion
	{
	}
	internal static class InvokeCmdCmdTriggerJumpEvent
	{
	}
	internal static class InvokeCmdCmdAddBuffAuthority
	{
	}
	internal static class InvokeCmdCmdRemoveBuffAuthority
	{
	}
	internal static class InvokeCmdCmdAddTimedBuff
	{
	}
	internal static class InvokeCmdCmdSetInLava
	{
	}
	internal static class InvokeCmdCmdUpdateSprint
	{
	}
	internal static class InvokeCmdCmdOnSkillActivated
	{
	}
	internal static class InvokeCmdCmdTransmitItemBehavior
	{
	}
	internal static class InvokeCmdCmdSpawnDelayedDamageEffect
	{
	}
	internal static class InvokeCmdCmdSpawnShard
	{
	}
	internal static class InvokeCmdCmdDoHitOnJumpDamage
	{
	}
	internal static class InvokeCmdCmdRequestVehicleEjection
	{
	}
	internal static class CallCmdTriggerJumpEvent
	{
	}
	internal static class CallCmdAddBuffAuthority
	{
	}
	internal static class CallCmdRemoveBuffAuthority
	{
	}
	internal static class CallCmdAddTimedBuff
	{
	}
	internal static class CallCmdSetInLava
	{
	}
	internal static class CallCmdUpdateSprint
	{
	}
	internal static class CallCmdOnSkillActivated
	{
	}
	internal static class CallCmdTransmitItemBehavior
	{
	}
	internal static class CallCmdSpawnDelayedDamageEffect
	{
	}
	internal static class CallCmdSpawnShard
	{
	}
	internal static class CallCmdDoHitOnJumpDamage
	{
	}
	internal static class CallCmdRequestVehicleEjection
	{
	}
	internal static class InvokeRpcRpcTriggerJumpEvent
	{
	}
	internal static class InvokeRpcRpcPlaySoundSpeedOnPickup
	{
	}
	internal static class InvokeRpcRpcTransmitItemBehavior
	{
	}
	internal static class InvokeRpcRpcTransmitItemBehaviorReliable
	{
	}
	internal static class InvokeRpcRpcTeleportWithLocalAuthority
	{
	}
	internal static class InvokeRpcRpcRequestShardInfoClient
	{
	}
	internal static class InvokeRpcRpcOnShardSpawnedClient
	{
	}
	internal static class InvokeRpcRpcBark
	{
	}
	internal static class InvokeRpcRpcUsePreferredInitialStateType
	{
	}
	internal static class CallRpcTriggerJumpEvent
	{
	}
	internal static class CallRpcPlaySoundSpeedOnPickup
	{
	}
	internal static class CallRpcTransmitItemBehavior
	{
	}
	internal static class CallRpcTransmitItemBehaviorReliable
	{
	}
	internal static class CallRpcTeleportWithLocalAuthority
	{
	}
	internal static class CallRpcRequestShardInfoClient
	{
	}
	internal static class CallRpcOnShardSpawnedClient
	{
	}
	internal static class CallRpcBark
	{
	}
	internal static class CallRpcUsePreferredInitialStateType
	{
	}
	internal static class PreStartClient
	{
	}
	internal static class CommonAssets
	{
		internal static class Load
		{
		}

		internal static class __c
		{
			internal static class _cctor
			{
			}

			internal static class _ctor
			{
			}

			internal static class _Load_b__48_0
			{
			}

			internal static class _Load_b__48_1
			{
			}

			internal static class _Load_b__48_2
			{
			}

			internal static class _Load_b__48_3
			{
			}

			internal static class _Load_b__48_4
			{
			}

			internal static class _Load_b__48_5
			{
			}

			internal static class _Load_b__48_6
			{
			}

			internal static class _Load_b__48_7
			{
			}

			internal static class _Load_b__48_8
			{
			}

			internal static class _Load_b__48_9
			{
			}

			internal static class _Load_b__48_10
			{
			}

			internal static class _Load_b__48_11
			{
			}

			internal static class _Load_b__48_12
			{
			}

			internal static class _Load_b__48_13
			{
			}

			internal static class _Load_b__48_14
			{
			}

			internal static class _Load_b__48_15
			{
			}

			internal static class _Load_b__48_16
			{
			}

			internal static class _Load_b__48_17
			{
			}

			internal static class _Load_b__48_18
			{
			}

			internal static class _Load_b__48_19
			{
			}

			internal static class _Load_b__48_20
			{
			}

			internal static class _Load_b__48_21
			{
			}

			internal static class _Load_b__48_22
			{
			}

			internal static class _Load_b__48_23
			{
			}

			internal static class _Load_b__48_24
			{
			}

			internal static class _Load_b__48_25
			{
			}

			internal static class _Load_b__48_26
			{
			}

			internal static class _Load_b__48_27
			{
			}

			internal static class _Load_b__48_28
			{
			}

			internal static class _Load_b__48_29
			{
			}

			internal static class _Load_b__48_30
			{
			}

			internal static class _Load_b__48_31
			{
			}

			internal static class _Load_b__48_32
			{
			}

			internal static class _Load_b__48_33
			{
			}

			internal static class _Load_b__48_34
			{
			}

			internal static class _Load_b__48_35
			{
			}

			internal static class _Load_b__48_36
			{
			}

			internal static class _Load_b__48_37
			{
			}

			internal static class _Load_b__48_38
			{
			}

			internal static class _Load_b__48_39
			{
			}

			internal static class _Load_b__48_40
			{
			}

			internal static class _Load_b__48_41
			{
			}

			internal static class _Load_b__48_42
			{
			}

			internal static class _Load_b__48_43
			{
			}

			internal static class _Load_b__48_44
			{
			}

			internal static class _Load_b__48_45
			{
			}
		}
	}
	internal static class JumpDelegate
	{
		internal static class _ctor
		{
		}

		internal static class Invoke
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class TimedBuff
	{
		internal static class _ctor
		{
		}
	}
	internal static class BodyFlags
	{
		internal static class _ctor
		{
		}
	}
	internal static class ItemAvailability
	{
		internal static class _ctor
		{
		}
	}
	internal static class PickupClass
	{
		internal static class _ctor
		{
		}
	}
	internal static class OnPickupArgs
	{
		internal static class _ctor
		{
		}
	}
	internal static class OnPickupCallback
	{
		internal static class _ctor
		{
		}

		internal static class Invoke
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class NetworkItemBehaviorData
	{
		internal static class _ctor
		{
		}

		internal static class get_messageID
		{
		}

		internal static class set_messageID
		{
		}

		internal static class get_itemIndex
		{
		}

		internal static class set_itemIndex
		{
		}

		internal static class get_buffIndex
		{
		}

		internal static class set_buffIndex
		{
		}

		internal static class _ctor_RoR2_ItemIndex_System_Single
		{
		}

		internal static class _ctor_RoR2_BuffIndex_System_Single
		{
		}

		internal static class _ctor_System_Int32_System_Single
		{
		}

		internal static class _ctor_RoR2_CharacterBody_NetworkItemBehaviorData_NetworkItemBehaviorMessageID_System_Single
		{
		}

		internal static class NetworkItemBehaviorMessageID
		{
			internal static class _ctor
			{
			}
		}
	}
	internal static class ItemBehavior
	{
		internal static class _ctor
		{
		}
	}
	internal static class QuestVolatileBatteryBehaviorServer
	{
		internal static class Start
		{
		}

		internal static class OnDestroy
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class AssetReferences
	{
		internal static class Resolve
		{
		}

		internal static class __c
		{
			internal static class _cctor
			{
			}

			internal static class _ctor
			{
			}

			internal static class _Resolve_b__66_0
			{
			}

			internal static class _Resolve_b__66_1
			{
			}

			internal static class _Resolve_b__66_2
			{
			}

			internal static class _Resolve_b__66_3
			{
			}

			internal static class _Resolve_b__66_4
			{
			}

			internal static class _Resolve_b__66_5
			{
			}

			internal static class _Resolve_b__66_6
			{
			}

			internal static class _Resolve_b__66_7
			{
			}

			internal static class _Resolve_b__66_8
			{
			}

			internal static class _Resolve_b__66_9
			{
			}

			internal static class _Resolve_b__66_10
			{
			}

			internal static class _Resolve_b__66_11
			{
			}

			internal static class _Resolve_b__66_12
			{
			}

			internal static class _Resolve_b__66_13
			{
			}

			internal static class _Resolve_b__66_14
			{
			}

			internal static class _Resolve_b__66_15
			{
			}

			internal static class _Resolve_b__66_16
			{
			}

			internal static class _Resolve_b__66_17
			{
			}

			internal static class _Resolve_b__66_18
			{
			}

			internal static class _Resolve_b__66_19
			{
			}

			internal static class _Resolve_b__66_20
			{
			}

			internal static class _Resolve_b__66_21
			{
			}

			internal static class _Resolve_b__66_22
			{
			}

			internal static class _Resolve_b__66_23
			{
			}

			internal static class _Resolve_b__66_24
			{
			}

			internal static class _Resolve_b__66_25
			{
			}

			internal static class _Resolve_b__66_26
			{
			}

			internal static class _Resolve_b__66_27
			{
			}

			internal static class _Resolve_b__66_28
			{
			}

			internal static class _Resolve_b__66_29
			{
			}

			internal static class _Resolve_b__66_30
			{
			}

			internal static class _Resolve_b__66_31
			{
			}

			internal static class _Resolve_b__66_32
			{
			}

			internal static class _Resolve_b__66_33
			{
			}

			internal static class _Resolve_b__66_34
			{
			}

			internal static class _Resolve_b__66_35
			{
			}

			internal static class _Resolve_b__66_36
			{
			}

			internal static class _Resolve_b__66_37
			{
			}

			internal static class _Resolve_b__66_38
			{
			}

			internal static class _Resolve_b__66_39
			{
			}

			internal static class _Resolve_b__66_40
			{
			}

			internal static class _Resolve_b__66_41
			{
			}

			internal static class _Resolve_b__66_42
			{
			}

			internal static class _Resolve_b__66_43
			{
			}

			internal static class _Resolve_b__66_44
			{
			}

			internal static class _Resolve_b__66_45
			{
			}

			internal static class _Resolve_b__66_46
			{
			}

			internal static class _Resolve_b__66_47
			{
			}

			internal static class _Resolve_b__66_48
			{
			}

			internal static class _Resolve_b__66_49
			{
			}

			internal static class _Resolve_b__66_50
			{
			}

			internal static class _Resolve_b__66_51
			{
			}

			internal static class _Resolve_b__66_52
			{
			}

			internal static class _Resolve_b__66_53
			{
			}

			internal static class _Resolve_b__66_54
			{
			}

			internal static class _Resolve_b__66_55
			{
			}

			internal static class _Resolve_b__66_56
			{
			}

			internal static class _Resolve_b__66_57
			{
			}

			internal static class _Resolve_b__66_58
			{
			}

			internal static class _Resolve_b__66_59
			{
			}

			internal static class _Resolve_b__66_60
			{
			}

			internal static class _Resolve_b__66_61
			{
			}

			internal static class _Resolve_b__66_62
			{
			}
		}
	}
	internal static class ConstructTurretMessage
	{
		internal static class _ctor
		{
		}

		internal static class Serialize
		{
		}

		internal static class Deserialize
		{
		}
	}
	internal static class DelayedDamageInfo
	{
		internal static class _ctor
		{
		}
	}
	internal static class OnShardSpawned
	{
		internal static class _ctor
		{
		}

		internal static class Invoke
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class CharacterBodyUnityEvent
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass43_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass84_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass490_0
	{
		internal static class _ctor
		{
		}
	}
}
namespace Mdh.RoR2.DamageTrail
{
	internal static class Awake
	{
		public delegate void PrefixSignature(DamageTrail self);

		public delegate void PostfixSignature(DamageTrail self);

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

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

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

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

		public delegate void PostfixSignature(DamageTrail self);

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

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

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

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

		public delegate void PostfixSignature(DamageTrail self, ref float damageInterval);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(DamageTrail);
			MethodInfo method = typeFromHandle.GetMethod("DoDamage", (BindingFlags)(-1), null, new Type[1] { typeof(float) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.DamageTrail", "DoDamage");
			}
			return method;
		}
	}
	internal static class MyFixedUpdate
	{
		public delegate void PrefixSignature(DamageTrail self, ref float deltaTime);

		public delegate void PostfixSignature(DamageTrail self, ref float deltaTime);

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

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

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

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

		public delegate void PostfixSignature();

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(DamageTrail);
			MethodInfo method = typeFromHandle.GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.DamageTrail", "Init");
			}
			return method;
		}
	}
	internal static class Start
	{
	}
	internal static class UpdateOptimizedDamageUpdateInterval
	{
	}
	internal static class FixedUpdate
	{
	}
	internal static class UpdateTrail
	{
	}
	internal static class UpdateLineRenderer
	{
	}
	internal static class AddPoint
	{
	}
	internal static class RemovePoint
	{
	}
	internal static class OnDrawGizmos
	{
	}
	internal static class _ctor
	{
	}
	internal static class TrailPoint
	{
		internal static class _ctor
		{
		}
	}
}
namespace Mdh.RoR2.AffixAurelioniteBehavior
{
	internal static class FireAurelioniteAttack
	{
		public delegate void PrefixSignature(ref Vector3 groundPosition, ref Vector3 groundNormal, ref CharacterBody attackerBody, ref bool fireOuter);

		public delegate void PostfixSignature(ref Vector3 groundPosition, ref Vector3 groundNormal, ref CharacterBody attackerBody, ref bool fireOuter);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(AffixAurelioniteBehavior);
			MethodInfo method = typeFromHandle.GetMethod("FireAurelioniteAttack", (BindingFlags)(-1), null, new Type[4]
			{
				typeof(Vector3),
				typeof(Vector3),
				typeof(CharacterBody),
				typeof(bool)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.AffixAurelioniteBehavior", "FireAurelioniteAttack");
			}
			return method;
		}
	}
	internal static class OnDisable
	{
		public delegate void PrefixSignature(AffixAurelioniteBehavior self);

		public delegate void PostfixSignature(AffixAurelioniteBehavior self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(AffixAurelioniteBehavior);
			MethodInfo method = typeFromHandle.GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("RoR2.AffixAurelioniteBehavior", "OnDisable");
			}
			return method;
		}
	}
	internal static class TryFindGroundPoint
	{
	}
	internal static class get_cooldownDuration
	{
	}
	internal static class get_targetSearchCooldown
	{
	}
	internal static class Start
	{
	}
	internal static class OnEnable
	{
	}
	internal static class OnNetworkItemUpdate
	{
	}
	internal static class EnsureReferences
	{
	}
	internal static class OnServerDamageDealt
	{
	}
	internal static class GetTotalPossibleNuggets
	{
	}
	internal static class StealMoneyWithFX
	{
	}
	internal static class Update
	{
	}
	internal static class UpdateAccumulatedGold
	{
	}
	internal static class UpdateGoldAccumulationDisplay
	{
	}
	internal static class StepIdentifyNextTarget
	{
	}
	internal static class StepPrefireVFX
	{
	}
	internal static class StepPredictAndFireWarningProjectile
	{
	}
	internal static class StepFire
	{
	}
	internal static class TryIdentifyNextTarget
	{
	}
	internal static class SpawnPreFireVFX
	{
	}
	internal static class QuickCooldown
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
}
namespace MonoDetour.HookGen
{
	internal static class DefaultMonoDetourManager
	{
		internal static MonoDetourManager Instance { get; } = New();

		internal static MonoDetourManager New()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return new MonoDetourManager(typeof(DefaultMonoDetourManager).Assembly.GetName().Name);
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
	internal class MonoDetourTargetsAttribute(Type? targetType = null) : Attribute(), IMonoDetourTargets
	{
		public Type? TargetType { get; } = targetType;

		public bool IncludeNestedTypes { get; set; } = true;

		public string[]? Members { get; set; }

		public string[]? MemberNamePrefixes { get; set; }

		public string[]? MemberNameSuffixes { get; set; }

		public bool GenerateControlFlowVariants { get; set; }
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace DamageSourceForEquipment
{
	internal static class ConfigOptions
	{
		public static ConfigEntry<bool> AspectDamageIsEquipment;

		internal static void BindConfigOptions(ConfigFile config)
		{
			AspectDamageIsEquipment = Extensions.BindOption<bool>(config, "Aspects", "Make aspect effect damage count as equipment damage", "Should damage from aspect's passive effects (i.e blazing fire trail, malachite spikes) count as equipment damage?", true, (ConfigFlags)1);
		}
	}
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(da