using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AlwaysPlayFinalDay.Patches;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using MonoMod.RuntimeDetour.HookGen;
using MyceliumNetworking;
using On;
using UnityEngine;
using Zorro.Settings;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("alexandria-p.AlwaysPlayFinalDay")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+8a187f421d45a669232b3d213421fcaaeb159cd0")]
[assembly: AssemblyProduct("AlwaysPlayFinalDay")]
[assembly: AssemblyTitle("alexandria-p.AlwaysPlayFinalDay")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.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 AlwaysPlayFinalDay
{
	[ContentWarningPlugin("alexandria-p.AlwaysPlayFinalDay", "1.0.1", false)]
	[BepInPlugin("alexandria-p.AlwaysPlayFinalDay", "AlwaysPlayFinalDay", "1.0.1")]
	public class FixR2Modman : BaseUnityPlugin
	{
		internal static ManualLogSource Logger { get; private set; }

		private void Awake()
		{
			//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_001e: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			GameObject val = new GameObject("AlwaysPlayFinalDayPluginR2ModMan")
			{
				hideFlags = (HideFlags)61
			};
			val.AddComponent<AlwaysPlayFinalDay>();
			AlwaysPlayFinalDay.Instance.SetLogger(((BaseUnityPlugin)this).Logger);
			Object.DontDestroyOnLoad((Object)(object)val);
		}
	}
	public class AlwaysPlayFinalDay : MonoBehaviour
	{
		[ContentWarningSetting]
		public class EnableAllowCrewToWatchFootageEvenIfQuotaNotMetSetting : BoolSetting, IExposedSetting
		{
			public SettingCategory GetSettingCategory()
			{
				return (SettingCategory)4;
			}

			public override void ApplyValue()
			{
				Instance.SetPlayFinalDayEvenIfQuotaNotMet(((BoolSetting)this).Value);
			}

			public string GetDisplayName()
			{
				return "AlwaysPlayFinalDay: Allow crew to view their camera footage on final day, even if the footage won't reach quota (uses the host's game settings) \nWithout this setting, the third day ends immediately.";
			}

			protected override bool GetDefaultValue()
			{
				return true;
			}
		}

		private const uint myceliumNetworkModId = 61813u;

		public bool Debug_InitSurfaceActive;

		public static AlwaysPlayFinalDay Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		public bool PlayFinalDayEvenIfQuotaNotMet { get; private set; }

		public void SetLogger(ManualLogSource logger)
		{
			Logger = logger;
			Logger.LogInfo((object)"AlwaysPlayFinalDay v1.0.1 has loaded!");
		}

		private void Awake()
		{
			Instance = this;
			HookAll();
		}

		private void Start()
		{
			MyceliumNetwork.RegisterNetworkObject((object)Instance, 61813u, 0);
		}

		private void OnDestroy()
		{
			MyceliumNetwork.DeregisterNetworkObject((object)Instance, 61813u, 0);
		}

		internal static void HookAll()
		{
			SurfaceNetworkHandlerPatch.Init();
			PhotonGameLobbyHandlerPatch.Init();
		}

		internal static void UnhookAll()
		{
			HookEndpointManager.RemoveAllOwnedBy((object)Assembly.GetExecutingAssembly());
		}

		public bool IsFinalDayAndQuotaNotMet()
		{
			if (SurfaceNetworkHandler.RoomStats != null && SurfaceNetworkHandler.RoomStats.IsQuotaDay)
			{
				return !SurfaceNetworkHandler.RoomStats.CalculateIfReachedQuota();
			}
			return false;
		}

		public void SetPlayFinalDayEvenIfQuotaNotMet(bool playFinalDayEvenIfQuotaNotMet)
		{
			PlayFinalDayEvenIfQuotaNotMet = playFinalDayEvenIfQuotaNotMet;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "alexandria-p.AlwaysPlayFinalDay";

		public const string PLUGIN_NAME = "AlwaysPlayFinalDay";

		public const string PLUGIN_VERSION = "1.0.1";
	}
}
namespace AlwaysPlayFinalDay.Patches
{
	public class PhotonGameLobbyHandlerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_SetCurrentObjective <0>__PhotonGameLobbyHandler_SetCurrentObjective;
		}

		internal static void Init()
		{
			//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>__PhotonGameLobbyHandler_SetCurrentObjective;
			if (obj == null)
			{
				hook_SetCurrentObjective val = PhotonGameLobbyHandler_SetCurrentObjective;
				<>O.<0>__PhotonGameLobbyHandler_SetCurrentObjective = val;
				obj = (object)val;
			}
			PhotonGameLobbyHandler.SetCurrentObjective += (hook_SetCurrentObjective)obj;
		}

		private static void PhotonGameLobbyHandler_SetCurrentObjective(orig_SetCurrentObjective orig, PhotonGameLobbyHandler self, Objective objective)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (MyceliumNetwork.IsHost && AlwaysPlayFinalDay.Instance.PlayFinalDayEvenIfQuotaNotMet && AlwaysPlayFinalDay.Instance.IsFinalDayAndQuotaNotMet())
			{
				if (AlwaysPlayFinalDay.Instance.Debug_InitSurfaceActive)
				{
					objective = (Objective)new ExtractVideoObjective();
				}
				if (objective is GoToBedSuccessObjective)
				{
					objective = (Objective)new GoToBedFailedObjective();
				}
			}
			orig.Invoke(self, objective);
		}
	}
	public class SurfaceNetworkHandlerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_InitSurface <0>__SurfaceNetworkHandler_InitSurface;

			public static hook_NextDay <1>__SurfaceNetworkHandler_NextDay;
		}

		internal static void Init()
		{
			//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
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			object obj = <>O.<0>__SurfaceNetworkHandler_InitSurface;
			if (obj == null)
			{
				hook_InitSurface val = SurfaceNetworkHandler_InitSurface;
				<>O.<0>__SurfaceNetworkHandler_InitSurface = val;
				obj = (object)val;
			}
			SurfaceNetworkHandler.InitSurface += (hook_InitSurface)obj;
			object obj2 = <>O.<1>__SurfaceNetworkHandler_NextDay;
			if (obj2 == null)
			{
				hook_NextDay val2 = SurfaceNetworkHandler_NextDay;
				<>O.<1>__SurfaceNetworkHandler_NextDay = val2;
				obj2 = (object)val2;
			}
			SurfaceNetworkHandler.NextDay += (hook_NextDay)obj2;
		}

		private static void SurfaceNetworkHandler_InitSurface(orig_InitSurface orig, SurfaceNetworkHandler self)
		{
			AlwaysPlayFinalDay.Instance.Debug_InitSurfaceActive = true;
			orig.Invoke(self);
			if (MyceliumNetwork.IsHost && AlwaysPlayFinalDay.Instance.PlayFinalDayEvenIfQuotaNotMet && AlwaysPlayFinalDay.Instance.IsFinalDayAndQuotaNotMet())
			{
				AlwaysPlayFinalDay.Logger.LogInfo((object)"AlwaysPlayFinalDay: spawn players, even on final day.");
				if (!Player.justDied)
				{
					SpawnHandler.Instance.SpawnLocalPlayer((Spawns)3);
				}
			}
			AlwaysPlayFinalDay.Instance.Debug_InitSurfaceActive = false;
		}

		private static void SurfaceNetworkHandler_NextDay(orig_NextDay orig, SurfaceNetworkHandler self)
		{
			if (MyceliumNetwork.IsHost && AlwaysPlayFinalDay.Instance.PlayFinalDayEvenIfQuotaNotMet && AlwaysPlayFinalDay.Instance.IsFinalDayAndQuotaNotMet() && AlwaysPlayFinalDay.Instance.Debug_InitSurfaceActive)
			{
				AlwaysPlayFinalDay.Logger.LogInfo((object)"AlwaysPlayFinalDay: Cancelled gameover, to allow players to watch their video on the final day when they didn't meet quota");
			}
			else
			{
				orig.Invoke(self);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Threading.Tasks;
using CurvedUI;
using DefaultNamespace;
using DefaultNamespace.Artifacts;
using DefaultNamespace.ContentEvents;
using DefaultNamespace.ContentProviders;
using DefaultNamespace.Petter.TitleCard;
using DefaultNamespace._10._SCRIPTS;
using ExitGames.Client.Photon;
using LimitlessDev.RetroLookPro;
using MonoMod.Cil;
using MonoMod.RuntimeDetour.HookGen;
using On;
using On.CurvedUI;
using On.DefaultNamespace;
using On.DefaultNamespace.Artifacts;
using On.DefaultNamespace.ContentEvents;
using On.DefaultNamespace.ContentProviders;
using On.DefaultNamespace.Petter.TitleCard;
using On.DefaultNamespace._10._SCRIPTS;
using On.LimitlessDev.RetroLookPro;
using On.Photon.Chat.Demo;
using On.Photon.Chat.UtilityScripts;
using On.Photon.Realtime.Demo;
using On.UnityEditor.Localization.Samples;
using On.UnityEngine.Localization.Samples;
using On.UnityEngine.Localization.Settings;
using On.UnityEngine.UI.ProceduralImage;
using On._02Scripts.Charts.Computes;
using Photon.Chat;
using Photon.Chat.Demo;
using Photon.Chat.UtilityScripts;
using Photon.Pun;
using Photon.Realtime;
using Photon.Realtime.Demo;
using Steamworks;
using TMPro;
using Unity.Collections;
using Unity.Mathematics;
using UnityEditor.Localization.Samples;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.Localization;
using UnityEngine.Localization.Samples;
using UnityEngine.Localization.Settings;
using UnityEngine.Localization.Tables;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.UI;
using UnityEngine.UI.ProceduralImage;
using UnityEngine.UIElements;
using Zorro.Core;
using Zorro.Core.CLI;
using Zorro.Core.Serizalization;
using Zorro.Recorder;
using Zorro.Settings;
using Zorro.Settings.DebugUI;
using Zorro.UI;
using _02Scripts.Charts.Computes;

[assembly: AssemblyVersion("0.0.0.0")]
namespace On
{
	public static class ArtifactBigSlapPainting
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactBigSlapPainting self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactBigSlapPainting self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactBigSlapPainting self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactBigSlapPainting self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_RPCA_SpawnSlap(ArtifactBigSlapPainting self, BinaryDeserializer deserializer);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_RPCA_SpawnSlap(orig_RPCA_SpawnSlap orig, ArtifactBigSlapPainting self, BinaryDeserializer deserializer);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactBigSlapPainting self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactBigSlapPainting self);

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_RPCA_SpawnSlap RPCA_SpawnSlap
		{
			add
			{
				HookEndpointManager.Add<hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactBigSlapPainting
	{
		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator RPCA_SpawnSlap
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactBudget
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactBudget self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactBudget self);

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactBudget
	{
		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactBudget.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactBudget.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactGeneric
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactGeneric self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactGeneric self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactGeneric self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactGeneric self);

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactGeneric
	{
		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGeneric.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGeneric.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGeneric.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGeneric.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactGravityFlipperOff
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactGravityFlipperOff self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactGravityFlipperOff self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactGravityFlipperOff self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactGravityFlipperOff self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactGravityFlipperOff self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactGravityFlipperOff self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_<Update>b__3_0(ArtifactGravityFlipperOff self, CurseOfGravityFlip curse);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_<Update>b__3_0(orig_<Update>b__3_0 orig, ArtifactGravityFlipperOff self, CurseOfGravityFlip curse);

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_<Update>b__3_0 <Update>b__3_0
		{
			add
			{
				HookEndpointManager.Add<hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactGravityFlipperOff
	{
		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator <Update>b__3_0
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactGravityFlipperOn
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactGravityFlipperOn self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactGravityFlipperOn self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnFinishSpawning(ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnFinishSpawning(orig_OnFinishSpawning orig, ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_<Update>b__6_0(ArtifactGravityFlipperOn self, CurseOfGravityFlip curse);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_<Update>b__6_0(orig_<Update>b__6_0 orig, ArtifactGravityFlipperOn self, CurseOfGravityFlip curse);

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_OnFinishSpawning OnFinishSpawning
		{
			add
			{
				HookEndpointManager.Add<hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_<Update>b__6_0 <Update>b__6_0
		{
			add
			{
				HookEndpointManager.Add<hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactGravityFlipperOn
	{
		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator OnFinishSpawning
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator <Update>b__6_0
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactRadio
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactRadio self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactRadio self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactRadio self);

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactRadio
	{
		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactSpawner
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(ArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, ArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactSpawner self);

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactSpawner
	{
		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactSpawner.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactSpawner.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactWithCurse
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactWithCurse self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactWithCurse self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnItemEquipped(ArtifactWithCurse self, Player player);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnItemEquipped(orig_OnItemEquipped orig, ArtifactWithCurse self, Player player);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnDestroy(ArtifactWithCurse self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnDestroy(orig_OnDestroy orig, ArtifactWithCurse self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactWithCurse self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactWithCurse self);

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_OnItemEquipped OnItemEquipped
		{
			add
			{
				HookEndpointManager.Add<hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_OnDestroy OnDestroy
		{
			add
			{
				HookEndpointManager.Add<hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactWithCurse
	{
		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactWithCurse.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator OnItemEquipped
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactWithCurse.hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator OnDestroy
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactWithCurse.hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactWithCurse.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactZombieBook
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactZombieBook self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactZombieBook self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactZombieBook self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactZombieBook self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactZombieBook self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactZombieBook self);

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactZombieBook
	{
		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactZombieBook.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactZombieBook.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactZombieBook.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactZombieBook.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactZombieBook.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactZombieBook.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class CurseDataBase
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(CurseDataBase self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, CurseDataBase self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(CurseDataBase self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, CurseDataBase self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(CurseDataBase self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, CurseDataBase self);

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class CurseDataBase
	{
		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.CurseDataBase.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CurseDataBase.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.CurseDataBase.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CurseDataBase.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.CurseDataBase.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CurseDataBase.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class CursedPlayerBoss
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SpawnCurse(CursedPlayerBoss self, ItemInstanceBehaviour artifact, GameObject cursePrefab);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SpawnCurse(orig_SpawnCurse orig, CursedPlayerBoss self, ItemInstanceBehaviour artifact, GameObject cursePrefab);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Awake(CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Awake(orig_Awake orig, CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, CursedPlayerBoss self);

		public static event hook_SpawnCurse SpawnCurse
		{
			add
			{
				HookEndpointManager.Add<hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Awake Awake
		{
			add
			{
				HookEndpointManager.Add<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class CursedPlayerBoss
	{
		public static event Manipulator SpawnCurse
		{
			add
			{
				HookEndpointManager.Modify<On.CursedPlayerBoss.hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Awake
		{
			add
			{
				HookEndpointManager.Modify<On.CursedPlayerBoss.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.CursedPlayerBoss.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.CursedPlayerBoss.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.CursedPlayerBoss.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class PersistantRadio
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(PersistantRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, PersistantRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(PersistantRadio self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, PersistantRadio self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(PersistantRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, PersistantRadio self);

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class PersistantRadio
	{
		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.PersistantRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.PersistantRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.PersistantRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.PersistantRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.PersistantRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.PersistantRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class RoundArtifactSpawner
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Awake(RoundArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Awake(orig_Awake orig, RoundArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Start(RoundArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Start(orig_Start orig, RoundArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SpawnRound(RoundArtifactSpawner self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SpawnRound(orig_SpawnRound orig, RoundArtifactSpawner self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_PrintArtifactsPerDay(RoundArtifactSpawner self, int day, int times);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_PrintArtifactsPerDay(orig_PrintArtifactsPerDay orig, RoundArtifactSpawner self, int day, int times);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<Item> orig_GetArtifactsToSpawn(RoundArtifactSpawner self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<Item> hook_GetArtifactsToSpawn(orig_GetArtifactsToSpawn orig, RoundArtifactSpawner self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_CreateArtifactSpawners(RoundArtifactSpawner self, List<Item> artifacts);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_CreateArtifactSpawners(orig_CreateArtifactSpawners orig, RoundArtifactSpawner self, List<Item> artifacts);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Vector3 orig_GetRandPointWithWeight();

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Vector3 hook_GetRandPointWithWeight(orig_GetRandPointWithWeight orig);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item orig_GetArtifact(ref int budget, Item[] possibleSpawns, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item hook_GetArtifact(orig_GetArtifact orig, ref int budget, Item[] possibleSpawns, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item orig_GetRandomArtifactByRarity(Item[] possibleSpawns);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item hook_GetRandomArtifactByRarity(orig_GetRandomArtifactByRarity orig, Item[] possibleSpawns);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(RoundArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, RoundArtifactSpawner self);

		public static class ArtifactWithWeight
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(ArtifactWithWeight self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, ArtifactWithWeight self);

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}
		}

		public static event hook_Awake Awake
		{
			add
			{
				HookEndpointManager.Add<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_SpawnRound SpawnRound
		{
			add
			{
				HookEndpointManager.Add<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_PrintArtifactsPerDay PrintArtifactsPerDay
		{
			add
			{
				HookEndpointManager.Add<hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetArtifactsToSpawn GetArtifactsToSpawn
		{
			add
			{
				HookEndpointManager.Add<hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_CreateArtifactSpawners CreateArtifactSpawners
		{
			add
			{
				HookEndpointManager.Add<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetRandPointWithWeight GetRandPointWithWeight
		{
			add
			{
				HookEndpointManager.Add<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetArtifact GetArtifact
		{
			add
			{
				HookEndpointManager.Add<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetRandomArtifactByRarity GetRandomArtifactByRarity
		{
			add
			{
				HookEndpointManager.Add<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class RoundArtifactSpawner
	{
		public static class ArtifactWithWeight
		{
			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.RoundArtifactSpawner.ArtifactWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.RoundArtifactSpawner.ArtifactWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}
		}

		public static event Manipulator Awake
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator SpawnRound
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator PrintArtifactsPerDay
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetArtifactsToSpawn
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator CreateArtifactSpawners
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetRandPointWithWeight
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetArtifact
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetRandomArtifactByRarity
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class RoundSpawnerTools
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Awake(RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Awake(orig_Awake orig, RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Populate(RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Populate(orig_Populate orig, RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Start(RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Start(orig_Start orig, RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SpawnRound(RoundSpawnerTools self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SpawnRound(orig_SpawnRound orig, RoundSpawnerTools self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_PrintToolsPerDay(RoundSpawnerTools self, int day, int times);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_PrintToolsPerDay(orig_PrintToolsPerDay orig, RoundSpawnerTools self, int day, int times);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<Item> orig_GetToolsToSpawn(RoundSpawnerTools self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<Item> hook_GetToolsToSpawn(orig_GetToolsToSpawn orig, RoundSpawnerTools self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_CreateArtifactSpawners(RoundSpawnerTools self, List<Item> artifacts);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_CreateArtifactSpawners(orig_CreateArtifactSpawners orig, RoundSpawnerTools self, List<Item> artifacts);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Vector3 orig_GetRandPointWithWeight();

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Vector3 hook_GetRandPointWithWeight(orig_GetRandPointWithWeight orig);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item orig_GetArtifact(ref int budget, List<Item> possibleSpawns, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item hook_GetArtifact(orig_GetArtifact orig, ref int budget, List<Item> possibleSpawns, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item orig_GetRandomArtifactByRarity(Item[] possibleSpawns);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item hook_GetRandomArtifactByRarity(orig_GetRandomArtifactByRarity orig, Item[] possibleSpawns);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, RoundSpawnerTools self);

		public static class ToolWithWeight
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(ToolWithWeight self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, ToolWithWeight self);

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}
		}

		public static event hook_Awake Awake
		{
			add
			{
				HookEndpointManager.Add<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Populate Populate
		{
			add
			{
				HookEndpointManager.Add<hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_SpawnRound SpawnRound
		{
			add
			{
				HookEndpointManager.Add<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_PrintToolsPerDay PrintToolsPerDay
		{
			add
			{
				HookEndpointManager.Add<hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetToolsToSpawn GetToolsToSpawn
		{
			add
			{
				HookEndpointManager.Add<hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_CreateArtifactSpawners CreateArtifactSpawners
		{
			add
			{
				HookEndpointManager.Add<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetRandPointWithWeight GetRandPointWithWeight
		{
			add
			{
				HookEndpointManager.Add<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetArtifact GetArtifact
		{
			add
			{
				HookEndpointManager.Add<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetRandomArtifactByRarity GetRandomArtifactByRarity
		{
			add
			{
				HookEndpointManager.Add<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class RoundSpawnerTools
	{
		public static class ToolWithWeight
		{
			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.RoundSpawnerTools.ToolWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.RoundSpawnerTools.ToolWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}
		}

		public static event Manipulator Awake
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Populate
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator SpawnRound
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator PrintToolsPerDay
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetToolsToSpawn
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator CreateArtifactSpawners
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetRandPointWithWeight
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetArtifact
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetRandomArtifactByRarity
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class AspectRatioUISetter
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SetDefault(AspectRatioUISetter self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SetDefault(orig_SetDefault orig, AspectRatioUISetter self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SetAspectPosition(AspectRatioUISetter self, AspectRatio aspectRatio);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SetAspectPosition(orig_SetAspectPosition orig, AspectRatioUISetter self, AspectRatio aspectRatio);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_LoadAspectPosition(AspectRatioUISetter self, AspectRatio aspectRatio);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_LoadAspectPosition(orig_LoadAspectPosition orig, AspectRatioUISetter self, AspectRatio aspectRatio);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(AspectRatioUISetter self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, AspectRatioUISetter self);

		public static class AspectPosition
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(AspectPosition self, RectTransform rectTransform);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, AspectPosition self, RectTransform rectTransform);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_Load(AspectPosition self, RectTransform rectTransform);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_Load(orig_Load orig, AspectPosition self, RectTransform rectTransform);

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}

			public static event hook_Load Load
			{
				add
				{
					HookEndpointManager.Add<hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}
		}

		public static class SavedAspectPosition
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(SavedAspectPosition self, AspectRatio aspectRatio, AspectPosition aspectPosition);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, SavedAspectPosition self, AspectRatio aspectRatio, AspectPosition aspectPosition);

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}
		}

		public static event hook_SetDefault SetDefault
		{
			add
			{
				HookEndpointManager.Add<hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_SetAspectPosition SetAspectPosition
		{
			add
			{
				HookEndpointManager.Add<hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_LoadAspectPosition LoadAspectPosition
		{
			add
			{
				HookEndpointManager.Add<hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class AspectRatioUISetter
	{
		public static class AspectPosition
		{
			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.AspectRatioUISetter.AspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.AspectRatioUISetter.AspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}

			public static event Manipulator Load
			{
				add
				{
					HookEndpointManager.Modify<On.AspectRatioUISetter.AspectPosition.hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.AspectRatioUISetter.AspectPosition.hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}
		}

		public static class SavedAspectPosition
		{
			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.AspectRatioUISetter.SavedAspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.AspectRatioUISetter.SavedAspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}
		}

		public static event Manipulator SetDefault
		{
			add
			{
				HookEndpointManager.Modify<On.AspectRatioUISetter.hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator SetAspectPosition
		{
			add
			{
				HookEndpointManager.Modify<On.AspectRatioUISetter.hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator LoadAspectPosition
		{
			add
			{
				HookEndpointManager.Modify<On.AspectRatioUISetter.hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.AspectRatioUISetter.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class AudioLoop
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnEnable(AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnEnable(orig_OnEnable orig, AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnDisable(AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnDisable(orig_OnDisable orig, AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SetTime(AudioLoop self, float timeInSong);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SetTime(orig_SetTime orig, AudioLoop self, float timeInSong);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_TryGetOverrideTime(AudioLoop self, out float f);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_TryGetOverrideTime(orig_TryGetOverrideTime orig, AudioLoop self, out float f);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_CheckBoost(AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_CheckBoost(orig_CheckBoost orig, AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, AudioLoop self);

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_OnEnable OnEnable
		{
			add
			{
				HookEndpointManager.Add<hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_OnDisable OnDisable
		{
			add
			{
				HookEndpointManager.Add<hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_SetTime SetTime
		{
			add
			{
				HookEndpointManager.Add<hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_TryGetOverrideTime TryGetOverrideTime
		{
			add
			{
				HookEndpointManager.Add<hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_CheckBoost CheckBoost
		{
			add
			{
				HookEndpointManager.Add<hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class AudioLoop
	{
		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator OnEnable
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator OnDisable
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator SetTime
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator TryGetOverrideTime
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator CheckBoost
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class AudioLoopHandler
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_RegisterAudioLoop(AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_RegisterAudioLoop(orig_RegisterAudioLoop orig, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_UnregisterAudioLoop(AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_UnregisterAudioLoop(orig_UnregisterAudioLoop orig, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_LateUpdate(AudioLoopHandler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_LateUpdate(orig_LateUpdate orig, AudioLoopHandler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_RemoveSource(AudioLoopHandler self, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_RemoveSource(orig_RemoveSource orig, AudioLoopHandler self, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_AssignSource(AudioLoopHandler self, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_AssignSource(orig_AssignSource orig, AudioLoopHandler self, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(AudioLoopHandler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, AudioLoopHandler self);

		public static event hook_RegisterAudioLoop RegisterAudioLoop
		{
			add
			{
				HookEndpointManager.Add<hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_UnregisterAudioLoop UnregisterAudioLoop
		{
			add
			{
				HookEndpointManager.Add<hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_LateUpdate LateUpdate
		{
			add
			{
				HookEndpointManager.Add<hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_RemoveSource RemoveSource
		{
			add
			{
				HookEndpointManager.Add<hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_AssignSource AssignSource
		{
			add
			{
				HookEndpointManager.Add<hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class AudioLoopHandler
	{
		public static event Manipulator RegisterAudioLoop
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator UnregisterAudioLoop
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator LateUpdate
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator RemoveSource
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator AssignSource
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class AudioObstructability
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate float orig_GetObstructionValue(Vector3 position, float obstructability, out float rangeFactor);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate float hook_GetObstructionValue(orig_GetObstructionValue orig, Vector3 position, float obstructability, out float rangeFactor);

		public static event hook_GetObstructionValue GetObstructionValue
		{
			add
			{
				HookEndpointManager.Add<hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class AudioObstructability
	{
		public static event Manipulator GetObstructionValue
		{
			add
			{
				HookEndpointManager.Modify<On.AudioObstructability.hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioObstructability.hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class AudioToggler
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(AudioToggler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, AudioToggler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(AudioToggler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook