Decompiled source of Lightless v0.2.0

plugins/sombraSoft.Lightless.dll

Decompiled 4 hours ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using Lightless.Airport;
using Lightless.Darkness;
using Lightless.Dread;
using Lightless.Fear;
using Lightless.Items;
using Lightless.Lighting;
using Lightless.Loadout;
using Lightless.Models;
using Lightless.Refills;
using Lightless.Stalker;
using Md.AirportCheckInKiosk;
using Md.AmbienceManager;
using Md.Character;
using Md.DayNightManager;
using Md.GUIManager;
using Md.Item;
using Md.Lantern;
using Microsoft.CodeAnalysis;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using PEAKLib.Core;
using PEAKLib.Items;
using Peak;
using Peak.Network;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("sombraSoft.Lightless")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.0.0")]
[assembly: AssemblyInformationalVersion("0.2.0+b64936a682c72dca78166893695d88cea1ce995a")]
[assembly: AssemblyProduct("sombraSoft.Lightless")]
[assembly: AssemblyTitle("Lightless")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Md.GUIManager
{
	internal static class UpdateItemPrompts
	{
		public delegate void PrefixSignature(GUIManager self);

		public delegate void PostfixSignature(GUIManager self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(GUIManager);
			MethodInfo method = typeFromHandle.GetMethod("UpdateItemPrompts", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("GUIManager", "UpdateItemPrompts");
			}
			return method;
		}
	}
	internal static class RefreshInteractablePrompt
	{
		public delegate void PrefixSignature(GUIManager self);

		public delegate void PostfixSignature(GUIManager self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(GUIManager);
			MethodInfo method = typeFromHandle.GetMethod("RefreshInteractablePrompt", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("GUIManager", "RefreshInteractablePrompt");
			}
			return method;
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(GUIManager self);

		public delegate void PostfixSignature(GUIManager self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(GUIManager);
			MethodInfo method = typeFromHandle.GetMethod("Start", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("GUIManager", "Start");
			}
			return method;
		}
	}
	internal static class get_wheelActive
	{
	}
	internal static class get_currentInteractable
	{
	}
	internal static class set_currentInteractable
	{
	}
	internal static class get_controllerManager
	{
	}
	internal static class set_controllerManager
	{
	}
	internal static class get_InPauseMenu
	{
	}
	internal static class get_TimeLastPaused
	{
	}
	internal static class set_TimeLastPaused
	{
	}
	internal static class Awake
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class NicksUIFix
	{
	}
	internal static class LateUpdate
	{
	}
	internal static class get_windowShowingCursor
	{
	}
	internal static class set_windowShowingCursor
	{
	}
	internal static class get_windowBlockingInput
	{
	}
	internal static class set_windowBlockingInput
	{
	}
	internal static class UpdateWindowStatus
	{
	}
	internal static class UpdatePaused
	{
	}
	internal static class UpdateItemSelections
	{
	}
	internal static class OnUpdatedFeedData
	{
	}
	internal static class ForcePlayStinger
	{
	}
	internal static class SetHeroTitle
	{
	}
	internal static class OpenBackpackWheel
	{
	}
	internal static class CloseBackpackWheel
	{
	}
	internal static class get_canEmote
	{
	}
	internal static class UpdateEmoteWheel
	{
	}
	internal static class UpdateDyingBar
	{
	}
	internal static class UpdateSpectate
	{
	}
	internal static class UpdateRope
	{
	}
	internal static class UpdateWebs
	{
	}
	internal static class UpdateThrow
	{
	}
	internal static class UpdateReticle
	{
	}
	internal static class ReticleLand
	{
	}
	internal static class Grasp
	{
	}
	internal static class ClimbJump
	{
	}
	internal static class SetReticle
	{
	}
	internal static class InitReticleList
	{
	}
	internal static class UpdateDebug
	{
	}
	internal static class ScreenshotRoutine
	{
	}
	internal static class AddStatusFX
	{
	}
	internal static class InjuryFX
	{
	}
	internal static class CurseFX
	{
	}
	internal static class HungerFX
	{
	}
	internal static class DrowsyFX
	{
	}
	internal static class PoisonFX
	{
	}
	internal static class ThornsFX
	{
	}
	internal static class SporesFX
	{
	}
	internal static class PlayPertrifyFX
	{
	}
	internal static class PlayPertrifyFullFX
	{
	}
	internal static class ColdFX
	{
	}
	internal static class HotFX
	{
	}
	internal static class PlayFXSequence
	{
	}
	internal static class StartSugarRush
	{
	}
	internal static class EndSugarRush
	{
	}
	internal static class StartEnergyDrink
	{
	}
	internal static class EndEnergyDrink
	{
	}
	internal static class HeatFX
	{
	}
	internal static class StartHeat
	{
	}
	internal static class EndHeat
	{
	}
	internal static class StartSunscreen
	{
	}
	internal static class EndSunscreen
	{
	}
	internal static class StartAnti
	{
	}
	internal static class EndAnti
	{
	}
	internal static class OnInteractChange
	{
	}
	internal static class EnableBinocularOverlay
	{
	}
	internal static class UpdateBinocularOverlay
	{
	}
	internal static class BlurBinoculars
	{
	}
	internal static class UpdateItems
	{
	}
	internal static class PlayDayNightText
	{
	}
	internal static class TestUpdateItemPrompts
	{
	}
	internal static class TheFogRises
	{
	}
	internal static class TheLavaRises
	{
	}
	internal static class TheGloomRises
	{
	}
	internal static class TheGhostsRise
	{
	}
	internal static class GetMainInteractPrompt
	{
	}
	internal static class GetSecondaryInteractPrompt
	{
	}
	internal static class StartNumb
	{
	}
	internal static class StopNumb
	{
	}
	internal static class Quicksave
	{
	}
	internal static class EndQuicksave
	{
	}
	internal static class _ctor
	{
	}
	internal static class MenuWindowEvent
	{
		internal static class _ctor
		{
		}

		internal static class Invoke
		{
		}

		internal static class BeginInvoke
		{
		}

		internal static class EndInvoke
		{
		}
	}
	internal static class __TheFogRises_g__FogRisesRoutine_220_0_d
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class __TheGhostsRise_g__FogRisesRoutine_223_0_d
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class __TheGloomRises_g__FogRisesRoutine_222_0_d
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class __TheLavaRises_g__FogRisesRoutine_221_0_d
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class __c__DisplayClass153_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass153_1
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass153_2
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass155_0
	{
		internal static class _ctor
		{
		}

		internal static class __SetHeroTitle_g__HeroRoutine_0_d
		{
			internal static class _ctor
			{
			}

			internal static class System_IDisposable_Dispose
			{
			}

			internal static class MoveNext
			{
			}

			internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
			{
			}

			internal static class System_Collections_IEnumerator_Reset
			{
			}

			internal static class System_Collections_IEnumerator_get_Current
			{
			}
		}
	}
	internal static class __c__DisplayClass196_0
	{
		internal static class _ctor
		{
		}
	}
	internal static class _ScreenshotRoutine_d__179
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
}
namespace Md.AirportCheckInKiosk
{
	internal static class Center
	{
		public delegate void PrefixSignature(AirportCheckInKiosk self);

		public delegate void PostfixSignature(AirportCheckInKiosk self, ref Vector3 returnValue);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(AirportCheckInKiosk);
			MethodInfo method = typeFromHandle.GetMethod("Center", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("AirportCheckInKiosk", "Center");
			}
			return method;
		}
	}
	internal static class BeginIslandLoadRPC
	{
		public delegate void PrefixSignature(AirportCheckInKiosk self, ref string sceneName, ref int ascent, ref byte[] serializedRunSettings);

		public delegate void PostfixSignature(AirportCheckInKiosk self, ref string sceneName, ref int ascent, ref byte[] serializedRunSettings);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(AirportCheckInKiosk);
			MethodInfo method = typeFromHandle.GetMethod("BeginIslandLoadRPC", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(string),
				typeof(int),
				typeof(byte[])
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("AirportCheckInKiosk", "BeginIslandLoadRPC");
			}
			return method;
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(AirportCheckInKiosk self);

		public delegate void PostfixSignature(AirportCheckInKiosk self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(AirportCheckInKiosk);
			MethodInfo method = typeFromHandle.GetMethod("Start", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("AirportCheckInKiosk", "Start");
			}
			return method;
		}
	}
	internal static class GetName
	{
		public delegate void PrefixSignature(AirportCheckInKiosk self);

		public delegate void PostfixSignature(AirportCheckInKiosk self, ref string returnValue);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(AirportCheckInKiosk);
			MethodInfo method = typeFromHandle.GetMethod("GetName", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("AirportCheckInKiosk", "GetName");
			}
			return method;
		}
	}
	internal static class IsInteractible
	{
	}
	internal static class Awake
	{
	}
	internal static class Interact
	{
	}
	internal static class get_meshRenderers
	{
	}
	internal static class set_meshRenderers
	{
	}
	internal static class HoverEnter
	{
	}
	internal static class HoverExit
	{
	}
	internal static class GetTransform
	{
	}
	internal static class GetInteractionText
	{
	}
	internal static class IsConstantlyInteractable
	{
	}
	internal static class GetInteractTime
	{
	}
	internal static class Interact_CastFinished
	{
	}
	internal static class StartGame
	{
	}
	internal static class CancelCast
	{
	}
	internal static class ReleaseInteract
	{
	}
	internal static class LoadIslandMaster
	{
	}
	internal static class get_holdOnFinish
	{
	}
	internal static class _ctor
	{
	}
}
namespace Md.AmbienceManager
{
	internal static class Update
	{
		public delegate void PrefixSignature(AmbienceManager self);

