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.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.Events;
using HG.Reflection;
using HarmonyLib;
using LordsStarstormEdits.SS2Edits.Items;
using MSU;
using MSU.Config;
using Microsoft.CodeAnalysis;
using MiscFixes.Modules;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using MonoDetourHooks.EntityStates.Events.Storm;
using MonoDetourHooks.SS2.Components.ChirrFriendController;
using MonoDetourHooks.SS2.Components.ChirrFriendOrb;
using MonoDetourHooks.SS2.Components.ChirrFriendTracker;
using MonoDetourHooks.SS2.Components.Empyrean;
using MonoDetourHooks.SS2.Components.KnightPassiveController;
using MonoDetourHooks.SS2.EliteEventMissionController;
using MonoDetourHooks.SS2.Equipments.AffixSuperEarth;
using MonoDetourHooks.SS2.Equipments.AffixSuperFire;
using MonoDetourHooks.SS2.Equipments.AffixSuperIce;
using MonoDetourHooks.SS2.Equipments.AffixSuperLightning;
using MonoDetourHooks.SS2.ExtraEquipmentManager;
using MonoDetourHooks.SS2.Items.AffixUltra;
using MonoDetourHooks.SS2.Items.FieldAccelerator;
using MonoDetourHooks.SS2.TeleporterUpgradeController;
using MonoDetourHooks.SS2.TradeController;
using MonoMod.Cil;
using R2API;
using RoR2;
using RoR2.Items;
using SS2;
using SS2.Components;
using SS2.Equipments;
using SS2.Items;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MonoDetourHooks.EntityStates.Events.Storm
{
	internal static class OnTeleporterChargedGlobal
	{
		public delegate void PrefixSignature(Storm self, ref TeleporterInteraction _);

		public delegate void PostfixSignature(Storm self, ref TeleporterInteraction _);

		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(Storm).GetMethod("OnTeleporterChargedGlobal", (BindingFlags)(-1), null, new Type[1] { typeof(TeleporterInteraction) }, null) ?? throw new MissingMethodException("EntityStates.Events.Storm", "OnTeleporterChargedGlobal");
		}
	}
	internal static class FixedUpdate
	{
		public delegate void PrefixSignature(Storm self);

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

		public delegate void PostfixSignature(Storm 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(Storm).GetMethod("OnEnter", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("EntityStates.Events.Storm", "OnEnter");
		}
	}
	internal static class ModifySpawnedMasters
	{
	}
	internal static class ModifySpawnedBoss
	{
	}
	internal static class CreateStormElite
	{
	}
	internal static class BuffEnemy
	{
	}
	internal static class GETDUMBASSTOKENDELETELATER
	{
	}
	internal static class ShouldCharge
	{
	}
	internal static class CalculateCharge
	{
	}
	internal static class OnExit
	{
	}
	internal static class OnSerialize
	{
	}
	internal static class OnDeserialize
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class OnBossKilled
	{
		internal static class OnKilledServer
		{
		}

		internal static class _ctor
		{
		}
	}
}
namespace MonoDetourHooks.SS2.Equipments.AffixSuperEarth
{
	internal static class Behavior
	{
		internal static class OnEnable
		{
			public delegate void PrefixSignature(Behavior self);

			public delegate void PostfixSignature(Behavior self);

			public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(Behavior).GetMethod("OnEnable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Equipments.AffixSuperEarth+Behavior", "OnEnable");
			}
		}

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

			public delegate void PostfixSignature(Behavior self);

			public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(Behavior).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Equipments.AffixSuperEarth+Behavior", "FixedUpdate");
			}
		}

		internal static class GetBuffDef
		{
		}

		internal static class FireProjectiles
		{
		}

		internal static class OnDisable
		{
		}

		internal static class _ctor
		{
		}

		internal static class _cctor
		{
		}
	}
}
namespace MonoDetourHooks.SS2.Equipments.AffixSuperLightning
{
	internal static class Behavior
	{
		internal static class OnEnable
		{
			public delegate void PrefixSignature(Behavior self);

			public delegate void PostfixSignature(Behavior self);

			public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(Behavior).GetMethod("OnEnable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Equipments.AffixSuperLightning+Behavior", "OnEnable");
			}
		}

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

			public delegate void PostfixSignature(Behavior self);

			public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(Behavior).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Equipments.AffixSuperLightning+Behavior", "FixedUpdate");
			}
		}

		internal static class GetBuffDef
		{
		}

		internal static class FindTarget
		{
		}

		internal static class OnDisable
		{
		}

		internal static class _ctor
		{
		}

		internal static class _cctor
		{
		}
	}
}
namespace MonoDetourHooks.SS2.Equipments.AffixSuperIce
{
	internal static class Behavior
	{
		internal static class OnEnable
		{
			public delegate void PrefixSignature(Behavior self);

			public delegate void PostfixSignature(Behavior self);

			public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(Behavior).GetMethod("OnEnable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Equipments.AffixSuperIce+Behavior", "OnEnable");
			}
		}

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

			public delegate void PostfixSignature(Behavior self);

			public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(Behavior).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Equipments.AffixSuperIce+Behavior", "FixedUpdate");
			}
		}

		internal static class GetBuffDef
		{
		}

		internal static class FireProjectiles
		{
		}

		internal static class OnDisable
		{
		}

		internal static class IsStrikePointTooCloseToPreviousPoint
		{
		}

		internal static class _ctor
		{
		}

		internal static class _cctor
		{
		}

		internal static class TimedServerPositionData
		{
			internal static class _ctor
			{
			}

			internal static class _ctor_UnityEngine_Vector3_System_Single
			{
			}
		}
	}
}
namespace MonoDetourHooks.SS2.Equipments.AffixSuperFire
{
	internal static class Behavior
	{
		internal static class OnEnable
		{
			public delegate void PrefixSignature(Behavior self);

