using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.RocketSurvivorSkills.Primary;
using EntityStates.Toolbot;
using LordsItemEdits.ItemEdits;
using LordsItemEdits.MultiItemEdits;
using Mdh.EntityStates.RocketSurvivorSkills.Primary.FireRocket;
using Mdh.RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM;
using Mdh.RoR2.CharacterBody;
using Mdh.RoR2.CharacterMaster;
using Mdh.RoR2.EquipmentSlot;
using Mdh.RoR2.GlobalEventManager;
using Mdh.RoR2.Inventory;
using Mdh.RoR2.Items.ExtraLifeVoidManager;
using Mdh.RoR2.Items.MultiShopCardUtils;
using Mdh.RoR2.MissileUtils;
using Mdh.RoR2.Projectile.BoomerangProjectile;
using Mdh.WolfoFixes.EquipmentFixes;
using Microsoft.CodeAnalysis;
using MiscFixes.Modules;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using MonoMod.Cil;
using On.EntityStates.Toolbot;
using R2API;
using RiskyTweaks.Tweaks.Survivors.Toolbot;
using RoR2;
using RoR2.CharacterAI;
using RoR2.ContentManagement;
using RoR2.Items;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2BepInExPack.GameAssetPathsBetter;
using RoR2BepInExPack.Utilities;
using SimpleJSON;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using WolfoFixes;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("RiskyTweaks")]
[assembly: IgnoresAccessChecksTo("RocketSurvivor")]
[assembly: IgnoresAccessChecksTo("Starstorm2")]
[assembly: IgnoresAccessChecksTo("WolfoFixes")]
[assembly: IgnoresAccessChecksTo("WolfoLibrary")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LordVGames.LordsItemEdits")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.4.1.0")]
[assembly: AssemblyInformationalVersion("0.4.1+c037dfb51c1c627d360b1bd0e692f3c381145ad1")]
[assembly: AssemblyProduct("LordVGames.LordsItemEdits")]
[assembly: AssemblyTitle("LordsItemEdits")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.4.1.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.RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM
{
	internal static class FireGrenadeLauncher_ModifyProjectileAimRay
	{
		public delegate void PrefixSignature(ScrapICBM self, ref orig_ModifyProjectileAimRay orig, ref FireGrenadeLauncher self1, ref Ray aimRay);

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

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

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

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature 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(ScrapICBM).GetMethod("FireGrenadeLauncher_ModifyProjectileAimRay", (BindingFlags)(-1), null, new Type[3]
			{
				typeof(orig_ModifyProjectileAimRay),
				typeof(FireGrenadeLauncher),
				typeof(Ray)
			}, null) ?? throw new MissingMethodException("RiskyTweaks.Tweaks.Survivors.Toolbot.ScrapICBM", "FireGrenadeLauncher_ModifyProjectileAimRay");
		}
	}
}
namespace Mdh.WolfoFixes.EquipmentFixes
{
	internal static class Start
	{
		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(EquipmentFixes).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("WolfoFixes.EquipmentFixes", "Start");
		}
	}
}
namespace Mdh.EntityStates.RocketSurvivorSkills.Primary.FireRocket
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(FireRocket self);

		public delegate void PostfixSignature(FireRocket self);

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

		public delegate void PostfixSignature(FireRocket self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(FireRocket).GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("EntityStates.RocketSurvivorSkills.Primary.FireRocket", "OnEnter");
		}
	}
}
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");
		}
	}
}
namespace Mdh.RoR2.Items.ExtraLifeVoidManager
{
	internal static class GetNextBodyPrefab
	{
		public delegate void PrefixSignature();

		public delegate ReturnFlow ControlFlowPrefixSignature(ref GameObject returnValue);

		public delegate void PostfixSignature(ref GameObject 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 ControlFlowPrefix(ControlFlowPrefixSignature 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(ExtraLifeVoidManager).GetMethod("GetNextBodyPrefab", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.Items.ExtraLifeVoidManager", "GetNextBodyPrefab");
		}
	}
	internal static class Init
	{
		public delegate void PrefixSignature();

		public delegate ReturnFlow ControlFlowPrefixSignature();

		public delegate void PostfixSignature();

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

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature 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(ExtraLifeVoidManager).GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.Items.ExtraLifeVoidManager", "Init");
		}
	}
}
namespace Mdh.RoR2.Items.MultiShopCardUtils
{
	internal static class OnPurchase
	{
		public delegate void PrefixSignature(ref PayCostContext context, ref int moneyCost);