		public delegate void PostfixSignature(AmbienceManager self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(AmbienceManager);
			MethodInfo method = typeFromHandle.GetMethod("Update", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("AmbienceManager", "Update");
			}
			return method;
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(AmbienceManager self);

		public delegate void PostfixSignature(AmbienceManager self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(AmbienceManager);
			MethodInfo method = typeFromHandle.GetMethod("Start", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("AmbienceManager", "Start");
			}
			return method;
		}
	}
	internal static class Awake
	{
	}
	internal static class OnValidate
	{
	}
	internal static class UpdateFog
	{
	}
	internal static class ToggleFog
	{
	}
	internal static class _ctor
	{
	}
}
namespace Md.DayNightManager
{
	internal static class Update
	{
		public delegate void PrefixSignature(DayNightManager self);

		public delegate void PostfixSignature(DayNightManager self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(DayNightManager);
			MethodInfo method = typeFromHandle.GetMethod("Update", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("DayNightManager", "Update");
			}
			return method;
		}
	}
	internal static class UpdateCycle
	{
		public delegate void PrefixSignature(DayNightManager self);

		public delegate void PostfixSignature(DayNightManager self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(DayNightManager);
			MethodInfo method = typeFromHandle.GetMethod("UpdateCycle", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("DayNightManager", "UpdateCycle");
			}
			return method;
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(DayNightManager self);

		public delegate void PostfixSignature(DayNightManager self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(DayNightManager);
			MethodInfo method = typeFromHandle.GetMethod("Start", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("DayNightManager", "Start");
			}
			return method;
		}
	}
	internal static class getShaderValue
	{
	}
	internal static class clearAllShaderParams
	{
	}
	internal static class get_timeOfDayNormalized
	{
	}
	internal static class get_isDay
	{
	}
	internal static class get_dayNightBlend
	{
	}
	internal static class Awake
	{
	}
	internal static class BlendProfiles
	{
	}
	internal static class SetTimeOfDay
	{
	}
	internal static class setTimeOfDay
	{
	}
	internal static class DayCountString
	{
	}
	internal static class TimeOfDayString
	{
	}
	internal static class IntToNumberWord
	{
	}
	internal static class FloatToTimeString
	{
	}
	internal static class RPCA_SyncTime
	{
	}
	internal static class OnValidate
	{
	}
	internal static class OnDisable
	{
	}
	internal static class OnDrawGizmosSelected
	{
	}
	internal static class _ctor
	{
	}
	internal static class ShaderParams
	{
		internal static class _ctor
		{
		}
	}
	internal static class ShaderParameters
	{
		internal static class _ctor
		{
		}
	}
	internal static class __c__DisplayClass47_0
	{
		internal static class _ctor
		{
		}

		internal static class __BlendProfiles_g__blendRoutine_0_d
		{
			internal static class _ctor
			{
			}

			internal static class System_IDisposable_Dispose
			{
			}

			internal static class MoveNext
			{
			}

			internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
			{
			}

			internal static class System_Collections_IEnumerator_Reset
			{
			}

			internal static class System_Collections_IEnumerator_get_Current
			{
			}
		}
	}
}
namespace Md.Lantern
{
	internal static class Update
	{
		public delegate void PrefixSignature(Lantern self);

		public delegate void PostfixSignature(Lantern self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Lantern);
			MethodInfo method = typeFromHandle.GetMethod("Update", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Lantern", "Update");
			}
			return method;
		}
	}
	internal static class SnuffLantern
	{
		public delegate void PrefixSignature(Lantern self);

		public delegate void PostfixSignature(Lantern self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Lantern);
			MethodInfo method = typeFromHandle.GetMethod("SnuffLantern", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Lantern", "SnuffLantern");
			}
			return method;
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(Lantern self);