			public delegate void PostfixSignature(Behavior self);

			public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(Behavior).GetMethod("OnEnable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Equipments.AffixSuperFire+Behavior", "OnEnable");
			}
		}

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

			public delegate void PostfixSignature(Behavior self);

			public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(Behavior).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Equipments.AffixSuperFire+Behavior", "FixedUpdate");
			}
		}

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

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

			public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(Behavior).GetMethod("OnTakeDamageServer", (BindingFlags)(-1), null, new Type[1] { typeof(DamageReport) }, null) ?? throw new MissingMethodException("SS2.Equipments.AffixSuperFire+Behavior", "OnTakeDamageServer");
			}
		}

		internal static class GetBuffDef
		{
		}

		internal static class OnDisable
		{
		}

		internal static class FireProjectiles
		{
		}

		internal static class _ctor
		{
		}

		internal static class _cctor
		{
		}
	}
}
namespace MonoDetourHooks.SS2.TradeController
{
	internal static class Start
	{
		public delegate void PrefixSignature(TradeController self);

		public delegate ReturnFlow ControlFlowPrefixSignature(TradeController self);

		public delegate void PostfixSignature(TradeController 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(TradeController).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.TradeController", "Start");
		}
	}
	internal static class InitPrefabTEMP
	{
		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(TradeController).GetMethod("InitPrefabTEMP", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.TradeController", "InitPrefabTEMP");
		}
	}
	internal static class get_lastTradedItemIndex
	{
	}
	internal static class set_lastTradedItemIndex
	{
	}
	internal static class Awake
	{
	}
	internal static class SetOptionsFromInteractor
	{
	}
	internal static class BeginTrading
	{
	}
	internal static class _ctor
	{
	}
	internal static class UNetVersion
	{
	}
	internal static class OnSerialize
	{
	}
	internal static class OnDeserialize
	{
	}
	internal static class PreStartClient
	{
	}
}
namespace MonoDetourHooks.SS2.Items.FieldAccelerator
{
	internal static class Behavior
	{
		internal static class Start
		{
			public delegate void PrefixSignature(Behavior self);

			public delegate void PostfixSignature(Behavior self);

			public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
			{
				return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(Behavior).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Items.FieldAccelerator+Behavior", "Start");
			}
		}

		internal static class GetItemDef
		{
		}

		internal static class OnKilledOtherServer
		{
		}

		internal static class TeleporterInteraction_onTeleporterBeginChargingGlobal
		{
		}

		internal static class OnDestroy
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class FieldAcceleratorTeleporterBehavior
	{
		internal static class TeleporterInteraction_onTeleporterChargedGlobal
		{
			public delegate void PrefixSignature(FieldAcceleratorTeleporterBehavior self, ref TeleporterInteraction tele);

			public delegate void PostfixSignature(FieldAcceleratorTeleporterBehavior self, ref TeleporterInteraction tele);

			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(FieldAcceleratorTeleporterBehavior).GetMethod("TeleporterInteraction_onTeleporterChargedGlobal", (BindingFlags)(-1), null, new Type[1] { typeof(TeleporterInteraction) }, null) ?? throw new MissingMethodException("SS2.Items.FieldAccelerator+FieldAcceleratorTeleporterBehavior", "TeleporterInteraction_onTeleporterChargedGlobal");
			}
		}

		internal static class FixedUpdate
		{
			public delegate void PrefixSignature(FieldAcceleratorTeleporterBehavior self);

			public delegate void PostfixSignature(FieldAcceleratorTeleporterBehavior 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(FieldAcceleratorTeleporterBehavior).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Items.FieldAccelerator+FieldAcceleratorTeleporterBehavior", "FixedUpdate");
			}
		}

		internal static class Awake
		{
		}

		internal static class TeleporterInteraction_onTeleporterBeginChargingGlobal
		{
		}

		internal static class UpgradeTeleporterRadius
		{
		}

		internal static class RecalcRadius
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class Initialize
	{
		public delegate void PrefixSignature(FieldAccelerator self);

		public delegate void PostfixSignature(FieldAccelerator 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(FieldAccelerator).GetMethod("Initialize", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Items.FieldAccelerator", "Initialize");
		}
	}
	internal static class get_AssetRequest
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class __c
	{
		internal static class _ctor
		{
		}
	}
}
namespace MonoDetourHooks.SS2.Items.AffixUltra
{
	internal static class BodyBehavior
	{
		internal static class Start
		{
			public delegate void PrefixSignature(BodyBehavior self);

			public delegate ReturnFlow ControlFlowPrefixSignature(BodyBehavior self);

			public delegate void PostfixSignature(BodyBehavior 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(BodyBehavior).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Items.AffixUltra+BodyBehavior", "Start");
			}
		}

		internal static class GetItemDef
		{
		}

		internal static class OnDestroy
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class RecalculateStatsAPI_GetStatCoefficients
	{
		public delegate void PrefixSignature(AffixUltra self, ref CharacterBody body, ref StatHookEventArgs args);

		public delegate ReturnFlow ControlFlowPrefixSignature(AffixUltra self, ref CharacterBody body, ref StatHookEventArgs args);

		public delegate void PostfixSignature(AffixUltra self, ref CharacterBody body, ref StatHookEventArgs args);

		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(AffixUltra).GetMethod("RecalculateStatsAPI_GetStatCoefficients", (BindingFlags)(-1), null, new Type[2]
			{
				typeof(CharacterBody),
				typeof(StatHookEventArgs)
			}, null) ?? throw new MissingMethodException("SS2.Items.AffixUltra", "RecalculateStatsAPI_GetStatCoefficients");
		}
	}
	internal static class Initialize
	{
		public delegate void PrefixSignature(AffixUltra self);