		public delegate void PostfixSignature(ref PayCostContext context, ref int moneyCost);

		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(MultiShopCardUtils).GetMethod("OnPurchase", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(PayCostContext),
				typeof(int)
			}, null) ?? throw new MissingMethodException("RoR2.Items.MultiShopCardUtils", "OnPurchase");
		}
	}
}
namespace Mdh.RoR2.CharacterBody
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(CharacterBody self);

		public delegate ReturnFlow ControlFlowPrefixSignature(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 ControlFlowPrefix(ControlFlowPrefixSignature 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("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody", "FixedUpdate");
		}
	}
	internal static class AffixHauntedBehavior
	{
		internal static class FixedUpdate
		{
			public delegate void PrefixSignature(AffixHauntedBehavior self);

			public delegate ReturnFlow ControlFlowPrefixSignature(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 ControlFlowPrefix(ControlFlowPrefixSignature 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("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody+AffixHauntedBehavior", "FixedUpdate");
			}
		}
	}
	internal static class ElementalRingsBehavior
	{
		internal static class FixedUpdate
		{
			public delegate void PrefixSignature(ElementalRingsBehavior self);

			public delegate ReturnFlow ControlFlowPrefixSignature(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 ControlFlowPrefix(ControlFlowPrefixSignature 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("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody+ElementalRingsBehavior", "FixedUpdate");
			}
		}
	}
	internal static class AffixEchoBehavior
	{
		internal static class FixedUpdate
		{
			public delegate void PrefixSignature(AffixEchoBehavior self);

			public delegate ReturnFlow ControlFlowPrefixSignature(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 ControlFlowPrefix(ControlFlowPrefixSignature 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("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody+AffixEchoBehavior", "FixedUpdate");
			}
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(CharacterBody self);

		public delegate ReturnFlow ControlFlowPrefixSignature(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 ControlFlowPrefix(ControlFlowPrefixSignature 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("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody", "Start");
		}
	}
	internal static class QuestVolatileBatteryBehaviorServer
	{
		internal static class Start
		{
			public delegate void PrefixSignature(QuestVolatileBatteryBehaviorServer self);

			public delegate ReturnFlow ControlFlowPrefixSignature(QuestVolatileBatteryBehaviorServer self);

			public delegate void PostfixSignature(QuestVolatileBatteryBehaviorServer 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 ControlFlowPrefix(ControlFlowPrefixSignature 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(QuestVolatileBatteryBehaviorServer).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody+QuestVolatileBatteryBehaviorServer", "Start");
			}
		}
	}
	internal static class DelayedDamageBehavior
	{
		internal static class Start
		{
			public delegate void PrefixSignature(DelayedDamageBehavior self);

			public delegate ReturnFlow ControlFlowPrefixSignature(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 ControlFlowPrefix(ControlFlowPrefixSignature 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("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody+DelayedDamageBehavior", "Start");
			}
		}
	}
	internal static class GetBody
	{
		public delegate void PrefixSignature(CharacterBody self);

		public delegate ReturnFlow ControlFlowPrefixSignature(CharacterBody self, ref CharacterBody returnValue);

		public delegate void PostfixSignature(CharacterBody self, ref CharacterBody 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 ControlFlowPrefix(ControlFlowPrefixSignature 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("GetBody", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterBody", "GetBody");
		}
	}
	internal static class Init
	{
		public delegate void PrefixSignature();

		public delegate ReturnFlow ControlFlowPrefixSignature();

		public delegate void PostfixSignature();

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

		public static MonoDetourHook ControlFlowPrefix(ControlFlowPrefixSignature 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");
		}
	}
}
namespace Mdh.RoR2.CharacterMaster
{
	internal static class ExtraLifeServerBehavior
	{
		internal static class FixedUpdate
		{
			public delegate void PrefixSignature(ExtraLifeServerBehavior self);

			public delegate void PostfixSignature(ExtraLifeServerBehavior 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(ExtraLifeServerBehavior).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterMaster+ExtraLifeServerBehavior", "FixedUpdate");
			}
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(CharacterMaster self);

		public delegate void PostfixSignature(CharacterMaster 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(CharacterMaster).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterMaster", "Start");
		}
	}
	internal static class RespawnExtraLifeVoid
	{
		public delegate void PrefixSignature(CharacterMaster self);

		public delegate void PostfixSignature(CharacterMaster 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(CharacterMaster).GetMethod("RespawnExtraLifeVoid", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterMaster", "RespawnExtraLifeVoid");
		}
	}
	internal static class GetBody
	{
		public delegate void PrefixSignature(CharacterMaster self);

		public delegate void PostfixSignature(CharacterMaster self, ref CharacterBody 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(CharacterMaster).GetMethod("GetBody", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterMaster", "GetBody");
		}
	}
	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(CharacterMaster).GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.CharacterMaster", "Init");
		}
	}
}
namespace Mdh.RoR2.EquipmentSlot
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(EquipmentSlot self);

		public delegate ReturnFlow ControlFlowPrefixSignature(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 ControlFlowPrefix(ControlFlowPrefixSignature 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("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.EquipmentSlot", "FixedUpdate");
		}
	}
	internal static class HealAndReviveLock
	{
		internal static class FixedUpdate
		{
			public delegate void PrefixSignature(HealAndReviveLock self);

			public delegate ReturnFlow ControlFlowPrefixSignature(HealAndReviveLock self);

			public delegate void PostfixSignature(HealAndReviveLock 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 ControlFlowPrefix(ControlFlowPrefixSignature 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(HealAndReviveLock).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.EquipmentSlot+HealAndReviveLock", "FixedUpdate");
			}
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(EquipmentSlot self);

		public delegate ReturnFlow ControlFlowPrefixSignature(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 ControlFlowPrefix(ControlFlowPrefixSignature 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("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.EquipmentSlot", "Start");
		}
	}
	internal static class PerformEquipmentAction
	{
		public delegate void PrefixSignature(EquipmentSlot self, ref EquipmentDef equipmentDef);

		public delegate ReturnFlow ControlFlowPrefixSignature(EquipmentSlot self, ref EquipmentDef equipmentDef, ref bool returnValue);

		public delegate void PostfixSignature(EquipmentSlot self, ref EquipmentDef equipmentDef, 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 ControlFlowPrefix(ControlFlowPrefixSignature 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("PerformEquipmentAction", (BindingFlags)(-1), null, new Type[1] { typeof(EquipmentDef) }, null) ?? throw new MissingMethodException("RoR2.EquipmentSlot", "PerformEquipmentAction");
		}
	}
}
namespace Mdh.RoR2.Projectile.BoomerangProjectile
{
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(BoomerangProjectile self);

		public delegate void PostfixSignature(BoomerangProjectile 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(BoomerangProjectile).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.Projectile.BoomerangProjectile", "FixedUpdate");
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(BoomerangProjectile self);

		public delegate void PostfixSignature(BoomerangProjectile 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(BoomerangProjectile).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.Projectile.BoomerangProjectile", "Start");
		}
	}
}
namespace Mdh.RoR2.Inventory
{
	internal static class ItemStackValues
	{
		internal static class Create
		{
			public delegate void PrefixSignature();

			public delegate void PostfixSignature(ref ItemStackValues 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(ItemStackValues).GetMethod("Create", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.Inventory+ItemStackValues", "Create");
			}
		}
	}
	internal static class ItemAndStackValues
	{
		internal static class Create
		{
			public delegate void PrefixSignature();

			public delegate void PostfixSignature(ref ItemAndStackValues 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(ItemAndStackValues).GetMethod("Create", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.Inventory+ItemAndStackValues", "Create");
			}
		}
	}
	internal static class ItemTransformation
	{
		internal static class TryTransformResult
		{
			internal static class Create
			{
				public delegate void PrefixSignature();

				public delegate void PostfixSignature(ref TryTransformResult 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(TryTransformResult).GetMethod("Create", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.Inventory+ItemTransformation+TryTransformResult", "Create");
				}
			}
		}
	}
	internal static class GiveItemPermanentImpl
	{
		internal static class Add
		{
			public delegate void PrefixSignature(GiveItemPermanentImpl self, ref ItemIndex itemIndex, ref int count);

			public delegate void PostfixSignature(GiveItemPermanentImpl self, ref ItemIndex itemIndex, ref int count);

			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(GiveItemPermanentImpl).GetMethod("Add", (BindingFlags)(-1), null, new Type[2]
				{
					typeof(ItemIndex),
					typeof(int)
				}, null) ?? throw new MissingMethodException("RoR2.Inventory+GiveItemPermanentImpl", "Add");
			}
		}
	}
	internal static class GiveItemChanneledImpl
	{
		internal static class Add
		{
			public delegate void PrefixSignature(GiveItemChanneledImpl self, ref ItemIndex itemIndex, ref int count);

			public delegate void PostfixSignature(GiveItemChanneledImpl self, ref ItemIndex itemIndex, ref int count);

			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(GiveItemChanneledImpl).GetMethod("Add", (BindingFlags)(-1), null, new Type[2]
				{
					typeof(ItemIndex),
					typeof(int)
				}, null) ?? throw new MissingMethodException("RoR2.Inventory+GiveItemChanneledImpl", "Add");
			}
		}
	}
	internal static class TempItemsStorage
	{
		internal static class GiveItemTempImpl
		{
			internal static class Add
			{
				public delegate void PrefixSignature(GiveItemTempImpl self, ref ItemIndex itemIndex, ref int count);

				public delegate void PostfixSignature(GiveItemTempImpl self, ref ItemIndex itemIndex, ref int count);

				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(GiveItemTempImpl).GetMethod("Add", (BindingFlags)(-1), null, new Type[2]
					{
						typeof(ItemIndex),
						typeof(int)
					}, null) ?? throw new MissingMethodException("RoR2.Inventory+TempItemsStorage+GiveItemTempImpl", "Add");
				}
			}
		}
	}
	internal static class CalculateEquipmentCooldownScale
	{
		public delegate void PrefixSignature(Inventory self);

		public delegate void PostfixSignature(Inventory self, ref float 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(Inventory).GetMethod("CalculateEquipmentCooldownScale", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.Inventory", "CalculateEquipmentCooldownScale");
		}
	}
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(Inventory self);

		public delegate void PostfixSignature(Inventory 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(Inventory).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("RoR2.Inventory", "FixedUpdate");
		}
	}
}
namespace Mdh.RoR2.GlobalEventManager
{
	internal static class ProcessHitEnemy
	{
		public delegate void PrefixSignature(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject victim);

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

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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("ProcessHitEnemy", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(DamageInfo),
				typeof(GameObject)
			}, null) ?? throw new MissingMethodException("RoR2.GlobalEventManager", "ProcessHitEnemy");
		}
	}
	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");
		}
	}
}
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 LordsItemEdits
{
	public static class ConfigOptions
	{
		public static class VoidDios
		{
			public static ConfigEntry<bool> EnableEdit;

			public static ConfigEntry<bool> AllowRespawnAsVoidReaver;

			internal static void BindConfigOptions(ConfigFile config)
			{
				EnableEdit = Extensions.BindOption<bool>(config, "Pluripotent Larva", "Enable edit", "Enable the Pluripotent Larva edit?", true, (ConfigFlags)1);
				AllowRespawnAsVoidReaver = Extensions.BindOption<bool>(config, "Pluripotent Larva", "Allow respawning as a Void Reaver", "Should the Void Reaver be an option to respawn as with the edited Pluripotent Larva? This is configurable since their only attack has bad damage and can't target flying enemies.", false, (ConfigFlags)0);
			}
		}

		public static class ATG
		{
			public static ConfigEntry<bool> EnableEdit;

			internal static void BindConfigOptions(ConfigFile config)
			{
				EnableEdit = Extensions.BindOption<bool>(config, "ATG", "Enable edit", "Enable the ATG edit which makes it fire like plasma shrimp? This will help performance!", true, (ConfigFlags)1);
			}
		}

		public static class PocketICBM
		{
			public static ConfigEntry<bool> EnableEdit;

			public static ConfigEntry<bool> ChangeATGEffect;

			public static ConfigEntry<bool> ChangeArmedBackpackEffect;

			public static ConfigEntry<bool> ChangeGenericMissileEffect;

			public static ConfigEntry<bool> ChangePlasmaShrimpEffect;

			public static ConfigEntry<bool> ChangeRocketSurvivorEffect;

			public static ConfigEntry<bool> ChangeRiskyTweaksScrapLauncherEffect;

			internal static void BindConfigOptions(ConfigFile config)
			{
				EnableEdit = Extensions.BindOption<bool>(config, "Pocket ICBM", "Enable Edit", "Enable the Pocket I.C.B.M edit that triples missile damage instead of firing 2 extra missiles? This will help performance! Disabling this will also disable all effect options below.", true, (ConfigFlags)1);
				ChangeArmedBackpackEffect = Extensions.BindOption<bool>(config, "Pocket ICBM", "Change Armed Backpack Effect", "Make Armed Backpack's ICBM effect triple missile damage instead of firing 2 extra missiles? This will help performance!", true, (ConfigFlags)1);
				ChangeATGEffect = Extensions.BindOption<bool>(config, "Pocket ICBM", "Change ATG Effect", "Make ATG's ICBM effect triple missile damage instead of firing 2 extra missiles? This will help performance!", true, (ConfigFlags)1);
				ChangeGenericMissileEffect = Extensions.BindOption<bool>(config, "Pocket ICBM", "Change Effect for generic missiles", "Make DML's and Engineer Harpoons' ICBM effect triple missile damage instead of firing 2 extra missiles? This will help performance!", true, (ConfigFlags)1);
				ChangePlasmaShrimpEffect = Extensions.BindOption<bool>(config, "Pocket ICBM", "Change Plasma Shrimp Effect", "Make Plasma Shrimp's ICBM effect triple missile damage instead of firing 2 extra missiles? This will help performance!", true, (ConfigFlags)1);
				ChangeRocketSurvivorEffect = Extensions.BindOption<bool>(config, "Pocket ICBM", "Change The Rocket Survivor Effect", "Make Rocket's ICBM effect triple missile damage instead of firing 2 extra missiles? This will help performance!", true, (ConfigFlags)1);
				ChangeRiskyTweaksScrapLauncherEffect = Extensions.BindOption<bool>(config, "Pocket ICBM", "Change RiskyTweaks MUL-T Scrap Launcher Effect", "Make RiskyTweaks' MUL-T scrap launcher ICBM synergy effect triple missile damage instead of firing 2 extra missiles? This will help performance!", true, (ConfigFlags)1);
			}
		}

		public static class BottledChaos
		{
			public static ConfigEntry<bool> EnableEdit;

			internal static void BindConfigOptions(ConfigFile config)
			{
				EnableEdit = Extensions.BindOption<bool>(config, "Bottled Chaos", "Enable Edit", "Enable the Bottled Chaos edit which makes it give some equipment cooldown reduction alongside it's normal effect?", true, (ConfigFlags)1);
			}
		}

		public static class Planula
		{
			public static ConfigEntry<bool> EnableEdit;
		}

		public static class ElectricBoomerang
		{
			public static ConfigEntry<bool> EnableEdit;

			internal static void BindConfigOptions(ConfigFile config)
			{
				EnableEdit = Extensions.BindOption<bool>(config, "Electric Boomerang", "Enable Edit", "Enable the Electric Boomerang edit that entirely changes what the item does?", true, (ConfigFlags)1);
			}
		}

		public static class MoltenPerforator
		{
			public static ConfigEntry<bool> EnableEdit;

			internal static void BindConfigOptions(ConfigFile config)
			{
				EnableEdit = Extensions.BindOption<bool>(config, "Molten Perforator", "Enable Edit", "Enable the Molten Perforator edit?", true, (ConfigFlags)1);
			}
		}

		public static class ExecutiveCard
		{
			public static ConfigEntry<bool> EnableEdit;

			public static ConfigEntry<bool> AddCreditCardToBottledChaos;

			internal static void BindConfigOptions(ConfigFile config)
			{
				EnableEdit = Extensions.BindOption<bool>(config, "Executive Card", "Enable Edit", "Enable the Executive Card edit that makes it more like a normal equipment?", true, (ConfigFlags)1);
				AddCreditCardToBottledChaos = Extensions.BindOption<bool>(config, "Executive Card", "Add edited effect to the Bottled Chaos pool", "Should the new effect for Executive Card be added to the equipment effect pool for Bottled Chaos?", true, (ConfigFlags)1);
			}
		}

		public static class Polylute
		{
			public static ConfigEntry<bool> EnableEdit;

			internal static void BindConfigOptions(ConfigFile config)
			{
				EnableEdit = Extensions.BindOption<bool>(config, "Polylute", "Enable Edit", "Enable the Polylute edit that makes it stack damage instead of hit amount?", true, (ConfigFlags)1);
			}
		}

		internal static void BindAllConfigOptions(ConfigFile config)
		{
			ATG.BindConfigOptions(config);
			BottledChaos.BindConfigOptions(config);
			ElectricBoomerang.BindConfigOptions(config);
			ExecutiveCard.BindConfigOptions(config);
			MoltenPerforator.BindConfigOptions(config);
			PocketICBM.BindConfigOptions(config);
			Polylute.BindConfigOptions(config);
			VoidDios.BindConfigOptions(config);
			Extensions.WipeConfig(config);
		}
	}
	internal static class ModLanguage
	{
		internal static List<string> LangFilesToLoad = new List<string>();

		internal static void AddNewLangTokens()
		{
			string path = Path.Combine(Path.GetDirectoryName(Plugin.PluginInfo.Location), "Language");
			foreach (string item in LangFilesToLoad)
			{
				foreach (KeyValuePair<string, Dictionary<string, string>> item2 in LoadFile(File.ReadAllText(Path.Combine(path, item + ".json"))))
				{
					string key = item2.Key;
					foreach (KeyValuePair<string, string> item3 in item2.Value)
					{
						LanguageAPI.AddOverlay(item3.Key, item3.Value, key);
					}
				}
			}
		}

		private static Dictionary<string, Dictionary<string, string>>? LoadFile(string fileContent)
		{
			Dictionary<string, Dictionary<string, string>> dictionary = new Dictionary<string, Dictionary<string, string>>();
			try
			{
				JSONNode val = JSON.Parse(fileContent);
				if (val == (object)null)
				{
					return null;
				}
				foreach (string key in val.Keys)
				{
					JSONNode val2 = val[key];
					if (val2 == (object)null)
					{
						continue;
					}
					string text = key;
					if (text == "strings")
					{
						text = "generic";
					}
					if (!dictionary.ContainsKey(text))
					{
						dictionary.Add(text, new Dictionary<string, string>());
					}
					Dictionary<string, string> dictionary2 = dictionary[text];
					foreach (string key2 in val2.Keys)
					{
						dictionary2.Add(key2, val2[key2].Value);
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"Parsing error in language file, Error: {arg}");
				return null;
			}
			if (dictionary.Count == 0)
			{
				return null;
			}
			return dictionary;
		}
	}
	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 ModUtil
	{
		internal static void LogILInstructions(this ILWeaver iLWeaver)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Enumerator<Instruction> enumerator = iLWeaver.Instructions.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Log.Warning(enumerator.Current);
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("LordVGames.LordsItemEdits", "LordsItemEdits", "0.4.1")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Id = "LordVGames.LordsItemEdits";

		public static PluginInfo PluginInfo { get; private set; }

		public static string Name => "LordsItemEdits";

		public static string Version => "0.4.1";

		public void Awake()
		{
			PluginInfo = ((BaseUnityPlugin)this).Info;
			Log.Init(((BaseUnityPlugin)this).Logger);
			ConfigOptions.BindAllConfigOptions(((BaseUnityPlugin)this).Config);
			MonoDetourManager.InvokeHookInitializers(typeof(Plugin).Assembly, false);
			ModLanguage.AddNewLangTokens();
		}
	}
}
namespace LordsItemEdits.MultiItemEdits
{
	[MonoDetourTargets(typeof(MissileUtils))]
	internal static class Missiles
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__ChangeICBMEffect;

			public static Func<float, CharacterBody, float> <1>__ReplaceOldICBMDamageMult;
		}

		[MonoDetourHookInitialize]
		private static void Setup()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			if (ConfigOptions.PocketICBM.EnableEdit.Value && ConfigOptions.PocketICBM.ChangeGenericMissileEffect.Value)
			{
				object obj = <>O.<0>__ChangeICBMEffect;
				if (obj == null)
				{
					Manipulator val = ChangeICBMEffect;
					<>O.<0>__ChangeICBMEffect = val;
					obj = (object)val;
				}
				FireMissile_UnityEngine_Vector3_RoR2_CharacterBody_RoR2_ProcChainMask_UnityEngine_GameObject_System_Single_System_Boolean_UnityEngine_GameObject_RoR2_DamageColorIndex_UnityEngine_Vector3_System_Single_System_Boolean.ILHook((Manipulator)obj);
			}
		}

		private static void ChangeICBMEffect(ILManipulationInfo info)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			ILWeaver w = new ILWeaver(info);
			w.MatchRelaxed(new Predicate<Instruction>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchMul(x),
				(Instruction x) => ILPatternMatchingExt.MatchAdd(x),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Mathf>(x, "Max") && w.SetCurrentTo(x),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 1)
			}).ThrowIfFailure().InsertAfterCurrent((IEnumerable<Instruction>)new <>z__ReadOnlyArray<Instruction>((Instruction[])(object)new Instruction[2]
			{
				w.Create(OpCodes.Ldarg_1),
				w.CreateCall((Delegate)new Func<float, CharacterBody, float>(ReplaceOldICBMDamageMult))
			}));
			ILLabel jumpToEnd = w.DefineLabel();
			w.MatchRelaxed(new Predicate<Instruction>[5]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 0) && w.SetCurrentTo(x),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchBle(x, ref jumpToEnd),
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 2),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Object>(x, "op_Implicit")
			}).ThrowIfFailure().InsertBeforeCurrent((IEnumerable<Instruction>)new <>z__ReadOnlySingleElementList<Instruction>(w.Create(OpCodes.Br, (object)jumpToEnd)));
		}

		private static float ReplaceOldICBMDamageMult(float oldDamageMult, CharacterBody attackerBody)
		{
			return PocketICBM.GetICBMDamageMult(attackerBody);
		}

		internal static void FireMissileOrb(CharacterBody attackerBody, float missileDamage, DamageInfo damageInfo, GameObject victim)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			if (!((Object)(object)victim == (Object)null) && (int)attackerBody.teamComponent.teamIndex == 1)
			{
				CharacterBody component = victim.GetComponent<CharacterBody>();
				FireMissileOrb(attackerBody, missileDamage, damageInfo, component, addMissileProc: true);
			}
		}

		internal static void FireMissileOrb(CharacterBody attackerBody, float missileDamage, DamageInfo damageInfo, CharacterBody victimBody, bool addMissileProc)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_0018: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			if (!((Object)(object)victimBody == (Object)null) && (int)attackerBody.teamComponent.teamIndex == 1)
			{
				MicroMissileOrb val = new MicroMissileOrb
				{
					origin = attackerBody.aimOrigin,
					damageValue = missileDamage,
					isCrit = damageInfo.crit,
					teamIndex = attackerBody.teamComponent.teamIndex,
					attacker = ((Component)attackerBody).gameObject,
					procChainMask = damageInfo.procChainMask,
					procCoefficient = 1f,
					damageColorIndex = (DamageColorIndex)3,
					target = victimBody.mainHurtBox
				};
				if (addMissileProc)
				{
					((ProcChainMask)(ref ((GenericDamageOrb)val).procChainMask)).AddProc((ProcType)1);
				}
				if (ConfigOptions.PocketICBM.EnableEdit.Value && ((ConfigOptions.PocketICBM.ChangeATGEffect.Value && addMissileProc) || (ConfigOptions.PocketICBM.ChangeArmedBackpackEffect.Value && !addMissileProc)))
				{
					((GenericDamageOrb)val).damageValue = ((GenericDamageOrb)val).damageValue * PocketICBM.GetICBMDamageMult(attackerBody);
				}
				else
				{
					OrbManager.instance.AddOrb((Orb)(object)val);
					OrbManager.instance.AddOrb((Orb)(object)val);
					Util.PlaySound("Play_item_proc_missile_fire", ((Component)attackerBody).gameObject);
					Util.PlaySound("Play_item_proc_missile_fire", ((Component)attackerBody).gameObject);
				}
				OrbManager.instance.AddOrb((Orb)(object)val);
				Util.PlaySound("Play_item_proc_missile_fire", ((Component)attackerBody).gameObject);
			}
		}
	}
}
namespace LordsItemEdits.ModSupport.WolfFixes
{
	internal class WolfFixesMod
	{
		internal const string ModGUID = "Early.Wolfo.WolfFixes";

