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.GameAssetPaths.Version_1_35_0;
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("LordVGames.DamageSourceForEquipment")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+032084aa5246587541c4a976eb0346c7b7f3a1a1")]
[assembly: AssemblyProduct("LordVGames.DamageSourceForEquipment")]
[assembly: AssemblyTitle("DamageSourceForEquipment")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace 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()
		{
			return typeof(GoldGatFire).GetMethod("FireBullet", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("EntityStates.GoldGat.GoldGatFire", "FireBullet");
		}
	}
	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()
		{
			return typeof(CountDown).GetMethod("Detonate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("EntityStates.QuestVolatileBattery.CountDown", "Detonate");
		}
	}
	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()
		{
			return typeof(LightningStrikeOrb).GetMethod("OnArrival", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.Orbs.LightningStrikeOrb", "OnArrival");
		}
	}
	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()
		{
			return typeof(MissileUtils).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) ?? throw new MissingMethodException("RoR2.MissileUtils", "FireMissile");
		}
	}
	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()
		{
			return typeof(EquipmentSlot).GetMethod("FireMissile", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.EquipmentSlot", "FireMissile");
		}
	}
	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()
		{
			return typeof(EquipmentSlot).GetMethod("FireMolotov", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.EquipmentSlot", "FireMolotov");
		}
	}
	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()
		{
			return typeof(EquipmentSlot).GetMethod("MyFixedUpdate", (BindingFlags)(-1), null, new Type[1] { typeof(float) }, null) ?? throw new MissingMethodException("RoR2.EquipmentSlot", "MyFixedUpdate");
		}
	}
	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()
		{
			return typeof(EquipmentSlot).GetMethod("FireVendingMachine", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.EquipmentSlot", "FireVendingMachine");
		}
	}
	internal static class _FireSaw_g__FireSingleSaw_96_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()
		{
			return typeof(EquipmentSlot).GetMethod("<FireSaw>g__FireSingleSaw|96_0", (BindingFlags)(-1), null, new Type[3]
			{
				typeof(CharacterBody),
				typeof(Vector3),
				typeof(Quaternion)
			}, null) ?? throw new MissingMethodException("RoR2.EquipmentSlot", "<FireSaw>g__FireSingleSaw|96_0");
		}
	}
	internal static class get_activeEquipmentSlot
	{
	}
	internal static class set_activeEquipmentSlot
	{
	}
	internal static class get_activeEquipmentSet
	{
	}
	internal static class set_activeEquipmentSet
	{
	}
	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 add_onServerEquipmentActivated
	{
	}
	internal static class remove_onServerEquipmentActivated
	{
	}
	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 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 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 FireSproutOfLife
	{
	}
	internal static class FireParry
	{
	}
	internal static class FireAurelioniteSpike
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class _FireGateway_g__ToggleAttackSpeedPerNearbyCollider_115_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 CallRpcOnClientEquipmentActivationRecieved
	{
	}
	internal static class OnSerialize
	{
	}
	internal static class OnDeserialize
	{
	}
	internal static class PreStartClient
	{
	}
	internal static class UserTargetInfo
	{
		internal static class _ctor
		{
		}

		internal static class _ctor_RoR2_HurtBox
		{
		}

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

		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass114_0
	{
		internal static class _ctor
		{
		}

		internal static class _FireRecycle_b__0
		{
		}
	}
	internal static class __c__DisplayClass115_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()
		{
			return typeof(GlobalEventManager).GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.GlobalEventManager", "OnDisable");
		}
	}
	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()
		{
			return typeof(GlobalEventManager).GetMethod("OnCharacterDeath", (BindingFlags)(-1), null, new Type[1] { typeof(DamageReport) }, null) ?? throw new MissingMethodException("RoR2.GlobalEventManager", "OnCharacterDeath");
		}
	}
	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()
		{
			return typeof(GlobalEventManager).GetMethod("OnHitAllProcess", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(DamageInfo),
				typeof(GameObject)
			}, null) ?? throw new MissingMethodException("RoR2.GlobalEventManager", "OnHitAllProcess");
		}
	}
	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()
		{
			return typeof(GlobalEventManager).GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.GlobalEventManager", "Init");
		}
	}
	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 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 ProcIgniteOnKill
	{
	}
	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 add_OnInteractionsGlobal
	{
	}
	internal static class remove_OnInteractionsGlobal
	{
	}
	internal static class OnInteractionBegin
	{
	}
	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 _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class _ProcessHitEnemy_g__LocalCheckRoll_10_0
	{
	}
	internal static class _OnCharacterDeath_g__LocalCheckRoll_26_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__18_0
			{
			}

			internal static class _Load_b__18_1
			{
			}

			internal static class _Load_b__18_2
			{
			}

			internal static class _Load_b__18_3
			{
			}

			internal static class _Load_b__18_4
			{
			}

			internal static class _Load_b__18_5
			{
			}

			internal static class _Load_b__18_6
			{
			}

			internal static class _Load_b__18_7
			{
			}

			internal static class _Load_b__18_8
			{
			}

			internal static class _Load_b__18_9
			{
			}

			internal static class _Load_b__18_10
			{
			}

			internal static class _Load_b__18_11
			{
			}

			internal static class _Load_b__18_12
			{
			}

			internal static class _Load_b__18_13
			{
			}

			internal static class _Load_b__18_14
			{
			}

			internal static class _Load_b__18_15
			{
			}

			internal static class _Load_b__18_16
			{
			}

			internal static class _Load_b__18_17
			{
			}
		}
	}
	internal static class __c__DisplayClass10_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass26_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass26_1
	{
		internal static class _ctor
		{
		}

		internal static class _OnCharacterDeath_b__1
		{
		}
	}
	internal static class __c__DisplayClass41_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass41_1
	{
		internal static class _ctor
		{
		}

		internal static class _OnInteractionBegin_g__InteractableIsPermittedForSpawn_0
		{
		}

		internal static class _OnInteractionBegin_b__1
		{
		}
	}
	internal static class __c
	{
		internal static class _cctor
		{
		}

		internal static class _ctor
		{
		}

		internal static class __cctor_b__55_0
		{
		}

		internal static class __cctor_b__55_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()
		{
			return typeof(FireballVehicle).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.FireballVehicle", "Awake");
		}
	}
	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()
		{
			return typeof(FireballVehicle).GetMethod("OnPassengerEnter", (BindingFlags)(-1), null, new Type[1] { typeof(GameObject) }, null) ?? throw new MissingMethodException("RoR2.FireballVehicle", "OnPassengerEnter");
		}
	}
	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()
		{
			return typeof(FireballVehicle).GetMethod("DetonateServer", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.FireballVehicle", "DetonateServer");
		}
	}
	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()
		{
			return typeof(CharacterBody).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody", "Awake");
		}
	}
	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()
			{
				return typeof(AffixEchoBehavior).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody+AffixEchoBehavior", "Awake");
			}
		}

		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()
			{
				return typeof(AffixEchoBehavior).GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody+AffixEchoBehavior", "OnDisable");
			}
		}

		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()
		{
			return typeof(CharacterBody).GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody", "OnDisable");
		}
	}
	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()
			{
				return typeof(AffixHauntedBehavior).GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody+AffixHauntedBehavior", "OnDisable");
			}
		}

		internal static class FixedUpdate
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class ElementalRingsBehavior
	{
		internal static class OnDisable
		{
			public delegate void PrefixSignature(ElementalRingsBehavior self);

			public delegate void PostfixSignature(ElementalRingsBehavior 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()
			{
				return typeof(ElementalRingsBehavior).GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody+ElementalRingsBehavior", "OnDisable");
			}
		}

		internal static class FixedUpdate
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class DelayedDamageBehavior
	{
		internal static class OnDisable
		{
			public delegate void PrefixSignature(DelayedDamageBehavior self);

			public delegate void PostfixSignature(DelayedDamageBehavior 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()
			{
				return typeof(DelayedDamageBehavior).GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody+DelayedDamageBehavior", "OnDisable");
			}
		}

		internal static class Start
		{
		}

		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()
		{
			return typeof(CharacterBody).GetMethod("UpdateFireTrail", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody", "UpdateFireTrail");
		}
	}
	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()
		{
			return typeof(CharacterBody).GetMethod("UpdateAffixPoison", (BindingFlags)(-1), null, new Type[1] { typeof(float) }, null) ?? throw new MissingMethodException("RoR2.CharacterBody", "UpdateAffixPoison");
		}
	}
	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()
		{
			return typeof(CharacterBody).GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody", "Init");
		}
	}
	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 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 AddBuff_RoR2_BuffIndex
	{
	}
	internal static class AddBuff_RoR2_BuffDef
	{
	}
	internal static class RemoveBuff_RoR2_BuffIndex
	{
	}
	internal static class RemoveBuff_RoR2_BuffDef
	{
	}
	internal static class SetBuffCount
	{
	}
	internal static class OnBuffFirstStackGained
	{
	}
	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 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 AddTimedBuff_RoR2_BuffIndex_System_Single
	{
	}
	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_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 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 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 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 get_isSprinting
	{
	}
	internal static class set_isSprinting
	{
	}
	internal static class OnSprintStart
	{
	}
	internal static class OnSprintStop
	{
	}
	internal static class CmdUpdateSprint
	{
	}
	internal static class CmdOnSkillActivated
	{
	}
	internal static class get_speedOnPickupLimit
	{
	}
	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_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 MarkAllStatsDirty
	{
	}
	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 get_bestFitRadius
	{
	}
	internal static class get_bestFitActualRadius
	{
	}
	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 SendConstructTurret
	{
	}
	internal static class HandleConstructTurret
	{
	}
	internal static class get_multiKillCount
	{
	}
	internal static class set_multiKillCount
	{
	}
	internal static class GetMaxIncreasedDamageMultiKillBuffsForCharacter
	{
	}
	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 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_corePosition
	{
	}
	internal static class get_footPosition
	{
	}
	internal static class get_temporaryPathfindingFootpositionDoNotUseWillBePatchedOut
	{
	}
	internal static class get_radius
	{
	}
	internal static class set_radius
	{
	}
	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_isEquipmentActivationAllowed
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class _ReadBuffs_g__ZeroBuffIndexRange_37_0
	{
	}
	internal static class _AddTimedBuff_g__DefaultBehavior_58_0
	{
	}
	internal static class _AddTimedBuff_g__RefreshStacks_58_1
	{
	}
	internal static class _RecalculateStats_g__CalculateAppliedBeadStats_425_0
	{
	}
	internal static class _HandleDisableAllSkillsDebuff_g__HandleSkillDisableState_426_0
	{
	}
	internal static class _UpdateKnockBackHitVisualsAndGracePeriod_g__Clear_630_0
	{
	}
	internal static class UNetVersion
	{
	}
	internal static class InvokeCmdCmdTriggerJumpEvent
	{
	}
	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 InvokeCmdCmdRequestVehicleEjection
	{
	}
	internal static class CallCmdTriggerJumpEvent
	{
	}
	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 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__43_0
			{
			}

			internal static class _Load_b__43_1
			{
			}

			internal static class _Load_b__43_2
			{
			}

			internal static class _Load_b__43_3
			{
			}

			internal static class _Load_b__43_4
			{
			}

			internal static class _Load_b__43_5
			{
			}

			internal static class _Load_b__43_6
			{
			}

			internal static class _Load_b__43_7
			{
			}

			internal static class _Load_b__43_8
			{
			}

			internal static class _Load_b__43_9
			{
			}

			internal static class _Load_b__43_10
			{
			}

			internal static class _Load_b__43_11
			{
			}

			internal static class _Load_b__43_12
			{
			}

			internal static class _Load_b__43_13
			{
			}

			internal static class _Load_b__43_14
			{
			}

			internal static class _Load_b__43_15
			{
			}

			internal static class _Load_b__43_16
			{
			}

			internal static class _Load_b__43_17
			{
			}

			internal static class _Load_b__43_18
			{
			}

			internal static class _Load_b__43_19
			{
			}

			internal static class _Load_b__43_20
			{
			}

			internal static class _Load_b__43_21
			{
			}

			internal static class _Load_b__43_22
			{
			}

			internal static class _Load_b__43_23
			{
			}

			internal static class _Load_b__43_24
			{
			}

			internal static class _Load_b__43_25
			{
			}

			internal static class _Load_b__43_26
			{
			}

			internal static class _Load_b__43_27
			{
			}

			internal static class _Load_b__43_28
			{
			}

			internal static class _Load_b__43_29
			{
			}

			internal static class _Load_b__43_30
			{
			}

			internal static class _Load_b__43_31
			{
			}

			internal static class _Load_b__43_32
			{
			}

			internal static class _Load_b__43_33
			{
			}

			internal static class _Load_b__43_34
			{
			}

			internal static class _Load_b__43_35
			{
			}

			internal static class _Load_b__43_36
			{
			}

			internal static class _Load_b__43_37
			{
			}

			internal static class _Load_b__43_38
			{
			}

			internal static class _Load_b__43_39
			{
			}

			internal static class _Load_b__43_40
			{
			}
		}
	}
	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 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 TimeBubbleItemBehaviorServer
	{
		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__55_0
			{
			}

			internal static class _Resolve_b__55_1
			{
			}

			internal static class _Resolve_b__55_2
			{
			}

			internal static class _Resolve_b__55_3
			{
			}

			internal static class _Resolve_b__55_4
			{
			}

			internal static class _Resolve_b__55_5
			{
			}

			internal static class _Resolve_b__55_6
			{
			}

			internal static class _Resolve_b__55_7
			{
			}

			internal static class _Resolve_b__55_8
			{
			}

			internal static class _Resolve_b__55_9
			{
			}

			internal static class _Resolve_b__55_10
			{
			}

			internal static class _Resolve_b__55_11
			{
			}

			internal static class _Resolve_b__55_12
			{
			}

			internal static class _Resolve_b__55_13
			{
			}

			internal static class _Resolve_b__55_14
			{
			}

			internal static class _Resolve_b__55_15
			{
			}

			internal static class _Resolve_b__55_16
			{
			}

			internal static class _Resolve_b__55_17
			{
			}

			internal static class _Resolve_b__55_18
			{
			}

			internal static class _Resolve_b__55_19
			{
			}

			internal static class _Resolve_b__55_20
			{
			}

			internal static class _Resolve_b__55_21
			{
			}

			internal static class _Resolve_b__55_22
			{
			}

			internal static class _Resolve_b__55_23
			{
			}

			internal static class _Resolve_b__55_24
			{
			}

			internal static class _Resolve_b__55_25
			{
			}

			internal static class _Resolve_b__55_26
			{
			}

			internal static class _Resolve_b__55_27
			{
			}

			internal static class _Resolve_b__55_28
			{
			}

			internal static class _Resolve_b__55_29
			{
			}

			internal static class _Resolve_b__55_30
			{
			}

			internal static class _Resolve_b__55_31
			{
			}

			internal static class _Resolve_b__55_32
			{
			}

			internal static class _Resolve_b__55_33
			{
			}

			internal static class _Resolve_b__55_34
			{
			}

			internal static class _Resolve_b__55_35
			{
			}

			internal static class _Resolve_b__55_36
			{
			}

			internal static class _Resolve_b__55_37
			{
			}

			internal static class _Resolve_b__55_38
			{
			}

			internal static class _Resolve_b__55_39
			{
			}

			internal static class _Resolve_b__55_40
			{
			}

			internal static class _Resolve_b__55_41
			{
			}

			internal static class _Resolve_b__55_42
			{
			}

			internal static class _Resolve_b__55_43
			{
			}

			internal static class _Resolve_b__55_44
			{
			}

			internal static class _Resolve_b__55_45
			{
			}

			internal static class _Resolve_b__55_46
			{
			}

			internal static class _Resolve_b__55_47
			{
			}

			internal static class _Resolve_b__55_48
			{
			}

			internal static class _Resolve_b__55_49
			{
			}

			internal static class _Resolve_b__55_50
			{
			}

			internal static class _Resolve_b__55_51
			{
			}

			internal static class _Resolve_b__55_52
			{
			}

			internal static class _Resolve_b__55_53
			{
			}
		}
	}
	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__DisplayClass37_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass58_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass425_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()
		{
			return typeof(DamageTrail).GetMethod("Awake", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.DamageTrail", "Awake");
		}
	}
	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()
		{
			return typeof(DamageTrail).GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.DamageTrail", "OnDisable");
		}
	}
	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()
		{
			return typeof(DamageTrail).GetMethod("DoDamage", (BindingFlags)(-1), null, new Type[1] { typeof(float) }, null) ?? throw new MissingMethodException("RoR2.DamageTrail", "DoDamage");
		}
	}
	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()
		{
			return typeof(DamageTrail).GetMethod("MyFixedUpdate", (BindingFlags)(-1), null, new Type[1] { typeof(float) }, null) ?? throw new MissingMethodException("RoR2.DamageTrail", "MyFixedUpdate");
		}
	}
	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()
		{
			return typeof(DamageTrail).GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.DamageTrail", "Init");
		}
	}
	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()
		{
			return typeof(AffixAurelioniteBehavior).GetMethod("FireAurelioniteAttack", (BindingFlags)(-1), null, new Type[4]
			{
				typeof(Vector3),
				typeof(Vector3),
				typeof(CharacterBody),
				typeof(bool)
			}, null) ?? throw new MissingMethodException("RoR2.AffixAurelioniteBehavior", "FireAurelioniteAttack");
		}
	}
	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()
		{
			return typeof(AffixAurelioniteBehavior).GetMethod("OnDisable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.AffixAurelioniteBehavior", "OnDisable");
		}
	}
	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 : Attribute, IMonoDetourTargets
	{
		public Type? TargetType { get; }

		public bool IncludeNestedTypes { get; set; }

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

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

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

		public bool GenerateControlFlowVariants { get; set; }

		public MonoDetourTargetsAttribute(Type? targetType = null)
		{
			TargetType = targetType;
			IncludeNestedTypes = true;
			base..ctor();
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.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")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[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);
			Extensions.WipeConfig(config);
		}
	}
	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(data);
		}
	}
	internal static class Main
	{
		public static ModdedProcType AddEquipmentDamageSource;

		public static readonly DamageTypeCombo GenericEquipment = new DamageTypeCombo
		{
			damageType = (DamageType)0,
			damageTypeExtended = (DamageTypeExtended)0,
			damageSource = (DamageSource)64
		};

		internal static readonly Type[] GoodFireProjectileTypes = new Type[11]
		{
			typeof(GameObject),
			typeof(Vector3),
			typeof(Quaternion),
			typeof(GameObject),
			typeof(float),
			typeof(float),
			typeof(bool),
			typeof(DamageColorIndex),
			typeof(GameObject),
			typeof(float),
			typeof(DamageTypeCombo?)
		};
	}
	[BepInPlugin("LordVGames.DamageSourceForEquipment", "DamageSourceForEquipment", "2.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Id = "LordVGames.DamageSourceForEquipment";

		public static string Name => "DamageSourceForEquipment";

		public static string Version => "2.0.0";

		public void Awake()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Log.Init(((BaseUnityPlugin)this).Logger);
			ConfigOptions.BindConfigOptions(((BaseUnityPlugin)this).Config);
			Main.AddEquipmentDamageSource = ProcTypeAPI.ReserveProcType();
			MonoDetourManager.InvokeHookInitializers(typeof(Plugin).Assembly);
		}
	}
}
namespace DamageSourceForEquipment.Edits
{
	public static class EliteAspects
	{
		[MonoDetourTargets(typeof(AffixAurelioniteBehavior))]
		private static class GildedAspect
		{
			[CompilerGenerated]
			private static class <>O
			{
				public static Manipulator <0>__AffixAurelioniteBehavior_FireAurelioniteAttack;
			}