		public delegate ReturnFlow ControlFlowPrefixSignature(AffixUltra self);

		public delegate void PostfixSignature(AffixUltra 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(AffixUltra).GetMethod("Initialize", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Items.AffixUltra", "Initialize");
		}
	}
	internal static class get_AssetRequest
	{
	}
	internal static class IsAvailable
	{
	}
	internal static class _ctor
	{
	}
}
namespace MonoDetourHooks.SS2.Components.ChirrFriendOrb
{
	internal static class ConvertBehavior
	{
		internal static class FixedUpdate
		{
			public delegate void PrefixSignature(ConvertBehavior self);

			public delegate void PostfixSignature(ConvertBehavior 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(ConvertBehavior).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Components.ChirrFriendOrb+ConvertBehavior", "FixedUpdate");
			}
		}

		internal static class OnTakeDamageServer
		{
			public delegate void PrefixSignature(ConvertBehavior self, ref DamageReport damageReport);

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

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

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

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

			public static MethodBase Target()
			{
				return typeof(ConvertBehavior).GetMethod("OnTakeDamageServer", (BindingFlags)(-1), null, new Type[1] { typeof(DamageReport) }, null) ?? throw new MissingMethodException("SS2.Components.ChirrFriendOrb+ConvertBehavior", "OnTakeDamageServer");
			}
		}

		internal static class Awake
		{
		}

		internal static class _ctor
		{
		}
	}
}
namespace MonoDetourHooks.SS2.Components.ChirrFriendController
{
	internal static class OnEnable
	{
		public delegate void PrefixSignature(ChirrFriendController self);

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

		public delegate void PostfixSignature(ChirrFriendController 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(ChirrFriendController).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Components.ChirrFriendController", "FixedUpdate");
		}
	}
	internal static class ItemFilter
	{
		public delegate void PrefixSignature(ChirrFriendController self, ref ItemIndex itemIndex);

		public delegate void PostfixSignature(ChirrFriendController self, ref ItemIndex itemIndex, ref bool returnValue);

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

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

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

		public static MethodBase Target()
		{
			return typeof(ChirrFriendController).GetMethod("ItemFilter", (BindingFlags)(-1), null, new Type[1] { typeof(ItemIndex) }, null) ?? throw new MissingMethodException("SS2.Components.ChirrFriendController", "ItemFilter");
		}
	}
	internal static class get_isScepter
	{
	}
	internal static class set_isScepter
	{
	}
	internal static class get_hasFriend
	{
	}
	internal static class Awake
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class UpdateScepter
	{
	}
	internal static class CheckFriendLeftTeam
	{
	}
	internal static class ItemIsScepter
	{
	}
	internal static class ShareNewItem
	{
	}
	internal static class OnFriendDeath
	{
	}
	internal static class AddFriend
	{
	}
	internal static class RemoveFriend_RoR2_CharacterMaster
	{
	}
	internal static class RemoveFriend_RoR2_CharacterMaster_System_Boolean
	{
	}
	internal static class FriendRewards
	{
	}
	internal static class HauntedAffixFix
	{
	}
	internal static class BeadAffixFix
	{
	}
	internal static class OnDisable
	{
	}
	internal static class ShowHealthbarFromFriend
	{
	}
	internal static class FriendIsValid
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class Friend
	{
		internal static class _ctor
		{
		}

		internal static class _ctor_RoR2_CharacterMaster
		{
		}
	}
	internal static class __c
	{
		internal static class _ctor
		{
		}
	}
}
namespace MonoDetourHooks.SS2.Components.KnightPassiveController
{
	internal static class Start
	{
		public delegate void PrefixSignature(KnightPassiveController self);

		public delegate ReturnFlow ControlFlowPrefixSignature(KnightPassiveController self);

		public delegate void PostfixSignature(KnightPassiveController 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(KnightPassiveController).GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Components.KnightPassiveController", "Start");
		}
	}
	internal static class _ctor
	{
	}
	internal static class UNetVersion
	{
	}
	internal static class OnSerialize
	{
	}
	internal static class OnDeserialize
	{
	}
	internal static class PreStartClient
	{
	}
}
namespace MonoDetourHooks.SS2.Components.ChirrFriendTracker
{
	internal static class Start
	{
		public delegate void PrefixSignature(ChirrFriendTracker self);

		public delegate ReturnFlow ControlFlowPrefixSignature(ChirrFriendTracker self);

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

		public delegate ReturnFlow ControlFlowPrefixSignature(ChirrFriendTracker self);

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

		public delegate ReturnFlow ControlFlowPrefixSignature(ChirrFriendTracker self);

		public delegate void PostfixSignature(ChirrFriendTracker 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(ChirrFriendTracker).GetMethod("FixedUpdate", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.Components.ChirrFriendTracker", "FixedUpdate");
		}
	}
	internal static class CheckBody
	{
		public delegate void PrefixSignature(ChirrFriendTracker self, ref CharacterBody body);

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

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

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (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(ChirrFriendTracker).GetMethod("CheckBody", (BindingFlags)(-1), null, new Type[1] { typeof(CharacterBody) }, null) ?? throw new MissingMethodException("SS2.Components.ChirrFriendTracker", "CheckBody");
		}
	}
	internal static class get_isScepter
	{
	}
	internal static class set_isScepter
	{
	}
	internal static class Awake
	{
	}
	internal static class UpdateScepter
	{
	}
	internal static class ShouldShowTracker
	{
	}
	internal static class ShouldSearchForFriend
	{
	}
	internal static class GetTrackingTarget
	{
	}
	internal static class OnDisable
	{
	}
	internal static class SearchForTarget
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
}
namespace MonoDetourHooks.SS2.Components.Empyrean
{
	internal static class MakeElite
	{
		public delegate void PrefixSignature(Empyrean self, ref CharacterBody body);