		private static bool? _enabled;

		internal static bool ModIsRunning
		{
			get
			{
				bool valueOrDefault = _enabled.GetValueOrDefault();
				if (!_enabled.HasValue)
				{
					valueOrDefault = Chainloader.PluginInfos.ContainsKey("Early.Wolfo.WolfFixes");
					_enabled = valueOrDefault;
				}
				return _enabled.Value;
			}
		}
	}
}
namespace LordsItemEdits.ModSupport.RocketSurvivorGuy
{
	[MonoDetourTargets(typeof(FireRocket))]
	internal static class PrimaryICBMSupport
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__ChangeICBMEffect;

			public static Func<float, EntityState, float> <1>__ChangeDamageBasedOnICBM;
		}

		[MonoDetourHookInitialize]
		internal 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.PocketICBM.ChangeRocketSurvivorEffect.Value)
			{
				object obj = <>O.<0>__ChangeICBMEffect;
				if (obj == null)
				{
					Manipulator val = ChangeICBMEffect;
					<>O.<0>__ChangeICBMEffect = val;
					obj = (object)val;
				}
				OnEnter.ILHook((Manipulator)obj);
			}
		}

		private static void ChangeICBMEffect(ILManipulationInfo info)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			ILWeaver w = new ILWeaver(info);
			ILLabel val = default(ILLabel);
			w.MatchRelaxed(new Predicate<Instruction>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 5),
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 5) && w.SetCurrentTo(x),
				(Instruction x) => ILPatternMatchingExt.MatchBrfalse(x, ref val)
			}).ThrowIfFailure().InsertAfterCurrent((IEnumerable<Instruction>)new <>z__ReadOnlySingleElementList<Instruction>(w.Create(OpCodes.Pop)))
				.Next.OpCode = OpCodes.Br;
			w.MatchRelaxed(new Predicate<Instruction>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<BaseState>(x, "damageStat"),
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld<FireRocket>(x, "damageCoefficient"),
				(Instruction x) => ILPatternMatchingExt.MatchMul(x) && w.SetCurrentTo(x)
			}).ThrowIfFailure().InsertAfterCurrent((IEnumerable<Instruction>)new <>z__ReadOnlyArray<Instruction>((Instruction[])(object)new Instruction[2]
			{
				w.Create(OpCodes.Ldarg_0),
				w.CreateCall((Delegate)new Func<float, EntityState, float>(ChangeDamageBasedOnICBM))
			}));
		}

		private static float ChangeDamageBasedOnICBM(float damage, EntityState entityState)
		{
			return damage * PocketICBM.GetICBMDamageMult(entityState.characterBody);
		}
	}
}
namespace LordsItemEdits.ModSupport.RiskyTweaksMod
{
	[MonoDetourTargets(typeof(ScrapICBM), GenerateControlFlowVariants = true)]
	internal static class MulTScrapLauncherSynergyEdit
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__JustDoMyThing;