		public delegate void PostfixSignature(Lantern self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Lantern);
			MethodInfo method = typeFromHandle.GetMethod("Start", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Lantern", "Start");
			}
			return method;
		}
	}
	internal static class get_lit
	{
	}
	internal static class set_lit
	{
	}
	internal static class Awake
	{
	}
	internal static class OnEnable
	{
	}
	internal static class OnDisable
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class OnInstanceDataSet
	{
	}
	internal static class UpdateFuel
	{
	}
	internal static class SetupDefaultFuel
	{
	}
	internal static class ToggleLantern
	{
	}
	internal static class LightLantern
	{
	}
	internal static class OnPhotonSerializeView
	{
	}
	internal static class _ctor
	{
	}
}
namespace Md.Item
{
	internal static class Update
	{
		public delegate void PrefixSignature(Item self);

		public delegate void PostfixSignature(Item self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Item);
			MethodInfo method = typeFromHandle.GetMethod("Update", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Item", "Update");
			}
			return method;
		}
	}
	internal static class Center
	{
		public delegate void PrefixSignature(Item self);

		public delegate void PostfixSignature(Item self, ref Vector3 returnValue);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Item);
			MethodInfo method = typeFromHandle.GetMethod("Center", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Item", "Center");
			}
			return method;
		}
	}
	internal static class GetItemName
	{
		public delegate void PrefixSignature(Item self, ref ItemInstanceData data);

		public delegate void PostfixSignature(Item self, ref ItemInstanceData data, ref string returnValue);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Item);
			MethodInfo method = typeFromHandle.GetMethod("GetItemName", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(ItemInstanceData) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Item", "GetItemName");
			}
			return method;
		}
	}
	internal static class FinishCastPrimary
	{
		public delegate void PrefixSignature(Item self);

		public delegate void PostfixSignature(Item self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Item);
			MethodInfo method = typeFromHandle.GetMethod("FinishCastPrimary", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Item", "FinishCastPrimary");
			}
			return method;
		}
	}
	internal static class HasData
	{
		public delegate void PrefixSignature(Item self, ref DataEntryKey key);

		public delegate void PostfixSignature(Item self, ref DataEntryKey key, ref bool returnValue);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Item);
			MethodInfo method = typeFromHandle.GetMethod("HasData", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(DataEntryKey) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Item", "HasData");
			}
			return method;
		}
	}
	internal static class TryGetItemFromCollider
	{
		public delegate void PrefixSignature(ref Collider collider, ref Item result);

		public delegate void PostfixSignature(ref Collider collider, ref Item result, ref bool returnValue);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Item);
			MethodInfo method = typeFromHandle.GetMethod("TryGetItemFromCollider", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(Collider),
				typeof(Item).MakeByRefType()
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Item", "TryGetItemFromCollider");
			}
			return method;
		}
	}
	internal static class SetUseRemainingPercentage
	{
		public delegate void PrefixSignature(Item self, ref float percentage);

		public delegate void PostfixSignature(Item self, ref float percentage);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Item);
			MethodInfo method = typeFromHandle.GetMethod("SetUseRemainingPercentage", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(float) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Item", "SetUseRemainingPercentage");
			}
			return method;
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(Item self);

		public delegate void PostfixSignature(Item self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Item);
			MethodInfo method = typeFromHandle.GetMethod("Start", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Item", "Start");
			}
			return method;
		}
	}
	internal static class GetName
	{
		public delegate void PrefixSignature(Item self);

		public delegate void PostfixSignature(Item self, ref string returnValue);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Item);
			MethodInfo method = typeFromHandle.GetMethod("GetName", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Item", "GetName");
			}
			return method;
		}
	}
	internal static class get_itemState
	{
	}
	internal static class set_itemState
	{
	}
	internal static class get_CarryWeight
	{
	}
	internal static class get_isUsingPrimary
	{
	}
	internal static class set_isUsingPrimary
	{
	}
	internal static class get_HasInstanceData
	{
	}
	internal static class get_cooking
	{
	}
	internal static class set_cooking
	{
	}
	internal static class OnEnable
	{
	}
	internal static class OnDisable
	{
	}
	internal static class Awake
	{
	}
	internal static class RegisterItem
	{
	}
	internal static class DeregisterItem
	{
	}
	internal static class AddPropertyBlock
	{
	}
	internal static class GetItemActions
	{
	}
	internal static class AddPhysics
	{
	}
	internal static class get_transform
	{
	}
	internal static class UpdateCollisionDetectionMode
	{
	}
	internal static class Interact
	{
	}
	internal static class DenyPickupRPC
	{
	}
	internal static class RequestPickup
	{
	}
	internal static class ClearDataFromBackpack
	{
	}
	internal static class GetTransform
	{
	}
	internal static class GetInteractionText
	{
	}
	internal static class IsInteractible
	{
	}
	internal static class Move
	{
	}
	internal static class get_holderCharacter
	{
	}
	internal static class set_holderCharacter
	{
	}
	internal static class get_trueHolderCharacter
	{
	}
	internal static class SetColliders
	{
	}
	internal static class SetState
	{
	}
	internal static class HideRenderers
	{
	}
	internal static class get_isUsingSecondary
	{
	}
	internal static class set_isUsingSecondary
	{
	}
	internal static class get_castProgress
	{
	}
	internal static class set_castProgress
	{
	}
	internal static class get_progress
	{
	}
	internal static class get_shouldShowCastProgress
	{
	}
	internal static class CanUsePrimary
	{
	}
	internal static class get_raycastingCharacter
	{
	}
	internal static class set_raycastingCharacter
	{
	}
	internal static class CanUseSecondary
	{
	}
	internal static class StartUsePrimary
	{
	}
	internal static class ContinueUsePrimary
	{
	}
	internal static class CancelUsePrimary
	{
	}
	internal static class ScrollButtonBackwardPressed
	{
	}
	internal static class ScrollButtonForwardPressed
	{
	}
	internal static class ScrollButtonBackwardHeld
	{
	}
	internal static class ScrollButtonForwardHeld
	{
	}
	internal static class Scroll
	{
	}
	internal static class StartUseSecondary
	{
	}
	internal static class SendFeedDataRPC
	{
	}
	internal static class RemoveFeedDataRPC
	{
	}
	internal static class get_totalSecondaryUsingTime
	{
	}
	internal static class ContinueUseSecondary
	{
	}
	internal static class FinishCastSecondary
	{
	}
	internal static class CancelUseSecondary
	{
	}
	internal static class get_consuming
	{
	}
	internal static class set_consuming
	{
	}
	internal static class ConsumeDelayed
	{
	}
	internal static class Consume
	{
	}
	internal static class OnStash
	{
	}
	internal static class AddDefaultFoodScripts
	{
	}
	internal static class HoverEnter
	{
	}
	internal static class HoverExit
	{
	}
	internal static class SetKinematic
	{
	}
	internal static class SetKinematicNetworked_System_Boolean
	{
	}
	internal static class SetKinematicNetworked_System_Boolean_UnityEngine_Vector3_UnityEngine_Quaternion
	{
	}
	internal static class SetKinematicAndResetSyncData
	{
	}
	internal static class SetKinematicRPC
	{
	}
	internal static class ApplyForceRPC
	{
	}
	internal static class ForceSyncForFrames
	{
	}
	internal static class SetItemInstanceDataRPC
	{
	}
	internal static class OnInstanceDataRecieved
	{
	}
	internal static class OnPlayerEnteredRoom
	{
	}
	internal static class PutInBackpackRPC
	{
	}
	internal static class SetCookedAmountRPC
	{
	}
	internal static class get_inActiveList
	{
	}
	internal static class set_inActiveList
	{
	}
	internal static class WasActive
	{
	}
	internal static class UpdateEntryInActiveList
	{
	}
	internal static class RemoveFromActiveList
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class RPC_Clone
	{
	}
	internal static class TryGetFeeder
	{
	}
	internal static class IsValidToSpawn
	{
	}
	internal static class AddNameToCSV
	{
	}
	internal static class AddPromptToCSV
	{
	}
	internal static class RPC_SetThrownData
	{
	}
	internal static class get_antigrav
	{
	}
	internal static class set_antigrav
	{
	}
	internal static class _ctor
	{
	}
	internal static class ItemTags
	{
		internal static class _ctor
		{
		}
	}
	internal static class ItemUIData
	{
		internal static class GetIcon
		{
		}

		internal static class _ctor
		{
		}
	}
	internal static class __Awake_g__DefaultPosRoutine_86_0_d
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class __c
	{
		internal static class _ctor
		{
		}
	}
	internal static class _ConsumeDelayed_d__174
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
}
namespace Md.Character
{
	internal static class Update
	{
		public delegate void PrefixSignature(Character self);