		public delegate void PostfixSignature(Empyrean self, ref CharacterBody body);

		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(Empyrean).GetMethod("MakeElite", (BindingFlags)(-1), null, new Type[1] { typeof(CharacterBody) }, null) ?? throw new MissingMethodException("SS2.Components.Empyrean", "MakeElite");
		}
	}
	internal static class get_EliteCreditCost
	{
	}
	internal static class get_CostMultiplier
	{
	}
	internal static class get_IsBoss
	{
	}
	internal static class IsAvailable
	{
	}
	internal static class CanAfford
	{
	}
	internal static class SubtractCost
	{
	}
	internal static class SetSpawnState
	{
	}
	internal static class MakeEmpyreanOLDstupidFUCK
	{
	}
	internal static class _ctor
	{
	}
}
namespace MonoDetourHooks.SS2.ExtraEquipmentManager
{
	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(ExtraEquipmentManager).GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.ExtraEquipmentManager", "Init");
		}
	}
	internal static class ExtraEquipmentDisplays
	{
		internal static class OnEnable
		{
			public delegate void PrefixSignature(ExtraEquipmentDisplays self);

			public delegate void PostfixSignature(ExtraEquipmentDisplays 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(ExtraEquipmentDisplays).GetMethod("OnEnable", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.ExtraEquipmentManager+ExtraEquipmentDisplays", "OnEnable");
			}
		}

		internal static class EnableEquipmentDisplay
		{
			public delegate void PrefixSignature(ExtraEquipmentDisplays self, ref EquipmentIndex index);

			public delegate void PostfixSignature(ExtraEquipmentDisplays self, ref EquipmentIndex index);

			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(ExtraEquipmentDisplays).GetMethod("EnableEquipmentDisplay", (BindingFlags)(-1), null, new Type[1] { typeof(EquipmentIndex) }, null) ?? throw new MissingMethodException("SS2.ExtraEquipmentManager+ExtraEquipmentDisplays", "EnableEquipmentDisplay");
			}
		}

		internal static class InstantiateDisplayRuleGroup
		{
			public delegate void PrefixSignature(ExtraEquipmentDisplays self, ref DisplayRuleGroup displayRuleGroup, ref EquipmentIndex equipmentIndex);

			public delegate void PostfixSignature(ExtraEquipmentDisplays self, ref DisplayRuleGroup displayRuleGroup, ref EquipmentIndex equipmentIndex);

			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(ExtraEquipmentDisplays).GetMethod("InstantiateDisplayRuleGroup", (BindingFlags)(-1), null, new Type[2]
				{
					typeof(DisplayRuleGroup),
					typeof(EquipmentIndex)
				}, null) ?? throw new MissingMethodException("SS2.ExtraEquipmentManager+ExtraEquipmentDisplays", "InstantiateDisplayRuleGroup");
			}
		}

		internal static class Awake
		{
		}

		internal static class OnDisable
		{
		}

		internal static class OnInventoryChanged
		{
		}

		internal static class DisableEquipmentDisplay
		{
		}

		internal static class HasEquipment
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class CharacterBody_OnInventoryChanged
	{
	}
	internal static class CharacterModel_UpdateOverlays
	{
	}
	internal static class CharacterModel_Awake
	{
	}
	internal static class _ctor
	{
	}
	internal static class __c
	{
		internal static class _ctor
		{
		}
	}
}
namespace MonoDetourHooks.SS2.EliteEventMissionController
{
	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(EliteEventMissionController).GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.EliteEventMissionController", "Init");
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(EliteEventMissionController self);

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

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

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

		public delegate void PostfixSignature(EliteEventMissionController 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(EliteEventMissionController).GetMethod("SpawnBoss", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.EliteEventMissionController", "SpawnBoss");
		}
	}
	internal static class get_bossCredit
	{
	}
	internal static class Awake
	{
	}
	internal static class OnDisable
	{
	}
	internal static class StartEvent
	{
	}
	internal static class StopEvent
	{
	}
	internal static class OnBossSpawned
	{
	}
	internal static class OnBossDefeatedServer
	{
	}
	internal static class OnCharacterDeathGlobal
	{
	}
	internal static class OnTeleporterBeginChargingGlobal
	{
	}
	internal static class OnSpawnedServer
	{
	}
	internal static class EliteObjective
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class UNetVersion
	{
	}
	internal static class get_NetworkrequiredEliteKills
	{
	}
	internal static class set_NetworkrequiredEliteKills
	{
	}
	internal static class get_NetworkcurrentEliteKills
	{
	}
	internal static class set_NetworkcurrentEliteKills
	{
	}
	internal static class get_NetworkhasStarted
	{
	}
	internal static class set_NetworkhasStarted
	{
	}
	internal static class OnSerialize
	{
	}
	internal static class OnDeserialize
	{
	}
	internal static class PreStartClient
	{
	}
	internal static class OnBossKilledServer
	{
		internal static class OnKilledServer
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class EliteObjectiveTracker
	{
		internal static class GenerateString
		{
		}

		internal static class get_shouldConsiderComplete
		{
		}

		internal static class IsComplete
		{
		}

		internal static class IsDirty
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class OnDestroyCallback
	{
		internal static class OnDestroy
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass38_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c
	{
		internal static class _ctor
		{
		}
	}
}
namespace MonoDetourHooks.SS2.TeleporterUpgradeController
{
	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(TeleporterUpgradeController).GetMethod("Init", (BindingFlags)(-1), null, Array.Empty<Type>(), null) ?? throw new MissingMethodException("SS2.TeleporterUpgradeController", "Init");
		}
	}
	internal static class OnTeleporterChargedGlobal
	{
		public delegate void PrefixSignature(TeleporterUpgradeController self, ref TeleporterInteraction teleporter);

		public delegate void PostfixSignature(TeleporterUpgradeController self, ref TeleporterInteraction teleporter);

		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(TeleporterUpgradeController).GetMethod("OnTeleporterChargedGlobal", (BindingFlags)(-1), null, new Type[1] { typeof(TeleporterInteraction) }, null) ?? throw new MissingMethodException("SS2.TeleporterUpgradeController", "OnTeleporterChargedGlobal");
		}
	}
	internal static class OnEnable
	{
		public delegate void PrefixSignature(TeleporterUpgradeController self);

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

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

		public delegate void PostfixSignature(TeleporterUpgradeController self, ref bool upgrade);

		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(TeleporterUpgradeController).GetMethod("UpgradeStorm", (BindingFlags)(-1), null, new Type[1] { typeof(bool) }, null) ?? throw new MissingMethodException("SS2.TeleporterUpgradeController", "UpgradeStorm");
		}
	}
	internal static class Awake
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class OnDisable
	{
	}
	internal static class OnTeleporterBeginChargingGlobal
	{
	}
	internal static class ModifySpawnedBoss
	{
	}
	internal static class RpcUpgradeStorm
	{
	}
	internal static class UpgradeEthereal
	{
	}
	internal static class RpcUpgradeEthereal
	{
	}
	internal static class EtherealUpgradeInternal
	{
	}
	internal static class _ctor
	{
	}
	internal static class _cctor
	{
	}
	internal static class UNetVersion
	{
	}
	internal static class get_NetworkisEthereal
	{
	}
	internal static class set_NetworkisEthereal
	{
	}
	internal static class get_NetworkisStorm
	{
	}
	internal static class set_NetworkisStorm
	{
	}
	internal static class InvokeRpcRpcUpgradeStorm
	{
	}
	internal static class InvokeRpcRpcUpgradeEthereal
	{
	}
	internal static class CallRpcUpgradeStorm
	{
	}
	internal static class CallRpcUpgradeEthereal
	{
	}
	internal static class OnSerialize
	{
	}
	internal static class OnDeserialize
	{
	}
	internal static class PreStartClient
	{
	}
}
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 bool DistinguishOverloadsByName { 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 LordsStarstormEdits
{
	public static class ConfigOptions
	{
		public static ConfigEntry<bool> ChirrMinionsNoHealingItems;

		public static ConfigEntry<bool> ChirrNoTamingTerminals;

		public static ConfigEntry<bool> ChirrTameLingerFix;

		public static ConfigEntry<bool> AddKnightPassive;

		public static ConfigEntry<bool> NewStormEventText;

		public static ConfigEntry<bool> NewSuperEliteSpawnEventText;

		public static ConfigEntry<bool> RemoveEmpyreanShardDrop;

		public static ConfigEntry<bool> ImplementZanzanPortalAppearText;

		public static ConfigEntry<bool> TweakUltraWardBuff;

		internal static void BindConfigOptions(ConfigFile config)
		{
			ChirrMinionsNoHealingItems = Extensions.BindOption<bool>(config, "Chirr", "Make tamed enemies not get Chirrs healing items.", "This is so her gameplay of keeping her tamed enemy healthy isn't removed once a few good healing items are required.", true, (ConfigFlags)1);
			ChirrNoTamingTerminals = Extensions.BindOption<bool>(config, "Chirr", "Make enemies from Relic of Termination untamable", "Termination eneimes are insanely strong when tamed by Chirr, this makes them untamable so they're not an almost free win", true, (ConfigFlags)1);
			ChirrTameLingerFix = Extensions.BindOption<bool>(config, "Chirr", "Fix enemies being tamable after debuff expiration", "Enemies can be tamed even after the taming debuff expires, this fixes that.", true, (ConfigFlags)1);
			AddKnightPassive = Extensions.BindOption<bool>(config, "Knight", "Add his unused passive", "Knight has a (currently) unused passive buff ward for allies that gives some attack speed and movement speed. This implements that.", true, (ConfigFlags)1);
			NewStormEventText = Extensions.BindOption<bool>(config, "Storms", "New storm text", "Replaces the silly placeholder storm event text with new text.", true, (ConfigFlags)1);
			NewSuperEliteSpawnEventText = Extensions.BindOption<bool>(config, "Elite Events", "New super elite spawn text", "Replaces the silly placeholder super elite spawn event text with new text.", true, (ConfigFlags)1);
			RemoveEmpyreanShardDrop = Extensions.BindOption<bool>(config, "Empyreans", "Remove shard drop", "Prevents empyrean elites from dropping a random shard on death.", true, (ConfigFlags)1);
			ImplementZanzanPortalAppearText = Extensions.BindOption<bool>(config, "Ethereal Related", "Implement unused Zanzan portal appearance text", "There's already added non-placeholder text for when Zanzan's portal appears, this will implement it.", true, (ConfigFlags)1);
			TweakUltraWardBuff = Extensions.BindOption<bool>(config, "Ethereal Related", "Tweak the passive buff from ultra elites", "Makes the passive buff ultra elites give off also apply to the ultra elite itself, along with the passive buff giving a tiny amount of % hp regen to everyone but ultra elites. This basically makes it like more of a super duper mending elite.", true, (ConfigFlags)1);
			Extensions.WipeConfig(config);
		}
	}
	internal static class Log
	{
		private static ManualLogSource _logSource;

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

		internal static void Debug(object data)
		{
		}

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

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

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

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

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	internal static class Main
	{
	}
	internal static class MyAssets
	{
		internal static class ShardIcons
		{
			public static AssetBundle AssetBundle;

			public const string BundleName = "lse_shard_icons";

			public static string AssetBundlePath => Path.Combine(Path.GetDirectoryName(Plugin.PluginInfo.Location), "lse_shard_icons");

			internal static void Init()
			{
				AssetBundle = AssetBundle.LoadFromFile(AssetBundlePath);
			}
		}

		internal static class SurvivorIcons
		{
			public static AssetBundle AssetBundle;

			public const string BundleName = "lse_survivor_icons";

			public static string AssetBundlePath => Path.Combine(Path.GetDirectoryName(Plugin.PluginInfo.Location), "lse_survivor_icons");

			internal static void Init()
			{
				AssetBundle = AssetBundle.LoadFromFile(AssetBundlePath);
			}
		}

		internal static void Init()
		{
			ShardIcons.Init();
			SurvivorIcons.Init();
		}
	}
	[BepInPlugin("LordVGames.LordsStarstormEdits", "LordsStarstormEdits", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGUID = "LordVGames.LordsStarstormEdits";

		public const string PluginAuthor = "LordVGames";

		public const string PluginName = "LordsStarstormEdits";

		public const string PluginVersion = "1.0.1";

		public static PluginInfo PluginInfo { get; private set; }

		public void Awake()
		{
			PluginInfo = ((BaseUnityPlugin)this).Info;
			Log.Init(((BaseUnityPlugin)this).Logger);
			ConfigOptions.BindConfigOptions(((BaseUnityPlugin)this).Config);
			MyAssets.Init();
			MonoDetourManager.InvokeHookInitializers(typeof(Plugin).Assembly);
			((ResourceAvailability)(ref ItemCatalog.availability)).CallWhenAvailable((Action)RemoveBrokenItemAchievements.YouShallWorkAgain);
		}
	}
}
namespace LordsStarstormEdits.SS2Edits.Survivors
{
	internal static class SurvivorIcons
	{
		[SystemInitializer(new Type[] { typeof(SurvivorCatalog) })]
		internal static void ChangeSurvivorIcons()
		{
			if (((ConfiguredVariable<bool>)(object)SS2Config.enableBeta).value)
			{
				Survivors.survivorKnight.bodyPrefab.GetComponent<CharacterBody>().portraitIcon = MyAssets.SurvivorIcons.AssetBundle.LoadAsset<Texture>("texIconKnight");
				SurvivorCatalog.FindSurvivorDef("survivorCyborg2").bodyPrefab.GetComponent<CharacterBody>().portraitIcon = MyAssets.SurvivorIcons.AssetBundle.LoadAsset<Texture>("texIconCyborg");
			}
		}
	}
}
namespace LordsStarstormEdits.SS2Edits.Survivors.Knight
{
	[MonoDetourTargets(typeof(KnightPassiveController), GenerateControlFlowVariants = true)]
	internal static class FixKnightPassive
	{
		[MonoDetourHookInitialize]
		internal static void Setup()
		{
			if (ConfigOptions.AddKnightPassive.Value && ((ConfiguredVariable<bool>)(object)SS2Config.enableBeta).value)
			{
				MonoDetourHooks.SS2.Components.KnightPassiveController.Start.ControlFlowPrefix(AddTheCoolPassive);
			}
		}

		private static ReturnFlow AddTheCoolPassive(KnightPassiveController self)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			self.PassiveWardPrefab = SS2Assets.LoadAsset<GameObject>("KnightPassiveBuffWard", (SS2Bundle)15);
			self.characterBody = ((Component)((Component)self).transform).GetComponent<CharacterBody>();
			if (NetworkServer.active)
			{
				GameObject obj = Object.Instantiate<GameObject>(self.PassiveWardPrefab, self.characterBody.footPosition, Quaternion.identity);
				obj.GetComponent<TeamFilter>().teamIndex = self.characterBody.teamComponent.teamIndex;
				obj.GetComponent<NetworkedBodyAttachment>().AttachToGameObjectAndSpawn(((Component)self.characterBody).gameObject, (string)null);
			}
			return (ReturnFlow)1;
		}

		[SystemInitializer(new Type[] { typeof(SurvivorCatalog) })]
		internal static void AddKnightPassiveToBody()
		{
			if (ConfigOptions.AddKnightPassive.Value && ((ConfiguredVariable<bool>)(object)SS2Config.enableBeta).value)
			{
				Survivors.survivorKnight.bodyPrefab.AddComponent<KnightPassiveController>();
				SkillLocator component = Survivors.survivorKnight.bodyPrefab.GetComponent<SkillLocator>();
				component.passiveSkill.enabled = true;
				component.passiveSkill.skillNameToken = "SS2_KNIGHT_PASSIVE_NAME";
				component.passiveSkill.skillDescriptionToken = "SS2_KNIGHT_PASSIVE_DESC";
				component.passiveSkill.icon = SS2Assets.FindAsset<Sprite>("texIconKnightPassiveAura");
			}
		}

		[SystemInitializer(new Type[] { typeof(BuffCatalog) })]
		internal static void RecolorKnightPassiveBuff()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigOptions.AddKnightPassive.Value && ((ConfiguredVariable<bool>)(object)SS2Config.enableBeta).value)
			{
				Buffs.bdKnightBuff.buffColor = Survivors.survivorKnight.primaryColor;
			}
		}
	}
}
namespace LordsStarstormEdits.SS2Edits.Survivors.Chirr
{
	[MonoDetourTargets(typeof(ChirrFriendController))]
	internal static class ChirrMinionNoHealingItems
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__FilterHealingItems;
		}

		[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.ChirrMinionsNoHealingItems.Value)
			{
				object obj = <>O.<0>__FilterHealingItems;
				if (obj == null)
				{
					Manipulator val = FilterHealingItems;
					<>O.<0>__FilterHealingItems = val;
					obj = (object)val;
				}
				ItemFilter.ILHook((Manipulator)obj);
			}
		}

		private static void FilterHealingItems(ILManipulationInfo info)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			ILWeaver w = new ILWeaver(info);
			ILLabel endIfFalse = w.DefineLabel();
			w.MatchRelaxed(new Predicate<Instruction>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 0) && w.SetCurrentTo(x),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 20),
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt<ItemDef>(x, "DoesNotContainTag"),
				(Instruction x) => ILPatternMatchingExt.MatchBrfalse(x, ref endIfFalse)
			}).ThrowIfFailure();
			w.InsertBeforeCurrent((IEnumerable<Instruction>)new <>z__ReadOnlyArray<Instruction>((Instruction[])(object)new Instruction[4]
			{
				w.Create(OpCodes.Ldloc_0),
				w.Create(OpCodes.Ldc_I4_2),
				w.Create(OpCodes.Callvirt, (MethodBase)typeof(ItemDef).GetMethod("DoesNotContainTag")),
				w.Create(OpCodes.Brfalse, (object)endIfFalse)
			}));
		}
	}
	[MonoDetourTargets(typeof(ChirrFriendTracker), GenerateControlFlowVariants = true)]
	internal static class ChirrNoTamingTerminals
	{
		[MonoDetourHookInitialize]
		internal static void Setup()
		{
			if (ConfigOptions.ChirrNoTamingTerminals.Value)
			{
				CheckBody.ControlFlowPrefix(DontLetTerminalsBeTamed);
			}
		}

		private static ReturnFlow DontLetTerminalsBeTamed(ChirrFriendTracker self, ref CharacterBody body, ref bool returnValue)
		{
			if ((Object)(object)body == (Object)null || (Object)(object)body.inventory == (Object)null)
			{
				returnValue = false;
				return (ReturnFlow)1;
			}
			bool flag = body.inventory.GetItemCount(Items.TerminationHelper) > 0;
			returnValue = !body.isBoss && !flag;
			return (ReturnFlow)1;
		}
	}
	[MonoDetourTargets(typeof(ConvertBehavior))]
	internal static class ChirrTameLingerFixAgain
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__DoChirrTameLingerBandaidFix;
		}

		[MonoDetourHookInitialize]
		internal static void Setup()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__DoChirrTameLingerBandaidFix;
			if (obj == null)
			{
				Manipulator val = DoChirrTameLingerBandaidFix;
				<>O.<0>__DoChirrTameLingerBandaidFix = val;
				obj = (object)val;
			}
			ConvertBehavior.OnTakeDamageServer.ILHook((Manipulator)obj);
		}

		private static void DoChirrTameLingerBandaidFix(ILManipulationInfo info)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			ILWeaver w = new ILWeaver(info);
			ILLabel returnLabel = w.DefineLabel();
			w.MatchRelaxed(new Predicate<Instruction>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<DamageReport>(x, "victimBody"),
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt<CharacterBody>(x, "get_isPlayerControlled"),
				(Instruction x) => ILPatternMatchingExt.MatchBrtrue(x, ref returnLabel) && w.SetCurrentTo(x)
			}).ThrowIfFailure();
			w.InsertAfterCurrent((IEnumerable<Instruction>)new <>z__ReadOnlySingleElementList<Instruction>(w.Create(OpCodes.Ldarg_1)));
			w.InsertAfterCurrent(w.CreateDelegateCall<Func<DamageReport, bool>>((Func<DamageReport, bool>)((DamageReport damageReport) => (Object)(object)damageReport.victimBody != (Object)null && damageReport.victimBody.HasBuff(Buffs.BuffChirrConvert))));
			w.InsertAfterCurrent((IEnumerable<Instruction>)new <>z__ReadOnlySingleElementList<Instruction>(w.Create(OpCodes.Brfalse, (object)returnLabel)));
		}
	}
}
namespace LordsStarstormEdits.SS2Edits.Items
{
	internal static class RemoveBrokenItemAchievements
	{
		internal static void YouShallWorkAgain()
		{
			if ((Object)(object)Items.X4.unlockableDef != (Object)null)
			{
				Items.X4.unlockableDef = null;
				Items.Insecticide.unlockableDef = null;
			}
		}
	}
	internal static class ShardIcons
	{
		[SystemInitializer(new Type[] { typeof(ItemCatalog) })]
		internal static void ChangeIcons()
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			if (((ConfiguredVariable<bool>)(object)SS2Config.enableBeta).value)
			{
				Sprite val = MyAssets.ShardIcons.AssetBundle.LoadAsset<Sprite>("texIconShardScav");
				Sprite val2 = MyAssets.ShardIcons.AssetBundle.LoadAsset<Sprite>("texIconShardGold");
				Sprite val3 = MyAssets.ShardIcons.AssetBundle.LoadAsset<Sprite>("texIconShardVoid");
				Sprite val4 = MyAssets.ShardIcons.AssetBundle.LoadAsset<Sprite>("texIconShardIce");
				Sprite val5 = MyAssets.ShardIcons.AssetBundle.LoadAsset<Sprite>("texIconShardFire");
				Sprite val6 = MyAssets.ShardIcons.AssetBundle.LoadAsset<Sprite>("texIconShardStorm");
				Sprite val7 = MyAssets.ShardIcons.AssetBundle.LoadAsset<Sprite>("texIconShardEarth");
				Sprite val8 = MyAssets.ShardIcons.AssetBundle.LoadAsset<Sprite>("texIconShardLightning");
				Items.ShardScav.pickupIconSprite = val;
				PickupIndex val9 = PickupCatalog.FindPickupIndex(Items.ShardScav.itemIndex);
				((PickupIndex)(ref val9)).pickupDef.iconSprite = val;
				Items.ShardGold.pickupIconSprite = val2;
				val9 = PickupCatalog.FindPickupIndex(Items.ShardGold.itemIndex);
				((PickupIndex)(ref val9)).pickupDef.iconSprite = val2;
				Items.ShardVoid.pickupIconSprite = val3;
				val9 = PickupCatalog.FindPickupIndex(Items.ShardVoid.itemIndex);
				((PickupIndex)(ref val9)).pickupDef.iconSprite = val3;
				Items.ShardFire.pickupIconSprite = val5;
				val9 = PickupCatalog.FindPickupIndex(Items.ShardFire.itemIndex);
				((PickupIndex)(ref val9)).pickupDef.iconSprite = val5;
				Items.ShardEarth.pickupIconSprite = val7;
				val9 = PickupCatalog.FindPickupIndex(Items.ShardEarth.itemIndex);
				((PickupIndex)(ref val9)).pickupDef.iconSprite = val7;
				Items.ShardLightning.pickupIconSprite = val8;
				val9 = PickupCatalog.FindPickupIndex(Items.ShardLightning.itemIndex);
				((PickupIndex)(ref val9)).pickupDef.iconSprite = val8;
				Items.ShardIce.pickupIconSprite = val4;
				val9 = PickupCatalog.FindPickupIndex(Items.ShardIce.itemIndex);
				((PickupIndex)(ref val9)).pickupDef.iconSprite = val4;
				if ((Object)(object)Items.ShardStorm != (Object)null)
				{
					Items.ShardStorm.pickupIconSprite = val6;
					val9 = PickupCatalog.FindPickupIndex(Items.ShardStorm.itemIndex);
					((PickupIndex)(ref val9)).pickupDef.iconSprite = val6;
				}
			}
		}
	}
}
namespace LordsStarstormEdits.SS2Edits.Events
{
	internal static class AddSuperEliteSubtitles
	{
		[MonoDetourTargets(typeof(Behavior))]
		private static class SuperFireSubtitle
		{
			[MonoDetourHookInitialize]
			internal static void Setup()
			{
				if (((ConfiguredVariable<bool>)(object)SS2Config.enableBeta).value)
				{
					MonoDetourHooks.SS2.Equipments.AffixSuperFire.Behavior.OnEnable.Postfix(AddSubtitle);
				}
			}

			private static void AddSubtitle(Behavior self)
			{
				((BaseBuffBehaviour)self).characterBody.subtitleNameToken = "SS2_EQUIP_AFFIXSUPERFIRE_SUBTITLE";
			}
		}

		[MonoDetourTargets(typeof(Behavior))]
		private static class SuperIceSubtitle
		{
			[MonoDetourHookInitialize]
			internal static void Setup()
			{
				if (((ConfiguredVariable<bool>)(object)SS2Config.enableBeta).value)
				{
					MonoDetourHooks.SS2.Equipments.AffixSuperIce.Behavior.OnEnable.Postfix(AddSubtitle);
				}
			}

			private static void AddSubtitle(Behavior self)
			{
				((BaseBuffBehaviour)self).characterBody.subtitleNameToken = "SS2_EQUIP_AFFIXSUPERICE_SUBTITLE";
			}
		}

		[MonoDetourTargets(typeof(Behavior))]
		private static class SuperLightningSubtitle
		{
			[MonoDetourHookInitialize]
			internal static void Setup()
			{
				if (((ConfiguredVariable<bool>)(object)SS2Config.enableBeta).value)
				{
					MonoDetourHooks.SS2.Equipments.AffixSuperLightning.Behavior.OnEnable.Postfix(AddSubtitle);
				}
			}

