Decompiled source of Keep Camera After Death v1.3.0

Get the Thunderstore App

Easily install and manage your mods with the Thunderstore App!

Decompiled source of Keep Camera After Death v1.3.0

alexandria-p.KeepCameraAfterDeath.dll

Decompiled 2 weeks ago

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using KeepCameraAfterDeath.Patches;
using Microsoft.CodeAnalysis;
using MonoMod.RuntimeDetour.HookGen;
using MyceliumNetworking;
using On;
using Photon.Pun;
using Unity.Mathematics;
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.KeepCameraAfterDeath")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0+809bc897adf7dc5fd4cf17919321e62fc10a4cc0")]
[assembly: AssemblyProduct("KeepCameraAfterDeath")]
[assembly: AssemblyTitle("alexandria-p.KeepCameraAfterDeath")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace KeepCameraAfterDeath
{
	[ContentWarningPlugin("alexandria-p.KeepCameraAfterDeath", "1.3.0", false)]
	[BepInPlugin("alexandria-p.KeepCameraAfterDeath", "KeepCameraAfterDeath", "1.3.0")]
	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("KeepCameraAfterDeathPluginR2ModMan")
			{
				hideFlags = (HideFlags)61
			};
			val.AddComponent<KeepCameraAfterDeath>();
			KeepCameraAfterDeath.Instance.SetLogger(((BaseUnityPlugin)this).Logger);
			Object.DontDestroyOnLoad((Object)(object)val);
		}
	}
	public class KeepCameraAfterDeath : MonoBehaviour
	{
		[ContentWarningSetting]
		public class EnableRewardForCameraReturnSetting : BoolSetting, IExposedSetting
		{
			public SettingCategory GetSettingCategory()
			{
				return (SettingCategory)4;
			}

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

			public string GetDisplayName()
			{
				return "KeepCameraAfterDeath: Turn on incentives for bringing the camera back to the surface (uses the host's game settings)";
			}

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

		[ContentWarningSetting]
		public class SetMetaCoinRewardForCameraReturnSetting : FloatSetting, IExposedSetting
		{
			public SettingCategory GetSettingCategory()
			{
				return (SettingCategory)4;
			}

			public override void ApplyValue()
			{
				Instance.SetPlayerSettingMetaCoinReward(((FloatSetting)this).Value);
			}

			public string GetDisplayName()
			{
				return "KeepCameraAfterDeath: Meta Coin (MC) reward for camera return (uses the host's game settings)";
			}

			protected override float GetDefaultValue()
			{
				return 10f;
			}

			protected override float2 GetMinMaxValue()
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return new float2(0f, 100f);
			}
		}

		[ContentWarningSetting]
		public class SetCashRewardForCameraReturnSetting : FloatSetting, IExposedSetting
		{
			public SettingCategory GetSettingCategory()
			{
				return (SettingCategory)4;
			}

			public override void ApplyValue()
			{
				Instance.SetPlayerSettingCashReward(((FloatSetting)this).Value);
			}

			public string GetDisplayName()
			{
				return "KeepCameraAfterDeath: Cash reward for camera return (uses the host's game settings)";
			}

			protected override float GetDefaultValue()
			{
				return 0f;
			}

			protected override float2 GetMinMaxValue()
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return new float2(0f, 1000f);
			}
		}

		private const uint myceliumNetworkModId = 61812u;

		public static KeepCameraAfterDeath Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		public bool PlayerSettingEnableRewardForCameraReturn { get; private set; }

		public float PlayerSettingMetaCoinReward { get; private set; }

		public float PlayerSettingCashReward { get; private set; }

		public ItemInstanceData? PreservedCameraInstanceDataForHost { get; private set; }

		public (float cash, float mc)? PendingRewardForCameraReturn { get; private set; }

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

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

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

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

		internal static void HookAll()
		{
			SurfaceNetworkHandlerPatch.Init();
			VideoCameraPatch.Init();
			PersistentObjectsHolderPatch.Init();
			PlayerPatch.Init();
		}

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

		public void SetPlayerSettingEnableRewardForCameraReturn(bool rewardEnabled)
		{
			PlayerSettingEnableRewardForCameraReturn = rewardEnabled;
		}

		public void SetPlayerSettingMetaCoinReward(float mcReward)
		{
			PlayerSettingMetaCoinReward = mcReward;
		}

		public void SetPlayerSettingCashReward(float cashReward)
		{
			PlayerSettingCashReward = cashReward;
		}

		public void SetPreservedCameraInstanceDataForHost(ItemInstanceData data)
		{
			if (MyceliumNetwork.IsHost)
			{
				PreservedCameraInstanceDataForHost = data;
			}
		}

		public void SetPendingRewardForAllPlayers()
		{
			if (MyceliumNetwork.IsHost)
			{
				MyceliumNetwork.RPC(61812u, "RPC_SetPendingRewardForCameraReturn", (ReliableType)1, new object[2] { PlayerSettingCashReward, PlayerSettingMetaCoinReward });
			}
		}

		[CustomRPC]
		public void RPC_SetPendingRewardForCameraReturn(float cash, float mc)
		{
			PendingRewardForCameraReturn = (cash, mc);
		}

		public void Command_ResetDataforDay()
		{
			if (MyceliumNetwork.IsHost)
			{
				Logger.LogInfo((object)"KeepCameraAfterDeath v1.3.0 reset data for day");
				MyceliumNetwork.RPC(61812u, "RPC_ResetDataforDay", (ReliableType)1, Array.Empty<object>());
			}
		}

		[CustomRPC]
		public void RPC_ResetDataforDay()
		{
			Instance.ClearData();
		}

		public void ClearData()
		{
			Instance.ClearPreservedCameraInstanceDataForHost();
			Instance.ClearPendingRewardForCameraReturn();
		}

		public void ClearPreservedCameraInstanceDataForHost()
		{
			if (MyceliumNetwork.IsHost)
			{
				PreservedCameraInstanceDataForHost = null;
			}
		}

		public void ClearPendingRewardForCameraReturn()
		{
			PendingRewardForCameraReturn = null;
		}

		public bool IsFinalDayAndQuotaNotMet()
		{
			if (SurfaceNetworkHandler.RoomStats != null && SurfaceNetworkHandler.RoomStats.IsQuotaDay)
			{
				return !SurfaceNetworkHandler.RoomStats.CalculateIfReachedQuota();
			}
			return false;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "alexandria-p.KeepCameraAfterDeath";

		public const string PLUGIN_NAME = "KeepCameraAfterDeath";

		public const string PLUGIN_VERSION = "1.3.0";
	}
}
namespace KeepCameraAfterDeath.Patches
{
	public class PersistentObjectsHolderPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_FindPersistantObjects <0>__PersistentObjectsHolder_FindPersistantObjects;
		}

		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>__PersistentObjectsHolder_FindPersistantObjects;
			if (obj == null)
			{
				hook_FindPersistantObjects val = PersistentObjectsHolder_FindPersistantObjects;
				<>O.<0>__PersistentObjectsHolder_FindPersistantObjects = val;
				obj = (object)val;
			}
			PersistentObjectsHolder.FindPersistantObjects += (hook_FindPersistantObjects)obj;
		}

		private static void PersistentObjectsHolder_FindPersistantObjects(orig_FindPersistantObjects orig, PersistentObjectsHolder self)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			List<VideoCamera> list = FindVideoCamerasInSet(self.m_PersistentObjects);
			orig.Invoke(self);
			if (!MyceliumNetwork.IsHost)
			{
				return;
			}
			int count = self.m_PersistentObjects.Count;
			VideoCamera item2 = default(VideoCamera);
			for (int num = count - 1; num >= 0; num--)
			{
				PersistentObjectInfo item = self.m_PersistentObjects[num];
				ItemInstanceData instanceData = ((PersistentObjectInfo)(ref item)).InstanceData;
				Guid guid = instanceData.m_guid;
				if (CameraHandler.TryGetCamera(guid, ref item2) && !list.Contains(item2))
				{
					KeepCameraAfterDeath.Instance.SetPreservedCameraInstanceDataForHost(instanceData);
					if (self.m_PersistentObjectDic.ContainsKey(((PersistentObjectInfo)(ref item)).Pickup))
					{
						self.m_PersistentObjectDic.Remove(((PersistentObjectInfo)(ref item)).Pickup);
					}
					self.m_PersistentObjects.Remove(item);
					break;
				}
			}
		}

		private static List<VideoCamera> FindVideoCamerasInSet(List<PersistentObjectInfo> persistantObjects)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			List<VideoCamera> list = new List<VideoCamera>();
			VideoCamera item = default(VideoCamera);
			foreach (PersistentObjectInfo persistantObject in persistantObjects)
			{
				PersistentObjectInfo current = persistantObject;
				ItemInstanceData instanceData = ((PersistentObjectInfo)(ref current)).InstanceData;
				Guid guid = instanceData.m_guid;
				if (CameraHandler.TryGetCamera(guid, ref item))
				{
					list.Add(item);
				}
			}
			return list;
		}
	}
	public class PlayerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Update <0>__Player_Update;
		}

		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>__Player_Update;
			if (obj == null)
			{
				hook_Update val = Player_Update;
				<>O.<0>__Player_Update = val;
				obj = (object)val;
			}
			Player.Update += (hook_Update)obj;
		}

		private static void Player_Update(orig_Update orig, Player self)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			if (KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.HasValue && self.IsLocal && self.data.playerSetUpAndReady && SurfaceNetworkHandler.RoomStats != null && (int)TimeOfDayHandler.TimeOfDay == 10)
			{
				AddCashToRoom();
				AddMCToPlayers();
				KeepCameraAfterDeath.Instance.ClearPendingRewardForCameraReturn();
			}
			orig.Invoke(self);
			static void AddCashToRoom()
			{
				float item2 = KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.Value.cash;
				if (!(item2 <= 0f))
				{
					UserInterface.ShowMoneyNotification("Cash Received", $"${(int)item2}", (MoneyCellType)1);
					if (MyceliumNetwork.IsHost)
					{
						SurfaceNetworkHandler.RoomStats.AddMoney((int)item2);
					}
				}
			}
			static void AddMCToPlayers()
			{
				float item = KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.Value.mc;
				if (!(item <= 0f))
				{
					MetaProgressionHandler.AddMetaCoins((int)item);
				}
			}
		}
	}
	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)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			if (SurfaceNetworkHandler.RoomStats == null)
			{
				KeepCameraAfterDeath.Instance.ClearData();
			}
			if (MyceliumNetwork.IsHost && (int)TimeOfDayHandler.TimeOfDay == 10)
			{
				if (KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost != null)
				{
					KeepCameraAfterDeath.Logger.LogInfo((object)"KeepCameraAfterDeath: Found backed-up camera footage");
					self.m_VideoCameraSpawner.SpawnMe(true);
				}
				else
				{
					KeepCameraAfterDeath.Logger.LogInfo((object)"KeepCameraAfterDeath: Could not find camera footage to restore");
					if (KeepCameraAfterDeath.Instance.PlayerSettingEnableRewardForCameraReturn)
					{
						KeepCameraAfterDeath.Instance.SetPendingRewardForAllPlayers();
					}
				}
			}
			orig.Invoke(self);
		}

		private static void SurfaceNetworkHandler_NextDay(orig_NextDay orig, SurfaceNetworkHandler self)
		{
			orig.Invoke(self);
			KeepCameraAfterDeath.Logger.LogInfo((object)"KeepCameraAfterDeath v1.3.0 Surface network handler patch NEXT DAY: reset data for day");
			KeepCameraAfterDeath.Instance.Command_ResetDataforDay();
		}
	}
	public class VideoCameraPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_ConfigItem <0>__VideoCamera_ConfigItem;
		}

		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>__VideoCamera_ConfigItem;
			if (obj == null)
			{
				hook_ConfigItem val = VideoCamera_ConfigItem;
				<>O.<0>__VideoCamera_ConfigItem = val;
				obj = (object)val;
			}
			VideoCamera.ConfigItem += (hook_ConfigItem)obj;
		}

		private static void VideoCamera_ConfigItem(orig_ConfigItem orig, VideoCamera self, ItemInstanceData data, PhotonView playerView)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			bool flag = (int)TimeOfDayHandler.TimeOfDay == 10;
			VideoInfoEntry val = default(VideoInfoEntry);
			bool flag2 = !data.TryGetEntry<VideoInfoEntry>(ref val) || val.videoID.id == Guid.Empty;
			bool flag3 = KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost != null;
			VideoInfoEntry val2 = default(VideoInfoEntry);
			if (MyceliumNetwork.IsHost && flag3 && flag && flag2 && KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost.TryGetEntry<VideoInfoEntry>(ref val2) && val2.videoID.id != Guid.Empty)
			{
				ManualLogSource logger = KeepCameraAfterDeath.Logger;
				Guid id = val2.videoID.id;
				logger.LogInfo((object)("KeepCameraAfterDeath: Restore camera footage: " + id));
				data.AddDataEntry((ItemDataEntry)(object)val2);
				KeepCameraAfterDeath.Instance.ClearPreservedCameraInstanceDataForHost();
			}
			orig.Invoke(self, data, playerView);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}

Dependencies/MMHOOK_Assembly-CSharp.dll

Decompiled 2 weeks ago

Download (5.9 MB)

The result has been truncated due to the large size, download it to view full contents!

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

Get the Thunderstore App

Decompiled source of Keep Camera After Death v1.3.0

alexandria-p.KeepCameraAfterDeath.dll

Dependencies/MMHOOK_Assembly-CSharp.dll

About

Developers