		public delegate void PostfixSignature(Character self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Character);
			MethodInfo method = typeFromHandle.GetMethod("Update", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Character", "Update");
			}
			return method;
		}
	}
	internal static class Fall
	{
		public delegate void PrefixSignature(Character self, ref float seconds, ref float screenShake);

		public delegate void PostfixSignature(Character self, ref float seconds, ref float screenShake);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Character);
			MethodInfo method = typeFromHandle.GetMethod("Fall", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(float),
				typeof(float)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Character", "Fall");
			}
			return method;
		}
	}
	internal static class GetBodypartRig
	{
		public delegate void PrefixSignature(Character self, ref BodypartType head);

		public delegate void PostfixSignature(Character self, ref BodypartType head, ref Rigidbody returnValue);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Character);
			MethodInfo method = typeFromHandle.GetMethod("GetBodypartRig", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(BodypartType) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Character", "GetBodypartRig");
			}
			return method;
		}
	}
	internal static class RPCA_ReviveAtPosition
	{
		public delegate void PrefixSignature(Character self, ref Vector3 position, ref bool applyStatus, ref int statueSegment);

		public delegate void PostfixSignature(Character self, ref Vector3 position, ref bool applyStatus, ref int statueSegment);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Character);
			MethodInfo method = typeFromHandle.GetMethod("RPCA_ReviveAtPosition", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(Vector3),
				typeof(bool),
				typeof(int)
			}, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Character", "RPCA_ReviveAtPosition");
			}
			return method;
		}
	}
	internal static class UpdateVariablesFixed
	{
		public delegate void PrefixSignature(Character self);

		public delegate void PostfixSignature(Character self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Character);
			MethodInfo method = typeFromHandle.GetMethod("UpdateVariablesFixed", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Character", "UpdateVariablesFixed");
			}
			return method;
		}
	}
	internal static class Start
	{
		public delegate void PrefixSignature(Character self);

		public delegate void PostfixSignature(Character self);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Character);
			MethodInfo method = typeFromHandle.GetMethod("Start", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Character", "Start");
			}
			return method;
		}
	}
	internal static class GetBodypart
	{
		public delegate void PrefixSignature(Character self, ref BodypartType head);

		public delegate void PostfixSignature(Character self, ref BodypartType head, ref Bodypart returnValue);

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

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

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

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(Character);
			MethodInfo method = typeFromHandle.GetMethod("GetBodypart", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(BodypartType) }, null);
			if ((object)method == null)
			{
				throw new MissingMethodException("Character", "GetBodypart");
			}
			return method;
		}
	}
	internal static class get_IsPlayerControlled
	{
	}
	internal static class get_localCharacterExists
	{
	}
	internal static class get_player
	{
	}
	internal static class get_observedCharacter
	{
	}
	internal static class get_inAirport
	{
	}
	internal static class get_Ghost
	{
	}
	internal static class set_Ghost
	{
	}
	internal static class get_IsGhost
	{
	}
	internal static class get_IsRegisteredToPlayer
	{
	}
	internal static class get_IsLocal
	{
	}
	internal static class get_IsObserved
	{
	}
	internal static class get_IsInitialized
	{
	}
	internal static class get_VirtualCenter
	{
	}
	internal static class get_Center
	{
	}
	internal static class get_Head
	{
	}
	internal static class get_characterName
	{
	}
	internal static class set_characterName
	{
	}
	internal static class GetCharacterWithPhotonID
	{
	}
	internal static class OnDestroy
	{
	}
	internal static class Awake
	{
	}
	internal static class InitializeRefs
	{
	}
	internal static class BreakCharacterCarrying
	{
	}
	internal static class DropCarriedCharacter
	{
	}
	internal static class SetDeadAfterReconnect
	{
	}
	internal static class get_LastLivingPosition
	{
	}
	internal static class set_LastLivingPosition
	{
	}
	internal static class GetSpectatePosition
	{
	}
	internal static class AddForceAtPosition
	{
	}
	internal static class RPCA_AddForceAtPosition
	{
	}
	internal static class GainFullStamina
	{
	}
	internal static class CreateHelperObjects
	{
	}
	internal static class OnAddedStatus
	{
	}
	internal static class UpdateVariables
	{
	}
	internal static class DeathPos
	{
	}
	internal static class HandleDeath
	{
	}
	internal static class HandlePassedOut
	{
	}
	internal static class ZombieFailsafe
	{
	}
	internal static class WillDoCheckpoint
	{
	}
	internal static class TryCheckpoint
	{
	}
	internal static class RegainItems
	{
	}
	internal static class Die
	{
	}
	internal static class DieInstantly
	{
	}
	internal static class DieInstantlyLocal
	{
	}
	internal static class RPCA_SetDead
	{
	}
	internal static class SetDead
	{
	}
	internal static class CouldBeEatenBy
	{
	}
	internal static class RPCA_Die
	{
	}
	internal static class GoDeadMode
	{
	}
	internal static class SpawnSkeletonOnDeath
	{
	}
	internal static class SpawnStatue
	{
	}
	internal static class Zombify
	{
	}
	internal static class TestWarp
	{
	}
	internal static class RPCA_Zombify
	{
	}
	internal static class FinishZombifying
	{
	}
	internal static class CheckEndGame
	{
	}
	internal static class TestWin
	{
	}
	internal static class EndGame
	{
	}
	internal static class RPCA_SyncScoutReport
	{
	}
	internal static class RPCA_InitializeScoutReport
	{
	}
	internal static class RPCEndGame_ForceWin
	{
	}
	internal static class RPCEndGame
	{
	}
	internal static class CheckWinCondition
	{
	}
	internal static class RPCA_UnPassOut
	{
	}
	internal static class UnPassOutDone
	{
	}
	internal static class PassOut
	{
	}
	internal static class RPCA_PassOut
	{
	}
	internal static class HandlePetrifyVisualsRemote
	{
	}
	internal static class HandleLife
	{
	}
	internal static class PassOutInstantly
	{
	}
	internal static class FixedUpdate
	{
	}
	internal static class NobodyIsAlive
	{
	}
	internal static class HasMeaningfulTempStatuses
	{
	}
	internal static class CanRegenStamina
	{
	}
	internal static class GetTotalStamina
	{
	}
	internal static class CalculateWorldMovementDir
	{
	}
	internal static class RecalculateLookDirections
	{
	}
	internal static class GetCameraPos
	{
	}
	internal static class GetAnimationRelativePosition
	{
	}
	internal static class OnLand
	{
	}
	internal static class OnStartJump
	{
	}
	internal static class OnJump
	{
	}
	internal static class OnStartClimb
	{
	}
	internal static class HipPos
	{
	}
	internal static class TorsoPos
	{
	}
	internal static class AddForce_UnityEngine_Vector3_System_Single_System_Single
	{
	}
	internal static class CheckStand
	{
	}
	internal static class CheckGravity
	{
	}
	internal static class CheckMovement
	{
	}
	internal static class CheckJump
	{
	}
	internal static class CheckSprint
	{
	}
	internal static class SetRotation
	{
	}
	internal static class UseStamina
	{
	}
	internal static class MoraleBoost
	{
	}
	internal static class AddStamina
	{
	}
	internal static class ClampStamina
	{
	}
	internal static class GetMaxStamina
	{
	}
	internal static class SetExtraStamina
	{
	}
	internal static class AddExtraStamina
	{
	}
	internal static class FeedItem
	{
	}
	internal static class GetFedItemRPC
	{
	}
	internal static class DragTowards
	{
	}
	internal static class OutOfStamina
	{
	}
	internal static class OutOfRegularStamina
	{
	}
	internal static class IsSliding
	{
	}
	internal static class CanDoInput
	{
	}
	internal static class GetPlayerListID
	{
	}
	internal static class RPCA_UnFall
	{
	}
	internal static class RPCA_Fall
	{
	}
	internal static class Revive
	{
	}
	internal static class ReviveCharacter
	{
	}
	internal static class ApplyPostReviveStatus
	{
	}
	internal static class WarpPlayerRPC
	{
	}
	internal static class PlayPoofVFX
	{
	}
	internal static class get_timeLastWarped
	{
	}
	internal static class set_timeLastWarped
	{
	}
	internal static class get_warping
	{
	}
	internal static class set_warping
	{
	}
	internal static class add_WarpCompleted
	{
	}
	internal static class remove_WarpCompleted
	{
	}
	internal static class TryWarpAgain
	{
	}
	internal static class WarpPlayer
	{
	}
	internal static class MoveBodypartTowardsPoint
	{
	}
	internal static class PlayerIsDeadOrDown
	{
	}
	internal static class GetPartType
	{
	}
	internal static class LimitFalling
	{
	}
	internal static class AddIllegalStatus
	{
	}
	internal static class get_infiniteStam
	{
	}
	internal static class set_infiniteStam
	{
	}
	internal static class InfiniteStamina
	{
	}
	internal static class get_statusesLocked
	{
	}
	internal static class set_statusesLocked
	{
	}
	internal static class LockStatuses
	{
	}
	internal static class OnGetMic
	{
	}
	internal static class StartPassedOutOnTheBeach
	{
	}
	internal static class TestSpawnChallengeItems
	{
	}
	internal static class AddForceToBodyPart
	{
	}
	internal static class RPCA_AddForceToBodyPart
	{
	}
	internal static class ClampSinceGrounded
	{
	}
	internal static class ClampRagdollControl
	{
	}
	internal static class HandleStickUpdate
	{
	}
	internal static class RPCA_ClearStickData
	{
	}
	internal static class RPCA_ClearJoint
	{
	}
	internal static class JumpStickEffect
	{
	}
	internal static class IsStuck
	{
	}
	internal static class TryStickBodypart
	{
	}
	internal static class RPCA_Stick
	{
	}
	internal static class UnStick
	{
	}
	internal static class RPCA_Unstick
	{
	}
	internal static class StickPartExists
	{
	}
	internal static class AddForce_System_Object
	{
	}
	internal static class RagdollExorcism
	{
	}
	internal static class WarpToSpawn
	{
	}
	internal static class TryGetGlobalPlayerData
	{
	}
	internal static class RPC_SetBlockedState
	{
	}
	internal static class _ctor
	{
	}
	internal static class CharacterRefs
	{
		internal static class _ctor
		{
		}
	}
	internal static class __RagdollExorcism_g__ForceRagdollToChill_224_0_d
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class __TestSpawnChallengeItems_g__SpawnChallengeItem_207_0_d
	{
		internal static class _ctor
		{
		}

		internal static class System_IDisposable_Dispose
		{
		}

		internal static class MoveNext
		{
		}

		internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
		{
		}

		internal static class System_Collections_IEnumerator_Reset
		{
		}

		internal static class System_Collections_IEnumerator_get_Current
		{
		}
	}
	internal static class __c__DisplayClass188_0
	{
		internal static class _ctor
		{
		}

		internal static class __WarpPlayer_g__IMove_0_d
		{
			internal static class _ctor
			{
			}

			internal static class System_IDisposable_Dispose
			{
			}

			internal static class MoveNext
			{
			}

			internal static class System_Collections_Generic_IEnumerator_System_Object__get_Current
			{
			}

			internal static class System_Collections_IEnumerator_Reset
			{
			}

			internal static class System_Collections_IEnumerator_get_Current
			{
			}
		}
	}
}
namespace MonoDetour.HookGen
{
	internal static class DefaultMonoDetourManager
	{
		internal static MonoDetourManager Instance { get; } = New();

		internal static MonoDetourManager New()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return new MonoDetourManager(typeof(DefaultMonoDetourManager).Assembly.GetName().Name);
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
	internal class MonoDetourTargetsAttribute(Type? targetType = null) : Attribute(), IMonoDetourTargets
	{
		public Type? TargetType { get; } = targetType;

		public bool IncludeNestedTypes { get; set; } = true;

		public string[]? Members { get; set; }

		public string[]? MemberNamePrefixes { get; set; }

		public string[]? MemberNameSuffixes { get; set; }

		public bool GenerateControlFlowVariants { get; set; }
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	[AttributeUsage(AttributeTargets.All)]
	[ExcludeFromCodeCoverage]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace Lightless
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("sombraSoft.Lightless", "Lightless", "0.2.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Id = "sombraSoft.Lightless";

		internal static ManualLogSource Log { get; private set; }

		internal static Settings Settings { get; private set; }

		public static string Name => "Lightless";

		public static string Version => "0.2.0";

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Settings = new Settings(((BaseUnityPlugin)this).Config);
			MonoDetourManager.InvokeHookInitializers(typeof(Plugin).Assembly);
			Flashlight.Register();
			RefillItems.Register();
			FuelSync.Listen();
			StalkerGrab.Listen();
			LanternSnuff.Listen();
			Log.LogInfo((object)("Plugin " + Name + " " + Version + " is loaded!"));
		}

		private void Update()
		{
			LanternFuel.Tick();
			LightPick.Tick();
			LightStand.Tick();
			StartingLight.Tick();
			StartingRefill.Tick();
			Flashlight.Tick();
			LightBudget.Tick();
			LitQuery.Tick();
			StowedLanterns.Tick();
			FearDriver.Tick();
			FearScreen.Tick();
			FearHeartbeat.Tick();
			FearShake.Tick();
			FearHud.Tick();
			DreadSounds.Tick();
			DreadEyes.Tick();
			FuelFlicker.Tick();
			Hunt.Tick();
			StalkerBrain.Tick();
			LanternSnuff.Tick();
			StalkerCall.Tick();
			StalkerSteps.Tick();
			StalkerScare.Tick();
			FireGlow.Tick();
			HeldLanternGlare.Tick();
			ScoutShade.Tick();
			MusicMute.Tick();
			AirportLamps.Tick();
			AirportDrone.Tick();
			RefillItems.Tick();
			RefillUse.Tick();
			CampfireRecharge.Tick();
			FuelSync.Tick();
		}

		private void OnDestroy()
		{
			DefaultMonoDetourManager.Instance.Dispose();
			FearDriver.Restore();
			FearScreen.Restore();
			FearHeartbeat.Restore();
			FearShake.Restore();
			FearHud.Restore();
			DreadSounds.Restore();
			DreadEyes.Restore();
			FuelFlicker.Restore();
			StalkerBrain.Restore();
			StalkerCall.Restore();
			StalkerSteps.Restore();
			StalkerScare.Restore();
			StalkerGrab.Restore();
			LanternSnuff.Restore();
			Hunt.Restore();
			NightOverride.Restore();
			MusicMute.Restore();
			AirportLamps.Restore();
			AirportDrone.Restore();
			LightBudget.Restore();
			ScoutShade.Restore();
			FireGlow.Restore();
			StowedLanterns.Restore();
			HeldLanternGlare.Restore();
			LanternFuel.Restore();
			LightStand.Restore();
			StartingRefill.Restore();
			LightPick.Restore();
			ItemModels.Release();
			Flashlight.Release();
			RefillUse.Restore();
			CampfireRecharge.Restore();
			FuelSync.Restore();
			RefillItems.Release();
			Log.LogInfo((object)("Plugin " + Name + " " + Version + " unloaded!"));
		}
	}
	internal sealed class Settings
	{
		public ConfigEntry<bool> DarknessEnabled { get; }

		public ConfigEntry<float> MoonIntensity { get; }

		public ConfigEntry<Color> MoonColor { get; }

		public ConfigEntry<float> MoonPitch { get; }

		public ConfigEntry<float> MoonYaw { get; }

		public ConfigEntry<float> SkyBrightness { get; }

		public ConfigEntry<Color> SkyTopTint { get; }

		public ConfigEntry<Color> SkyMidTint { get; }

		public ConfigEntry<Color> SkyBottomTint { get; }

		public ConfigEntry<float> AmbientBrightness { get; }

		public ConfigEntry<Color> AmbientColor { get; }

		public ConfigEntry<float> BakedLightScale { get; }

		public ConfigEntry<float> UnlitScoutBrightness { get; }

		public ConfigEntry<float> FireGlowIntensity { get; }

		public ConfigEntry<float> FireGlowRangeScale { get; }

		public ConfigEntry<bool> HideHeldLanternGlare { get; }

		public ConfigEntry<bool> MuteGameMusic { get; }

		public ConfigEntry<bool> AirportEnabled { get; }

		public ConfigEntry<float> AirportBrightness { get; }

		public ConfigEntry<float> AirportLampIntensity { get; }

		public ConfigEntry<float> AirportDroneVolume { get; }

		public ConfigEntry<bool> FearEnabled { get; }

		public ConfigEntry<float> FearSecondsToMax { get; }

		public ConfigEntry<float> FearSecondsToClear { get; }

		public ConfigEntry<float> FearUneasyAt { get; }

		public ConfigEntry<float> FearAfraidAt { get; }

		public ConfigEntry<float> FearVignetteIntensity { get; }

		public ConfigEntry<float> FearDesaturation { get; }

		public ConfigEntry<float> FearHeartbeatVolume { get; }

		public ConfigEntry<float> FearHeartbeatMinBpm { get; }

		public ConfigEntry<float> FearHeartbeatMaxBpm { get; }

		public ConfigEntry<float> FearShakeStrength { get; }

		public ConfigEntry<float> FearShakeInterval { get; }

		public ConfigEntry<float> FearStaminaRegenMultiplier { get; }

		public ConfigEntry<PanicReaction> FearPanicReaction { get; }

		public ConfigEntry<float> FearPanicCooldown { get; }

		public ConfigEntry<float> FearPanicFallback { get; }

		public ConfigEntry<float> FearPanicStumbleSeconds { get; }

		public ConfigEntry<float> FearPanicStumbleForce { get; }

		public ConfigEntry<bool> FearShowMeter { get; }

		public ConfigEntry<float> DebugForceFear { get; }

		public ConfigEntry<bool> GrantStartingLight { get; }

		public ConfigEntry<float> LanternFuelSeconds { get; }

		public ConfigEntry<bool> LanternStaysLitWhenStowed { get; }

		public ConfigEntry<float> StowedLanternReach { get; }

		public ConfigEntry<LightChoice> DefaultLight { get; }

		public ConfigEntry<bool> StandEnabled { get; }

		public ConfigEntry<float> StandRight { get; }

		public ConfigEntry<float> StandForward { get; }

		public ConfigEntry<float> StandYaw { get; }

		public ConfigEntry<float> FlashlightFuelSeconds { get; }

		public ConfigEntry<float> FlashlightRange { get; }

		public ConfigEntry<float> FlashlightThrow { get; }

		public ConfigEntry<float> FlashlightBeamWidth { get; }

		public ConfigEntry<float> FlashlightIntensity { get; }

		public ConfigEntry<float> FlashlightSpill { get; }

		public ConfigEntry<Color> FlashlightLightColor { get; }

		public ConfigEntry<float> FlashlightAimSmoothing { get; }

		public ConfigEntry<float> BatteriesRefill { get; }

		public ConfigEntry<float> LampOilRefill { get; }

		public ConfigEntry<Rarity> BatteriesRarity { get; }

		public ConfigEntry<Rarity> LampOilRarity { get; }

		public ConfigEntry<bool> CampfireRecharge { get; }

		public ConfigEntry<float> CampfireRechargeSeconds { get; }

		public ConfigEntry<bool> GrantStartingRefill { get; }

		public ConfigEntry<bool> StalkerEnabled { get; }

		public ConfigEntry<float> StalkerEncounterInterval { get; }

		public ConfigEntry<float> StalkerHuntedEncounterInterval { get; }

		public ConfigEntry<float> StalkerPanicsToGrab { get; }

		public ConfigEntry<float> StalkerAloneDistance { get; }

		public ConfigEntry<float> StalkerAloneSecondsToGrab { get; }

		public ConfigEntry<float> StalkerCampfireSecondsToClear { get; }

		public ConfigEntry<float> StalkerBeamSecondsToRetreat { get; }

		public ConfigEntry<float> StalkerGrabInjury { get; }

		public ConfigEntry<float> StalkerCallVolume { get; }

		public ConfigEntry<float> StalkerCloseCallFear { get; }

		public ConfigEntry<float> StalkerFlickerRadius { get; }

		public ConfigEntry<float> StalkerNearFearRadius { get; }

		public ConfigEntry<float> StalkerNearFearMultiplier { get; }

		public ConfigEntry<float> StalkerScareStrength { get; }

		public ConfigEntry<float> StalkerGrabChanceAtNoHunt { get; }

		public ConfigEntry<float> StalkerLitEncounterRate { get; }

		public ConfigEntry<float> StalkerSnuffSeconds { get; }

		public ConfigEntry<float> StalkerSnuffWarnSeconds { get; }

		public ConfigEntry<float> StalkerSnuffCooldown { get; }

		public ConfigEntry<float> StalkerStepVolume { get; }

		public ConfigEntry<bool> DreadSoundsEnabled { get; }

		public ConfigEntry<float> DreadSoundVolume { get; }

		public ConfigEntry<float> DreadSoundInterval { get; }

		public ConfigEntry<bool> DreadStalkerStepsEnabled { get; }

		public ConfigEntry<bool> DreadEyesEnabled { get; }

		public ConfigEntry<float> DreadEyesInterval { get; }

		public ConfigEntry<float> DreadEyesMinDistance { get; }

		public ConfigEntry<float> DreadEyesMaxDistance { get; }

		public ConfigEntry<bool> DreadFlickerEnabled { get; }

		public ConfigEntry<float> DreadFlickerBelowFuel { get; }

		public ConfigEntry<float> DreadFlickerDepth { get; }