			private static void AddSubtitle(Behavior self)
			{
				((BaseBuffBehaviour)self).characterBody.subtitleNameToken = "SS2_EQUIP_AFFIXSUPERLIGHTNING_SUBTITLE";
			}
		}

		[MonoDetourTargets(typeof(Behavior))]
		private static class SuperEarthSubtitle
		{
			[MonoDetourHookInitialize]
			internal static void Setup()
			{
				if (((ConfiguredVariable<bool>)(object)SS2Config.enableBeta).value)
				{
					MonoDetourHooks.SS2.Equipments.AffixSuperEarth.Behavior.OnEnable.Postfix(AddSubtitle);
				}
			}

			private static void AddSubtitle(Behavior self)
			{
				((BaseBuffBehaviour)self).characterBody.subtitleNameToken = "SS2_EQUIP_AFFIXSUPEREARTH_SUBTITLE";
			}
		}
	}
	[MonoDetourTargets(typeof(Storm))]
	internal static class FixStormTPEffectsNotGoingAway
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__RemoveStormEffects;
		}

		[MonoDetourHookInitialize]
		internal static void Setup()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__RemoveStormEffects;
			if (obj == null)
			{
				Manipulator val = RemoveStormEffects;
				<>O.<0>__RemoveStormEffects = val;
				obj = (object)val;
			}
			MonoDetourHooks.EntityStates.Events.Storm.FixedUpdate.ILHook((Manipulator)obj);
		}

		private static void RemoveStormEffects(ILManipulationInfo info)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			ILWeaver w = new ILWeaver(info);
			w.DefineLabel();
			MethodReference val = default(MethodReference);
			w.MatchRelaxed(new Predicate<Instruction>[4]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<EntityState>(x, "outer"),
				(Instruction x) => ILPatternMatchingExt.MatchNewobj(x, ref val),
				(Instruction x) => ILPatternMatchingExt.MatchCallvirt<EntityStateMachine>(x, "SetNextState") && w.SetCurrentTo(x)
			}).ThrowIfFailure();
			w.InsertAfterCurrent((IEnumerable<Instruction>)new <>