			[MonoDetourHookInitialize]
			private static void Setup()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected O, but got Unknown
				if (ConfigOptions.AspectDamageIsEquipment.Value)
				{
					object obj = <>O.<0>__AffixAurelioniteBehavior_FireAurelioniteAttack;
					if (obj == null)
					{
						Manipulator val = AffixAurelioniteBehavior_FireAurelioniteAttack;
						<>O.<0>__AffixAurelioniteBehavior_FireAurelioniteAttack = val;
						obj = (object)val;
					}
					FireAurelioniteAttack.ILHook((Manipulator)obj);
				}
			}

			private static void AffixAurelioniteBehavior_FireAurelioniteAttack(ILManipulationInfo info)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				ILWeaver w = new ILWeaver(info);
				ILHelpers.Projectiles.OverrideNextFireProjectileWithoutDamageType(Main.GenericEquipment, w);
				ILHelpers.Projectiles.OverrideNextFireProjectileWithoutDamageType(Main.GenericEquipment, w);
			}
		}

		[MonoDetourTargets(typeof(DamageTrail))]
		[MonoDetourTargets(typeof(CharacterBody))]
		private static class BlazingAspect
		{
			public class DamageTrailDamageSource
			{
				public DamageSource DamageSource;
			}

			[CompilerGenerated]
			private static class <>O
			{
				public static Mdh.RoR2.DamageTrail.Awake.PostfixSignature <0>__DamageTrail_Awake;

				public static Mdh.RoR2.DamageTrail.OnDisable.PostfixSignature <1>__DamageTrail_OnDisable;

				public static Manipulator <2>__DamageTrail_DoDamage;

				public static Manipulator <3>__CharacterBody_UpdateFireTrail;
			}

			public static readonly FixedConditionalWeakTable<DamageTrail, DamageTrailDamageSource> DamageTrailDamageSourceTable = new FixedConditionalWeakTable<DamageTrail, DamageTrailDamageSource>();

			[MonoDetourHookInitialize]
			private static void Setup()
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Expected O, but got Unknown
				if (ConfigOptions.AspectDamageIsEquipment.Value)
				{
					Mdh.RoR2.DamageTrail.Awake.Postfix(DamageTrail_Awake);
					Mdh.RoR2.DamageTrail.OnDisable.Postfix(DamageTrail_OnDisable);
					object obj = <>O.<2>__DamageTrail_DoDamage;
					if (obj == null)
					{
						Manipulator val = DamageTrail_DoDamage;
						<>O.<2>__DamageTrail_DoDamage = val;
						obj = (object)val;
					}
					DoDamage.ILHook((Manipulator)obj);
					object obj2 = <>O.<3>__CharacterBody_UpdateFireTrail;
					if (obj2 == null)
					{
						Manipulator val2 = CharacterBody_UpdateFireTrail;
						<>O.<3>__CharacterBody_UpdateFireTrail = val2;
						obj2 = (object)val2;
					}
					UpdateFireTrail.ILHook((Manipulator)obj2);
				}
			}

			private static void DamageTrail_Awake(DamageTrail self)
			{
				DamageTrailDamageSourceTable.GetOrCreateValue(self);
			}

			private static void DamageTrail_OnDisable(DamageTrail self)
			{
				DamageTrailDamageSource damageTrailDamageSource = default(DamageTrailDamageSource);
				if (DamageTrailDamageSourceTable.TryGetValue(self, ref damageTrailDamageSource))
				{
					DamageTrailDamageSourceTable.Remove(self);
				}
			}

			private static void DamageTrail_DoDamage(ILManipulationInfo info)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				ILWeaver w = new ILWeaver(info);
				w.MatchRelaxed(new Predicate<Instruction>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchStfld<DamageInfo>(x, "damageType") && w.SetCurrentTo(x)
				}).ThrowIfFailure();
				w.InsertAfterCurrent((IEnumerable<InstructionOrEnumerable>)new <>z__ReadOnlyArray<InstructionOrEnumerable>((InstructionOrEnumerable[])(object)new InstructionOrEnumerable[3]
				{
					InstructionOrEnumerable.op_Implicit(w.Create(OpCodes.Ldarg_0)),
					InstructionOrEnumerable.op_Implicit(w.Create(OpCodes.Ldloc_3)),
					InstructionOrEnumerable.op_Implicit(w.CreateDelegateCall<Action<DamageTrail, DamageInfo>>((Action<DamageTrail, DamageInfo>)delegate(DamageTrail damageTrail, DamageInfo damageInfo)
					{
						//IL_0016: Unknown result type (might be due to invalid IL or missing references)
						//IL_001b: Unknown result type (might be due to invalid IL or missing references)
						DamageTrailDamageSource damageTrailDamageSource = default(DamageTrailDamageSource);
						if (DamageTrailDamageSourceTable.TryGetValue(damageTrail, ref damageTrailDamageSource))
						{
							damageInfo.damageType.damageSource = damageTrailDamageSource.DamageSource;
						}
					}))
				}));
			}

			private static void CharacterBody_UpdateFireTrail(ILManipulationInfo info)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				ILWeaver w = new ILWeaver(info);
				w.MatchNextRelaxed((Instruction x) => ILPatternMatchingExt.MatchStfld<CharacterBody>(x, "fireTrail") && w.SetCurrentTo(x)).ThrowIfFailure();
				w.InsertAfterCurrent((IEnumerable<InstructionOrEnumerable>)new <>z__ReadOnlyArray<InstructionOrEnumerable>((InstructionOrEnumerable[])(object)new InstructionOrEnumerable[2]
				{
					InstructionOrEnumerable.op_Implicit(w.Create(OpCodes.Ldarg_0)),
					InstructionOrEnumerable.op_Implicit(w.CreateDelegateCall<Action<CharacterBody>>((Action<CharacterBody>)delegate(CharacterBody characterBody)
					{
						//IL_002e: Unknown result type (might be due to invalid IL or missing references)
						DamageTrailDamageSource damageTrailDamageSource = default(DamageTrailDamageSource);
						if ((Object)(object)characterBody != (Object)null && (Object)(object)characterBody.fireTrail != (Object)null && DamageTrailDamageSourceTable.TryGetValue(characterBody.fireTrail, ref damageTrailDamageSource))
						{
							damageTrailDamageSource.DamageSource = (DamageSource)64;
						}
					}))
				}));
			}
		}

		[MonoDetourTargets(typeof(CharacterBody))]
		private static class MalachiteAspect
		{
			[CompilerGenerated]
			private static class <>O
			{
				public static Manipulator <0>__CharacterBody_UpdateAffixPoison;
			}

			private static readonly AssetReferenceT<GameObject> _malachiteSpikeProjectile = new AssetReferenceT<GameObject>(RoR2_Base_ElitePoison.PoisonStakeProjectile_prefab);

			[MonoDetourHookInitialize]
			private static void Setup()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected O, but got Unknown
				if (ConfigOptions.AspectDamageIsEquipment.Value)
				{
					object obj = <>O.<0>__CharacterBody_UpdateAffixPoison;
					if (obj == null)
					{
						Manipulator val = CharacterBody_UpdateAffixPoison;
						<>O.<0>__CharacterBody_UpdateAffixPoison = val;
						obj = (object)val;
					}
					UpdateAffixPoison.ILHook((Manipulator)obj);
					AsyncOperationHandle<GameObject> val2 = AssetAsyncReferenceManager<GameObject>.LoadAsset(_malachiteSpikeProjectile, (AsyncReferenceHandleUnloadType)2);
					val2.Completed += delegate(AsyncOperationHandle<GameObject> handle)
					{
						//IL_0013: Unknown result type (might be due to invalid IL or missing references)
						handle.Result.GetComponent<ProjectileDamage>().damageType.damageSource = (DamageSource)64;
						AssetAsyncReferenceManager<GameObject>.UnloadAsset(_malachiteSpikeProjectile);
					};
				}
			}

			private static void CharacterBody_UpdateAffixPoison(ILManipulationInfo info)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				ILHelpers.Projectiles.OverrideFireProjectileWithoutDamageType(Main.GenericEquipment, info);
			}
		}

		[MonoDetourTargets(typeof(GlobalEventManager))]
		private static class GlacialAspect
		{
			[CompilerGenerated]
			private static class <>O
			{
				public static Manipulator <0>__GlobalEventManager_OnCharacterDeath;
			}

			[MonoDetourHookInitialize]
			private static void Setup()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected O, but got Unknown
				if (ConfigOptions.AspectDamageIsEquipment.Value)
				{
					object obj = <>O.<0>__GlobalEventManager_OnCharacterDeath;
					if (obj == null)
					{
						Manipulator val = GlobalEventManager_OnCharacterDeath;
						<>O.<0>__GlobalEventManager_OnCharacterDeath = val;
						obj = (object)val;
					}
					OnCharacterDeath.ILHook((Manipulator)obj);
				}
			}

			private static void GlobalEventManager_OnCharacterDeath(ILManipulationInfo info)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				ILWeaver w = new ILWeaver(info);
				int ldLocNumber = 25;
				int num = default(int);
				w.MatchRelaxed(new Predicate<Instruction>[4]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref ldLocNumber),
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, ref num),
					(Instruction x) => ILPatternMatchingExt.MatchCall<DamageTypeCombo>(x, "op_Implicit"),
					(Instruction x) =>