		public Settings(ConfigFile config)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Expected O, but got Unknown
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Expected O, but got Unknown
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Expected O, but got Unknown
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Expected O, but got Unknown
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Expected O, but got Unknown
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Expected O, but got Unknown
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Expected O, but got Unknown
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Expected O, but got Unknown
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Expected O, but got Unknown
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Expected O, but got Unknown
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Expected O, but got Unknown
			//IL_0537: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Expected O, but got Unknown
			//IL_0570: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Expected O, but got Unknown
			//IL_05a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b3: Expected O, but got Unknown
			//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ec: Expected O, but got Unknown
			//IL_061b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0625: Expected O, but got Unknown
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			//IL_065e: Expected O, but got Unknown
			//IL_068d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0697: Expected O, but got Unknown
			//IL_06c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d0: Expected O, but got Unknown
			//IL_071b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0725: Expected O, but got Unknown
			//IL_0754: Unknown result type (might be due to invalid IL or missing references)
			//IL_075e: Expected O, but got Unknown
			//IL_078d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0797: Expected O, but got Unknown
			//IL_07c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d0: Expected O, but got Unknown
			//IL_081b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0825: Expected O, but got Unknown
			//IL_0870: Unknown result type (might be due to invalid IL or missing references)
			//IL_087a: Expected O, but got Unknown
			//IL_08c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cf: Expected O, but got Unknown
			//IL_0952: Unknown result type (might be due to invalid IL or missing references)
			//IL_095c: Expected O, but got Unknown
			//IL_098b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0995: Expected O, but got Unknown
			//IL_09c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ce: Expected O, but got Unknown
			//IL_09fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a07: Expected O, but got Unknown
			//IL_0a36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a40: Expected O, but got Unknown
			//IL_0a6f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a79: Expected O, but got Unknown
			//IL_0aa8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab2: Expected O, but got Unknown
			//IL_0ae1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aeb: Expected O, but got Unknown
			//IL_0b1a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b24: Expected O, but got Unknown
			//IL_0b44: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b82: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b8c: Expected O, but got Unknown
			//IL_0bbb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc5: Expected O, but got Unknown
			//IL_0bf4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bfe: Expected O, but got Unknown
			//IL_0c81: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c8b: Expected O, but got Unknown
			//IL_0cd6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ce0: Expected O, but got Unknown
			//IL_0d0f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d19: Expected O, but got Unknown
			//IL_0d48: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d52: Expected O, but got Unknown
			//IL_0d81: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d8b: Expected O, but got Unknown
			//IL_0dba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc4: Expected O, but got Unknown
			//IL_0df3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dfd: Expected O, but got Unknown
			//IL_0e2c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e36: Expected O, but got Unknown
			//IL_0e65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e6f: Expected O, but got Unknown
			//IL_0e9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ea8: Expected O, but got Unknown
			//IL_0ed7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ee1: Expected O, but got Unknown
			//IL_0f10: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f1a: Expected O, but got Unknown
			//IL_0f49: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f53: Expected O, but got Unknown
			//IL_0f82: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f8c: Expected O, but got Unknown
			//IL_0fbb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fc5: Expected O, but got Unknown
			//IL_0ff4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ffe: Expected O, but got Unknown
			//IL_102d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1037: Expected O, but got Unknown
			//IL_1066: Unknown result type (might be due to invalid IL or missing references)
			//IL_1070: Expected O, but got Unknown
			//IL_109f: Unknown result type (might be due to invalid IL or missing references)
			//IL_10a9: Expected O, but got Unknown
			//IL_10d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_10e2: Expected O, but got Unknown
			//IL_1111: Unknown result type (might be due to invalid IL or missing references)
			//IL_111b: Expected O, but got Unknown
			//IL_1166: Unknown result type (might be due to invalid IL or missing references)
			//IL_1170: Expected O, but got Unknown
			//IL_119f: Unknown result type (might be due to invalid IL or missing references)
			//IL_11a9: Expected O, but got Unknown
			//IL_1210: Unknown result type (might be due to invalid IL or missing references)
			//IL_121a: Expected O, but got Unknown
			//IL_1249: Unknown result type (might be due to invalid IL or missing references)
			//IL_1253: Expected O, but got Unknown
			//IL_1282: Unknown result type (might be due to invalid IL or missing references)
			//IL_128c: Expected O, but got Unknown
			//IL_12d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_12e1: Expected O, but got Unknown
			//IL_1310: Unknown result type (might be due to invalid IL or missing references)
			//IL_131a: Expected O, but got Unknown
			DarknessEnabled = config.Bind<bool>("Darkness", "Enabled", true, "Force permanent night on the island. The game clock keeps running; only the rendered light changes.");
			MoonIntensity = config.Bind<float>("Darkness", "MoonIntensity", 0.08f, new ConfigDescription("Strength of the moonlight.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			MoonColor = config.Bind<Color>("Darkness", "MoonColor", new Color(0.55f, 0.65f, 1f), "Hue of the moonlight.");
			MoonPitch = config.Bind<float>("Darkness", "MoonPitch", 50f, new ConfigDescription("Moon height above the horizon, in degrees.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 90f), Array.Empty<object>()));
			MoonYaw = config.Bind<float>("Darkness", "MoonYaw", 30f, new ConfigDescription("Compass direction the moonlight travels, in degrees.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 360f), Array.Empty<object>()));
			SkyBrightness = config.Bind<float>("Darkness", "SkyBrightness", 0.04f, new ConfigDescription("Multiplier applied to the three sky tints.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			SkyTopTint = config.Bind<Color>("Darkness", "SkyTopTint", new Color(0.25f, 0.25f, 0.75f), "Sky hue at the zenith.");
			SkyMidTint = config.Bind<Color>("Darkness", "SkyMidTint", new Color(0.375f, 0.375f, 1f), "Sky hue at mid height.");
			SkyBottomTint = config.Bind<Color>("Darkness", "SkyBottomTint", new Color(0.5f, 0.625f, 1f), "Sky hue at the horizon.");
			AmbientBrightness = config.Bind<float>("Darkness", "AmbientBrightness", 0.04f, new ConfigDescription("Multiplier applied to the ambient colour.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			AmbientColor = config.Bind<Color>("Darkness", "AmbientColor", new Color(0.5f, 0.625f, 1f), "Hue of the ambient light.");
			BakedLightScale = config.Bind<float>("Darkness", "BakedLightScale", 0f, new ConfigDescription("How much of the island's baked lighting stays (0 = none, 1 = vanilla).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			UnlitScoutBrightness = config.Bind<float>("Darkness", "UnlitScoutBrightness", 0.08f, new ConfigDescription("How visible a scout standing in the dark is (0 = black, 1 = vanilla).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FireGlowIntensity = config.Bind<float>("Darkness", "FireGlowIntensity", 12f, new ConfigDescription("Brightness of the light cast by lit campfires and other fire zones. 0 turns it off.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), Array.Empty<object>()));
			FireGlowRangeScale = config.Bind<float>("Darkness", "FireGlowRangeScale", 1.5f, new ConfigDescription("Reach of that light, as a multiple of the fire's safe-zone radius.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 4f), Array.Empty<object>()));
			HideHeldLanternGlare = config.Bind<bool>("Darkness", "HideHeldLanternGlare", true, "Hide the glow sprite of the lantern you are holding, which otherwise washes the first-person view orange.");
			MuteGameMusic = config.Bind<bool>("Darkness", "MuteGameMusic", true, "While Darkness is on, silence the game's music in the airport and on the island. The title screen keeps its music; ambience and sound effects are untouched.");
			AirportEnabled = config.Bind<bool>("Airport", "Enabled", true, "While Darkness is on, the airport is dark too: night outside the windows, a few warm lamps in the hall, a lamp over the light stand and a low drone.");
			AirportBrightness = config.Bind<float>("Airport", "Brightness", 0.05f, new ConfigDescription("Share of the airport's own lighting that stays (0 = as dark as the island, 1 = vanilla).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			AirportLampIntensity = config.Bind<float>("Airport", "LampIntensity", 0.5f, new ConfigDescription("Brightness of the hall lamps and the light stand's lamp. 0 turns them off.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			AirportDroneVolume = config.Bind<float>("Airport", "DroneVolume", 0.35f, new ConfigDescription("Volume of the low drone in the dark airport, before the game's SFX volume. 0 turns it off.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FearEnabled = config.Bind<bool>("Fear", "Enabled", true, "Fear builds while you stand in darkness and drains while you are lit. Local to each player. Also off while Darkness is off.");
			FearSecondsToMax = config.Bind<float>("Fear", "SecondsToMax", 90f, new ConfigDescription("Seconds in full darkness to go from no fear to maximum.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 600f), Array.Empty<object>()));
			FearSecondsToClear = config.Bind<float>("Fear", "SecondsToClear", 15f, new ConfigDescription("Seconds fully lit to go from maximum fear to none. Partial light both builds and drains, in proportion.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 300f), Array.Empty<object>()));
			FearUneasyAt = config.Bind<float>("Fear", "UneasyAt", 0.3f, new ConfigDescription("Fear level where the Uneasy tier starts: vignette, desaturation and heartbeat.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FearAfraidAt = config.Bind<float>("Fear", "AfraidAt", 0.65f, new ConfigDescription("Fear level where the Afraid tier starts: camera shudders and slower stamina regeneration. Never below UneasyAt.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FearVignetteIntensity = config.Bind<float>("Fear", "VignetteIntensity", 0.5f, new ConfigDescription("Darkening of the screen edges at maximum fear. 0 turns it off.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FearDesaturation = config.Bind<float>("Fear", "Desaturation", 60f, new ConfigDescription("Colour drained from the view at maximum fear, in percent. 0 turns it off.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			FearHeartbeatVolume = config.Bind<float>("Fear", "HeartbeatVolume", 0.6f, new ConfigDescription("Heartbeat volume at maximum fear, before the game's SFX volume. 0 turns it off.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			FearHeartbeatMinBpm = config.Bind<float>("Fear", "HeartbeatMinBpm", 60f, new ConfigDescription("Heartbeat tempo when the Uneasy tier starts, in beats per minute.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(30f, 200f), Array.Empty<object>()));
			FearHeartbeatMaxBpm = config.Bind<float>("Fear", "HeartbeatMaxBpm", 110f, new ConfigDescription("Heartbeat tempo at maximum fear, in beats per minute.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(30f, 200f), Array.Empty<object>()));
			FearShakeStrength = config.Bind<float>("Fear", "ShakeStrength", 3f, new ConfigDescription("Strength of the camera shudder at maximum fear. Halved and capp