			public static Action<FireGrenadeLauncher> <1>__ChangeICBMSynergy;
		}

		[MonoDetourHookInitialize]
		internal 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.PocketICBM.ChangeRiskyTweaksScrapLauncherEffect.Value)
			{
				object obj = <>O.<0>__JustDoMyThing;
				if (obj == null)
				{
					Manipulator val = JustDoMyThing;
					<>O.<0>__JustDoMyThing = val;
					obj = (object)val;
				}
				FireGrenadeLauncher_ModifyProjectileAimRay.ILHook((Manipulator)obj);
			}
		}

		private static void JustDoMyThing(ILManipulationInfo info)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			ILWeaver w = new ILWeaver(info);
			ILLabel val = w.DefineLabel();
			w.InsertBeforeCurrent((IEnumerable<Instruction>)new <>z__ReadOnlyArray<Instruction>((Instruction[])(object)new Instruction[3]
			{
				w.Create(OpCodes.Ldarg_2),
				w.CreateCall((Delegate)new Action<FireGrenadeLauncher>(ChangeICBMSynergy)),
				w.Create(OpCodes.Br, (object)val)
			}));
			MethodReference val2 = default(MethodReference);
			w.MatchRelaxed(new Predicate<Instruction>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1) && w.SetCurrentTo(x),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 2),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 3),
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, ref val2)
			}).ThrowIfFailure().MarkLabelToCurrentPrevious(val);
		}

		private static void ChangeICBMSynergy(FireGrenadeLauncher fireGrenadeLauncherState)
		{
			((GenericProjectileBaseState)fireGrenadeLauncherState).damageCoefficient = ((GenericProjectileBaseState)fireGrenadeLauncherState).damageCoefficient * PocketICBM.GetICBMDamageMult(((EntityState)fireGrenadeLauncherState).characterBody);
		}
	}
	internal static class RiskyTweaksMod
	{
		internal const string GUID = "com.Moffein.RiskyTweaks";

		private static bool? _enabled;

		internal static bool ModIsRunning
		{
			get
			{
				bool valueOrDefault = _enabled.GetValueOrDefault();
				if (!_enabled.HasValue)
				{
					valueOrDefault = Chainloader.PluginInfos.ContainsKey("com.Moffein.RiskyTweaks");
					_enabled = valueOrDefault;
				}
				return _enabled.Value;
			}
		}
	}
}
namespace LordsItemEdits.ItemEdits
{
	[MonoDetourTargets(typeof(GlobalEventManager))]
	internal static class ATG
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__FireOrbIfItsFair;

			public static Func<CharacterBody, float, DamageInfo, GameObject, bool> <1>__FireMissileOrbReturnFairness;
		}

		[MonoDetourHookInitialize]
		internal 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.ATG.EnableEdit.Value)
			{
				object obj = <>O.<0>__FireOrbIfItsFair;
				if (obj == null)
				{
					Manipulator val = FireOrbIfItsFair;
					<>O.<0>__FireOrbIfItsFair = val;
					obj = (object)val;
				}
				ProcessHitEnemy.ILHook((Manipulator)obj);
			}
		}

		private static void FireOrbIfItsFair(ILManipulationInfo info)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			ILWeaver w = new ILWeaver(info);
			ILLabel val = w.DefineLabel();
			int missileDamageVariableNumber = 0;
			FieldReference val2 = default(FieldReference);
			w.MatchRelaxed(new Predicate<Instruction>[7]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.Util", "OnHitProcDamage"),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref missileDamageVariableNumber),
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 0) && w.SetCurrentTo(x),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<CharacterBody>(x, "get_corePosition"),
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, ref val2)
			}).ThrowIfFailure().InsertBeforeCurrent((IEnumerable<Instruction>)new <>z__ReadOnlyArray<Instruction>((Instruction[])(object)new Instruction[6]
			{
				w.Create(OpCodes.Ldloc, 0),
				w.Create(OpCodes.Ldloc, missileDamageVariableNumber),
				w.Create(OpCodes.Ldarg_1),
				w.Create(OpCodes.Ldarg_2),
				w.CreateCall((Delegate)new Func<CharacterBody, float, DamageInfo, GameObject, bool>(FireMissileOrbReturnFairness)),
				w.Create(OpCodes.Brtrue, (object)val)
			}));
			w.MatchRelaxed(new Predicate<Instruction>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.GlobalEventManager/CommonAssets", "missilePrefab"),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 3),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 1),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, "RoR2.MissileUtils", "FireMissile") && w.SetCurrentTo(x)
			}).ThrowIfFailure().MarkLabelToCurrentNext(val);
		}

		private static bool FireMissileOrbReturnFairness(CharacterBody attackerBody, float missileDamage, DamageInfo damageInfo, GameObject victim)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			Missiles.FireMissileOrb(attackerBody, missileDamage, damageInfo, victim);
			return (int)attackerBody.teamComponent.teamIndex == 1;
		}
	}
	[MonoDetourTargets(typeof(Inventory))]
	internal static class BottledChaos
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__SetupBhaosCooldownReduction;

			public static Func<Inventory, float, float> <1>__AddBhaosCooldownReduction;
		}

		[MonoDetourHookInitialize]
		internal static void Setup()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			if (ConfigOptions.BottledChaos.EnableEdit.Value)
			{
				ModLanguage.LangFilesToLoad.Add("BottledChaos");
				object obj = <>O.<0>__SetupBhaosCooldownReduction;
				if (obj == null)
				{
					Manipulator val = SetupBhaosCooldownReduction;
					<>O.<0>__SetupBhaosCooldownReduction = val;
					obj = (object)val;
				}
				CalculateEquipmentCooldownScale.ILHook((Manipulator)obj);
			}
		}

		private static void SetupBhaosCooldownReduction(ILManipulationInfo info)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			ILWeaver w = new ILWeaver(info);
			w.MatchRelaxed(new Predicate<Instruction>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 3) && w.SetCurrentTo(x),
				(Instruction x) => ILPatternMatchingExt.MatchRet(x)
			}).ThrowIfFailure().InsertBeforeCurrentStealLabels((IEnumerable<Instruction>)new <>z__ReadOnlyArray<Instruction>((Instruction[])(object)new Instruction[4]
			{
				w.Create(OpCodes.Ldarg_0),
				w.Create(OpCodes.Ldloc_3),
				w.CreateCall((Delegate)new Func<Inventory, float, float>(AddBhaosCooldownReduction)),
				w.Create(OpCodes.Stloc_3)
			}));
		}

		private static float AddBhaosCooldownReduction(Inventory inventory, float currentCooldownReduction)
		{
			if (inventory.GetItemCountEffective(Items.RandomEquipmentTrigger) > 0)
			{
				return currentCooldownReduction *= 0.65f;
			}
			return currentCooldownReduction;
		}
	}
	[MonoDetourTargets(typeof(BoomerangProjectile))]
	internal static class ElectricBoomerang
	{
		private class LieElectricBoomerangInfo
		{
			internal bool HasBoomerangOut;
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static ProcessHitEnemy.PostfixSignature <0>__GlobalEventManager_ProcessHitEnemy;

			public static Manipulator <1>__MakeBoomerangBetter;

			public static Manipulator <2>__InsertRemoveProjectileOwnerFromFiredList;

			public static Func<DamageInfo, int, bool> <3>__ShouldAllowNewElectricBoomerang;

			public static Func<DamageInfo, int, float> <4>__GetNewDamageValue;

			public static Action<CharacterBody> <5>__TryAddCharacterBodyToFiredBoomerangsList;

			public static Action<BoomerangProjectile> <6>__TryRemoveProjectileOwnerFromFiredList;
		}

		private const float _damagePerHit = 3.75f;

		private const float _damagePerHitStack = 2.75f;

		private static readonly AssetReferenceT<GameObject> _electricBoomerangProjectileAsset = new AssetReferenceT<GameObject>(RoR2_DLC2_Items_StunAndPierce.StunAndPierceBoomerang_prefab);

		private static readonly AssetReferenceT<ItemDef> _electricBoomerangItemDef = new AssetReferenceT<ItemDef>(RoR2_DLC2_Items_StunAndPierce.StunAndPierce_asset);

		private static readonly FixedConditionalWeakTable<GameObject, LieElectricBoomerangInfo> _lieElectricBoomerangInfoTable = new FixedConditionalWeakTable<GameObject, LieElectricBoomerangInfo>();

		[MonoDetourHookInitialize]
		internal static void Setup()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			if (ConfigOptions.ElectricBoomerang.EnableEdit.Value)
			{
				ModLanguage.LangFilesToLoad.Add("ElectricBoomerang");
				EditBoomerangProjectile();
				AIBlacklistNewBoomerang();
				ProcessHitEnemy.Postfix(GlobalEventManager_ProcessHitEnemy);
				object obj = <>O.<1>__MakeBoomerangBetter;
				if (obj == null)
				{
					Manipulator val = MakeBoomerangBetter;
					<>O.<1>__MakeBoomerangBetter = val;
					obj = (object)val;
				}
				ProcessHitEnemy.ILHook((Manipulator)obj);
				object obj2 = <>O.<2>__InsertRemoveProjectileOwnerFromFiredList;
				if (obj2 == null)
				{
					Manipulator val2 = InsertRemoveProjectileOwnerFromFiredList;
					<>O.<2>__InsertRemoveProjectileOwnerFromFiredList = val2;
					obj2 = (object)val2;
				}
				Mdh.RoR2.Projectile.BoomerangProjectile.FixedUpdate.ILHook((Manipulator)obj2);
			}
		}

		private static void GlobalEventManager_ProcessHitEnemy(GlobalEventManager self, ref DamageInfo damageInfo, ref GameObject victim)
		{
			if ((Object)(object)victim != (Object)null && (Object)(object)damageInfo.inflictor != (Object)null && ((Object)damageInfo.inflictor).name == "StunAndPierceBoomerang(Clone)")
			{
				Util.PlaySound("Play_item_proc_chain_lightning", victim);
				Util.PlaySound("Play_item_proc_chain_lightning", victim);
				Util.PlaySound("Play_item_proc_chain_lightning", victim);
				Util.PlaySound("Play_item_proc_chain_lightning", victim);
				Util.PlaySound("Play_item_proc_chain_lightning", victim);
				Util.PlaySound("Play_item_proc_chain_lightning", victim);
			}
		}

		private static void EditBoomerangProjectile()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			AsyncOperationHandle<GameObject> val = AssetAsyncReferenceManager<GameObject>.LoadAsset(_electricBoomerangProjectileAsset, (AsyncReferenceHandleUnloadType)2);
			val.Completed += delegate(AsyncOperationHandle<GameObject> handle)
			{
				BoomerangProjectile component = handle.Result.GetComponent<BoomerangProjectile>();
				component.distanceMultiplier *= 0.15f;
				component.travelSpeed *= 3f;
				Extensions.TryDestroyComponent<ProjectileOverlapAttack>(handle.Result);
				AssetAsyncReferenceManager<GameObject>.UnloadAsset(_electricBoomerangProjectileAsset);
			};
		}

		private static void AIBlacklistNewBoomerang()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			AsyncOperationHandle<ItemDef> val = AssetAsyncReferenceManager<ItemDef>.LoadAsset(_electricBoomerangItemDef, (AsyncReferenceHandleUnloadType)2);
			val.Completed += delegate(AsyncOperationHandle<ItemDef> handle)
			{
				ItemDef result = handle.Result;
				ItemTag[] tags = result.tags;
				int num = 0;
				ItemTag[] array = (ItemTag[])(object)new ItemTag[1 + tags.Length];
				ReadOnlySpan<ItemTag> readOnlySpan = new ReadOnlySpan<ItemTag>(tags);
				readOnlySpan.CopyTo(new Span<ItemTag>(array).Slice(num, readOnlySpan.Length));
				num += readOnlySpan.Length;
				array[num] = (ItemTag)4;
				result.tags = array;
				AssetAsyncReferenceManager<ItemDef>.UnloadAsset(_electricBoomerangItemDef);
			};
		}

		private static void MakeBoomerangBetter(ILManipulationInfo info)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			ILWeaver w = new ILWeaver(info);
			ILLabel skipElectricBoomerangCode = w.DefineLabel();
			ILLabel val = w.DefineLabel();
			ILLabel val2 = w.DefineLabel();
			int electricBoomerangEffectiveCountVariableNumber = 0;
			int setDamageVariableNumber = 0;
			int num3 = default(int);
			w.MatchRelaxed(new Predicate<Instruction>[6]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC2Content/Items", "StunAndPierce"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective"),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref num3),
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref electricBoomerangEffectiveCountVariableNumber) && w.SetCurrentTo(x),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchBle(x, ref skipElectricBoomerangCode)
			}).ThrowIfFailure().InsertBeforeCurrent((IEnumerable<Instruction>)new <>z__ReadOnlyArray<Instruction>((Instruction[])(object)new Instruction[5]
			{
				w.Create(OpCodes.Ldarg_1),
				w.Create(OpCodes.Ldloc, 24),
				w.CreateCall((Delegate)new Func<DamageInfo, int, bool>(ShouldAllowNewElectricBoomerang)),
				w.Create(OpCodes.Brfalse, (object)skipElectricBoomerangCode),
				w.Create(OpCodes.Br, (object)val)
			}));
			int num2 = default(int);
			int num = default(int);
			MethodReference val4 = default(MethodReference);
			ILLabel val3 = default(ILLabel);
			w.MatchRelaxed(new Predicate<Instruction>[8]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 15f),
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<DamageInfo>(x, "procCoefficient"),
				(Instruction x) => ILPatternMatchingExt.MatchMul(x),
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref num2),
				(Instruction x) => ILPatternMatchingExt.MatchLdloca(x, ref num),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, ref val4),
				(Instruction x) => ILPatternMatchingExt.MatchBrfalse(x, ref val3) && w.SetCurrentTo(x)
			}).ThrowIfFailure().MarkLabelToCurrentNext(val)
				.CurrentToNext()
				.InsertBeforeCurrentStealLabels((IEnumerable<Instruction>)new <>z__ReadOnlyArray<Instruction>((Instruction[])(object)new Instruction[7]
				{
					w.Create(OpCodes.Ldarg_1),
					w.Create(OpCodes.Ldloc, electricBoomerangEffectiveCountVariableNumber),
					w.CreateCall((Delegate)new Func<DamageInfo, int, float>(GetNewDamageValue)),
					w.Create(OpCodes.Stloc, setDamageVariableNumber),
					w.Create(OpCodes.Ldloc_0),
					w.CreateCall((Delegate)new Action<CharacterBody>(TryAddCharacterBodyToFiredBoomerangsList)),
					w.Create(OpCodes.Br, (object)val2)
				}));
			w.MatchRelaxed(new Predicate<Instruction>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 27),
				(Instruction x) => ILPatternMatchingExt.MatchConvR4(x),
				(Instruction x) => ILPatternMatchingExt.MatchMul(x),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref setDamageVariableN