Decompiled source of MMHOOK Assembly v1.0.0

Get the Thunderstore App

Easily install and manage your mods with the Thunderstore App!
Get App
Decompiled source of MMHOOK Assembly v1.0.0

MMHOOK-Assembly-CSharp.dll

Decompiled 2 months ago
Download (15.0 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.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Text;
using System.Text.RegularExpressions;
using AlienFXManagedWrapper;
using ArcConsistency;
using CS.Lights;
using CS.Lights.Alien;
using CS.Platform;
using CS.Platform.Base.Client.Part;
using CS.Platform.Core.Server;
using CS.Platform.Core.Server.Part;
using CS.Platform.None.Client;
using CS.Platform.None.Client.Part;
using CS.Platform.Steam.Client;
using CS.Platform.Steam.Client.Part;
using CS.Platform.Utils;
using CS.Platform.Utils.Data;
using CS.VT;
using ControlledRandomness;
using ControlledRandomness.Swapping;
using Discord;
using Fabric;
using GooglePlayGames;
using GooglePlayGames.BasicApi;
using GooglePlayGames.BasicApi.Nearby;
using GooglePlayGames.BasicApi.SavedGame;
using GooglePlayGames.BasicApi.Video;
using GooglePlayGames.OurUtils;
using I2.Loc;
using I2.Loc.SimpleJSON;
using InspectorExpressions;
using MeshModifer;
using MonoMod.Cil;
using MonoMod.RuntimeDetour.HookGen;
using On;
using On.ArcConsistency;
using On.CS.Lights;
using On.CS.Lights.Alien;
using On.CS.Platform;
using On.CS.Platform.Base.Client.Addon;
using On.CS.Platform.Base.Client.Part;
using On.CS.Platform.Core.Server;
using On.CS.Platform.Core.Server.Part;
using On.CS.Platform.Helpers.Client.Part;
using On.CS.Platform.None.Client;
using On.CS.Platform.None.Client.Part;
using On.CS.Platform.Steam.Client;
using On.CS.Platform.Steam.Client.Part;
using On.CS.Platform.Utils;
using On.CS.Platform.Utils.Data;
using On.CS.Platform.Utils.Data.SystemMessages;
using On.CS.VT;
using On.ControlledRandomness;
using On.ControlledRandomness.Swapping;
using On.Discord;
using On.Fabric;
using On.GooglePlayGames;
using On.GooglePlayGames.BasicApi;
using On.GooglePlayGames.BasicApi.Nearby;
using On.GooglePlayGames.BasicApi.SavedGame;
using On.GooglePlayGames.BasicApi.Video;
using On.GooglePlayGames.OurUtils;
using On.I2.Loc;
using On.I2.Loc.SimpleJSON;
using On.InspectorExpressions;
using On.MeshModifer;
using On.RTM.Git;
using On.RTM.Input;
using On.RTM.OnScreenDebug;
using On.RTM.OnScreenDebug.Internals;
using On.RTM.Pools;
using On.RTM.UISystem;
using On.RTM.UISystem.Internal;
using On.RTM.Utilities;
using On.RTM.Utilities.Test;
using On.ReflexCLI;
using On.ReflexCLI.Attributes;
using On.ReflexCLI.Libraries.FabricIntegration;
using On.ReflexCLI.Libraries.I2Integration;
using On.ReflexCLI.Parameters;
using On.ReflexCLI.UI;
using On.ReflexCLI.User;
using On.Rewired;
using On.Rewired.Data;
using On.Rewired.Demos;
using On.Rewired.Demos.GamepadTemplateUI;
using On.Rewired.Integration.UnityUI;
using On.Rewired.Internal;
using On.Rewired.Platforms.Switch;
using On.Rewired.Utils;
using On.SpriteComposing;
using On.Spriteshop;
using On.Steamworks;
using On.TrialVersion;
using On.Voxels;
using On.Voxels.SetRules;
using On.Voxels.TowerDefense;
using On.Voxels.TowerDefense.Ballistics;
using On.Voxels.TowerDefense.CampaignGeneration;
using On.Voxels.TowerDefense.CampaignGeneration.CampaignAc3;
using On.Voxels.TowerDefense.CampaignGeneration.Triangulation;
using On.Voxels.TowerDefense.CanvasSprites;
using On.Voxels.TowerDefense.CoinDispensing;
using On.Voxels.TowerDefense.Flag;
using On.Voxels.TowerDefense.Forestry;
using On.Voxels.TowerDefense.GdcDebuggers;
using On.Voxels.TowerDefense.HeroGeneration;
using On.Voxels.TowerDefense.Portraits;
using On.Voxels.TowerDefense.ProfileInternals;
using On.Voxels.TowerDefense.RaidGeneration;
using On.Voxels.TowerDefense.RaidPlanning;
using On.Voxels.TowerDefense.Reflex;
using On.Voxels.TowerDefense.ScriptAnimations;
using On.Voxels.TowerDefense.SpriteMagic;
using On.Voxels.TowerDefense.TriFlow;
using On.Voxels.TowerDefense.Tutorial;
using On.Voxels.TowerDefense.UI;
using On.Voxels.TowerDefense.UI.GridScrolling;
using On.Voxels.TowerDefense.UI.MetaInventory;
using On.Voxels.TowerDefense.UI.UpgradeScreen;
using On.Voxels.TowerDefense.Upgrades;
using On.Voxels.TowerDefense.WorldEnvironment;
using On.Voxels.TowerDefense.upgrades;
using RTM.Input;
using RTM.OnScreenDebug;
using RTM.OnScreenDebug.Internals;
using RTM.Pools;
using RTM.UISystem;
using RTM.Utilities;
using ReflexCLI;
using ReflexCLI.Attributes;
using ReflexCLI.Libraries.FabricIntegration;
using ReflexCLI.Parameters;
using ReflexCLI.UI;
using Rewired;
using Rewired.ControllerExtensions;
using Rewired.Data;
using Rewired.Demos;
using Rewired.Demos.GamepadTemplateUI;
using Rewired.Integration.UnityUI;
using Rewired.Platforms;
using Rewired.Platforms.Switch;
using Rewired.UI;
using Rewired.Utils;
using Rewired.Utils.Interfaces;
using Sony.PS4.SavedGame;
using SpriteComposing;
using Spriteshop;
using Steamworks;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Networking;
using UnityEngine.Profiling;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Voxels;
using Voxels.SetRules;
using Voxels.TowerDefense;
using Voxels.TowerDefense.Ballistics;
using Voxels.TowerDefense.CampaignGeneration;
using Voxels.TowerDefense.CampaignGeneration.CampaignAc3;
using Voxels.TowerDefense.CampaignGeneration.Triangulation;
using Voxels.TowerDefense.CanvasSprites;
using Voxels.TowerDefense.CoinDispensing;
using Voxels.TowerDefense.Flag;
using Voxels.TowerDefense.Forestry;
using Voxels.TowerDefense.GdcDebuggers;
using Voxels.TowerDefense.HeroGeneration;
using Voxels.TowerDefense.Portraits;
using Voxels.TowerDefense.ProfileInternals;
using Voxels.TowerDefense.RaidGeneration;
using Voxels.TowerDefense.RaidPlanning;
using Voxels.TowerDefense.Reflex;
using Voxels.TowerDefense.ScriptAnimations;
using Voxels.TowerDefense.SpriteMagic;
using Voxels.TowerDefense.TriFlow;
using Voxels.TowerDefense.Tutorial;
using Voxels.TowerDefense.UI;
using Voxels.TowerDefense.UI.GridScrolling;
using Voxels.TowerDefense.UI.MetaInventory;
using Voxels.TowerDefense.UI.UpgradeScreen;
using Voxels.TowerDefense.Upgrades;
using Voxels.TowerDefense.WorldEnvironment;

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Setup(Arc self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Setup(orig_Setup orig, Arc self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Arc orig_NewArc(Domain domain, ArcRule rule);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Arc hook_NewArc(orig_NewArc orig, Domain domain, ArcRule rule);

		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_Setup Setup
		{
			add
			{
				HookEndpointManager.Add<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_RunFast(ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_RunFast(orig_RunFast orig, ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_RunSlow(ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_RunSlow(orig_RunSlow orig, ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerable orig_Setup(ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerable hook_Setup(orig_Setup orig, ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Resolve(ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Resolve(orig_Resolve orig, ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerable<bool> orig_ConidtionalResolve(ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerable<bool> hook_ConidtionalResolve(orig_ConidtionalResolve orig, ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_PushToWorklist(ArcConsistencySolver self, Arc arc);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_PushToWorklist(orig_PushToWorklist orig, ArcConsistencySolver self, Arc arc);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_MaybeDebugLog(ArcConsistencySolver self, string message, Object target);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_MaybeDebugLog(orig_MaybeDebugLog orig, ArcConsistencySolver self, string message, Object target);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnDomainReduced(ArcConsistencySolver self, Domain domain);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnDomainReduced(orig_OnDomainReduced orig, ArcConsistencySolver self, Domain domain);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerable<bool> orig_ReduceByGuessing(ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerable<bool> hook_ReduceByGuessing(orig_ReduceByGuessing orig, ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerable<bool> orig_ReduceArc(ArcConsistencySolver self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerable<bool> hook_ReduceArc(orig_ReduceArc orig, ArcConsistencySolver 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_RunFast RunFast
		{
			add
			{
				HookEndpointManager.Add<hook_RunFast>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_RunFast>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static event Manipulator ReduceArc
		{
			add
			{
				HookEndpointManager.Modify<On.ArcConsistency.ArcConsistencySolver.hook_ReduceArc>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArcConsistency.ArcConsistencySolver.hook_ReduceArc>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On.ArcConsistency
{
	public static class Guess
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ref Guess self, Domain domain, float value, float priority);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ref Guess self, Domain domain, float value, float priority);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_TakeGuess(ref Guess self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_TakeGuess(orig_TakeGuess orig, ref Guess 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_TakeGuess TakeGuess
		{
			add
			{
				HookEndpointManager.Add<hook_TakeGuess>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_TakeGuess>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL.ArcConsistency
{
	public static class Guess
	{
		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArcConsistency.Guess.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArcConsistency.Guess.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Setup(ArcRule self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Setup(orig_Setup orig, ArcRule self);

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, ArcRule 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_Setup Setup
		{
			add
			{
				HookEndpointManager.Add<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Setup>(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);
			}
		}
	}
}
namespace IL.ArcConsistency
{
	public static class ArcRule
	{
		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArcConsistency.ArcRule.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArcConsistency.ArcRule.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Setup(ArcRuleEnumerable self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Setup(orig_Setup orig, ArcRuleEnumerable 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_Setup Setup
		{
			add
			{
				HookEndpointManager.Add<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL.ArcConsistency
{
	public static class ArcRuleEnumerable
	{
		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArcConsistency.ArcRuleEnumerable.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArcConsistency.ArcRuleEnumerable.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> orig_GetInitialValues(Domain self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> hook_GetInitialValues(orig_GetInitialValues orig, Domain self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> orig_GetValues(Domain self, Domain variableOverride, float valueOverride);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> hook_GetValues(orig_GetValues orig, Domain self, Domain variableOverride, float valueOverride);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_PrepareDomain(Domain self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_PrepareDomain(orig_PrepareDomain orig, Domain self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate string orig_GetDomainString(Domain self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate string hook_GetDomainString(orig_GetDomainString orig, Domain self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate string orig_ToString(Domain self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate string hook_ToString(orig_ToString orig, Domain 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_GetInitialValues GetInitialValues
		{
			add
			{
				HookEndpointManager.Add<hook_GetInitialValues>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetInitialValues>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

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

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

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> orig_GenerateValues(DomainBool self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> hook_GenerateValues(orig_GenerateValues orig, DomainBool self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_cctor();

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_cctor(orig_cctor orig);

		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_GenerateValues GenerateValues
		{
			add
			{
				HookEndpointManager.Add<hook_GenerateValues>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GenerateValues>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> orig_GenerateValues(DomainRange self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> hook_GenerateValues(orig_GenerateValues orig, DomainRange self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> orig_CreateDomain_Spacing(DomainRange self, float spacing);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> hook_CreateDomain_Spacing(orig_CreateDomain_Spacing orig, DomainRange self, float spacing);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> orig_CreateDomain_Count(DomainRange self, int count);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> hook_CreateDomain_Count(orig_CreateDomain_Count orig, DomainRange self, int count);

		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_GenerateValues GenerateValues
		{
			add
			{
				HookEndpointManager.Add<hook_GenerateValues>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GenerateValues>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> orig_GenerateValues(DomainSum self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<float> hook_GenerateValues(orig_GenerateValues orig, DomainSum self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_AddSum(List<Domain> domainList, List<float> values, float total, int index);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_AddSum(orig_AddSum orig, List<Domain> domainList, List<float> values, float total, int index);

		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_GenerateValues GenerateValues
		{
			add
			{
				HookEndpointManager.Add<hook_GenerateValues>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GenerateValues>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerable<Guess> orig_ArcConsistency_IGuessable_GetGuesses(GuessableBool self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerable<Guess> hook_ArcConsistency_IGuessable_GetGuesses(orig_ArcConsistency_IGuessable_GetGuesses orig, GuessableBool self);

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

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

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate float orig_Evaluate(ExpressionSerialized self, float Random);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate float hook_Evaluate(orig_Evaluate orig, ExpressionSerialized self, float Random);

			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_Evaluate Evaluate
			{
				add
				{
					HookEndpointManager.Add<hook_Evaluate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_Evaluate>(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_ArcConsistency_IGuessable_GetGuesses ArcConsistency_IGuessable_GetGuesses
		{
			add
			{
				HookEndpointManager.Add<hook_ArcConsistency_IGuessable_GetGuesses>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ArcConsistency_IGuessable_GetGuesses>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL.ArcConsistency
{
	public static class GuessableBool
	{
		public static class Probability
		{
			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.ArcConsistency.GuessableBool.Probability.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.ArcConsistency.GuessableBool.Probability.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Setup(ArcRule1 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Setup(orig_Setup orig, ArcRule1 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Reset(ArcRule1 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Reset(orig_Reset orig, ArcRule1 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_Valid(ArcRule1 self, Domain domain, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_Valid(orig_Valid orig, ArcRule1 self, Domain domain, float value);

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

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

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate bool orig_Evaluate(ExpressionSerialized self, float A);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate bool hook_Evaluate(orig_Evaluate orig, ExpressionSerialized self, float A);

			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_Evaluate Evaluate
			{
				add
				{
					HookEndpointManager.Add<hook_Evaluate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_Evaluate>(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_Setup Setup
		{
			add
			{
				HookEndpointManager.Add<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Setup(ArcRule2 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Setup(orig_Setup orig, ArcRule2 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Reset(ArcRule2 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Reset(orig_Reset orig, ArcRule2 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_Valid(ArcRule2 self, Domain variable, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_Valid(orig_Valid orig, ArcRule2 self, Domain variable, float value);

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

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

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate bool orig_Evaluate(ExpressionSerialized self, float A, float B);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate bool hook_Evaluate(orig_Evaluate orig, ExpressionSerialized self, float A, float B);

			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_Evaluate Evaluate
			{
				add
				{
					HookEndpointManager.Add<hook_Evaluate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_Evaluate>(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_Setup Setup
		{
			add
			{
				HookEndpointManager.Add<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Setup(ArcRule3 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Setup(orig_Setup orig, ArcRule3 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Reset(ArcRule3 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Reset(orig_Reset orig, ArcRule3 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_Valid(ArcRule3 self, Domain variable, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_Valid(orig_Valid orig, ArcRule3 self, Domain variable, float value);

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

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

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate bool orig_Evaluate(ExpressionSerialized self, float A, float B, float C);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate bool hook_Evaluate(orig_Evaluate orig, ExpressionSerialized self, float A, float B, float C);

			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_Evaluate Evaluate
			{
				add
				{
					HookEndpointManager.Add<hook_Evaluate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_Evaluate>(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_Setup Setup
		{
			add
			{
				HookEndpointManager.Add<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Setup(ArcRuleN self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Setup(orig_Setup orig, ArcRuleN self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_Valid(ArcRuleN self, Domain variable, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_Valid(orig_Valid orig, ArcRuleN self, Domain variable, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_TryHitSum(ArcRuleN self, Domain variableOverride, float valueOverride, List<Domain> list, float total, int index);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_TryHitSum(orig_TryHitSum orig, ArcRuleN self, Domain variableOverride, float valueOverride, List<Domain> list, float total, int index);

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

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

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate float orig_Evaluate(ExpressionSerialized self, float Total, float Value);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate float hook_Evaluate(orig_Evaluate orig, ExpressionSerialized self, float Total, float 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_Evaluate Evaluate
			{
				add
				{
					HookEndpointManager.Add<hook_Evaluate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_Evaluate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}
		}

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

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

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate bool orig_Evaluate(ExpressionSerialized self, float Total, float Count);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate bool hook_Evaluate(orig_Evaluate orig, ExpressionSerialized self, float Total, float Count);

			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_Evaluate Evaluate
			{
				add
				{
					HookEndpointManager.Add<hook_Evaluate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_Evaluate>(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_Setup Setup
		{
			add
			{
				HookEndpointManager.Add<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

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

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

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Setup(ArcRuleN1 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Setup(orig_Setup orig, ArcRuleN1 self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_Valid(ArcRuleN1 self, Domain variable, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_Valid(orig_Valid orig, ArcRuleN1 self, Domain variable, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_TryHitSum(ArcRuleN1 self, Domain variableOverride, float valueOverride, List<Domain> list, float A, float sum, int index);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_TryHitSum(orig_TryHitSum orig, ArcRuleN1 self, Domain variableOverride, float valueOverride, List<Domain> list, float A, float sum, int index);

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

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

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate float orig_Evaluate(ExpressionSerialized self, float A, float Total, float Variable);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate float hook_Evaluate(orig_Evaluate orig, ExpressionSerialized self, float A, float Total, float Variable);

			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_Evaluate Evaluate
			{
				add
				{
					HookEndpointManager.Add<hook_Evaluate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_Evaluate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}
		}

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

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

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate bool orig_Evaluate(ExpressionSerialized self, float A, float Total, float Count);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate bool hook_Evaluate(orig_Evaluate orig, ExpressionSerialized self, float A, float Total, float Count);

			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_Evaluate Evaluate
			{
				add
				{
					HookEndpointManager.Add<hook_Evaluate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_Evaluate>(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_Setup Setup
		{
			add
			{
				HookEndpointManager.Add<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

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

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

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Setup(ArcRuleRelation self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Setup(orig_Setup orig, ArcRuleRelation self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_Valid(ArcRuleRelation self, Domain domain, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_Valid(orig_Valid orig, ArcRuleRelation self, Domain domain, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_<Valid>m__0(float x);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_<Valid>m__0(orig_<Valid>m__0 orig, float x);

		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_Setup Setup
		{
			add
			{
				HookEndpointManager.Add<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

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

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

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

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

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

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Setup(ArcRuleSum self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Setup(orig_Setup orig, ArcRuleSum self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_Valid(ArcRuleSum self, Domain variable, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_Valid(orig_Valid orig, ArcRuleSum self, Domain variable, float value);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_TryHitSum(Domain variableOverride, float valueOverride, List<Domain> list, float target, float total, int index);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_TryHitSum(orig_TryHitSum orig, Domain variableOverride, float valueOverride, List<Domain> list, float target, float total, int index);

		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_Setup Setup
		{
			add
			{
				HookEndpointManager.Add<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Setup>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

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

		public static event hook_TryHitSum TryHitSum
		{
			add
			{
				HookEndpointManager.Add<hook_TryHitSum>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_TryHitSum>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemb
Get the Thunderstore App

Decompiled source of MMHOOK Assembly v1.0.0

MMHOOK-Assembly-CSharp.dll

About

Developers
