using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Lockout;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Lockout")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Lockout")]
[assembly: AssemblyTitle("Lockout")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/AntoninJuquel/lethal-company-lockout")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[Serializable]
public class SyncedInstance<T>
{
	[NonSerialized]
	protected static int IntSize = 4;

	internal static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;

	internal static bool IsClient => NetworkManager.Singleton.IsClient;

	internal static bool IsHost => NetworkManager.Singleton.IsHost;

	public static T Default { get; private set; }

	public static T Instance { get; private set; }

	public static bool Synced { get; internal set; }

	protected void InitInstance(T instance)
	{
		Default = instance;
		Instance = instance;
		IntSize = 4;
	}

	internal static void SyncInstance(byte[] data)
	{
		Instance = DeserializeFromBytes(data);
		Synced = true;
	}

	internal static void RevertSync()
	{
		Instance = Default;
		Synced = false;
	}

	public static byte[] SerializeToBytes(T val)
	{
		BinaryFormatter binaryFormatter = new BinaryFormatter();
		using MemoryStream memoryStream = new MemoryStream();
		try
		{
			binaryFormatter.Serialize(memoryStream, val);
			return memoryStream.ToArray();
		}
		catch (Exception arg)
		{
			LockoutBase.Logger.LogError((object)$"Error serializing instance: {arg}");
			return null;
		}
	}

	public static T DeserializeFromBytes(byte[] data)
	{
		BinaryFormatter binaryFormatter = new BinaryFormatter();
		using MemoryStream serializationStream = new MemoryStream(data);
		try
		{
			return (T)binaryFormatter.Deserialize(serializationStream);
		}
		catch (Exception arg)
		{
			LockoutBase.Logger.LogError((object)$"Error deserializing instance: {arg}");
			return default(T);
		}
	}
}
namespace Lockout
{
	[BepInPlugin("com.github.somindras.lethal-company-lockout", "Lockout", "1.3.1")]
	public class LockoutBase : BaseUnityPlugin
	{
		public enum KeyUsage
		{
			No,
			Inventory,
			Hand
		}

		[HarmonyPatch(typeof(TimeOfDay))]
		internal class TimeOfDayPatch : HarmonyPatch
		{
			[HarmonyPatch("TimeOfDayEvents")]
			[HarmonyPostfix]
			public static void TimeOfDayEventsPostfix(float ___currentDayTime, float ___totalTime)
			{
				timeRatio = ___currentDayTime / ___totalTime;
				if (timeRatio < TimeBeforeLockout || (CanPowerOffLockout && !powerOn))
				{
					if (isLocked)
					{
						Logger.LogInfo((object)"TimeOfDayEventsPostfix: Unlock Alert");
						HUDManager.Instance.ReadDialogue(unlockDialog);
						isLocked = false;
					}
				}
				else if (timeRatio < TimeBeforeUnlock)
				{
					if (!isLocked)
					{
						Logger.LogInfo((object)"TimeOfDayEventsPostfix: Lockout Alert");
						HUDManager.Instance.ReadDialogue(lockoutDialog);
						isLocked = true;
					}
				}
				else if (isLocked)
				{
					Logger.LogInfo((object)"TimeOfDayEventsPostfix: Unlock Alert");
					HUDManager.Instance.ReadDialogue(unlockDialog);
					isLocked = false;
				}
			}
		}

		[HarmonyPatch(typeof(EntranceTeleport))]
		internal class EntranceTeleportPatch : HarmonyPatch
		{
			private static bool UseKey()
			{
				PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
				switch (CanUseKey)
				{
				case KeyUsage.No:
					Logger.LogInfo((object)$"UseKey: config DISABLED key usage: {CanUseKey}");
					return false;
				default:
				{
					int num = Array.FindIndex(localPlayerController.ItemSlots, (GrabbableObject item) => Object.op_Implicit((Object)(object)item) && item is KeyItem);
					bool flag2 = num != -1;
					if (flag2)
					{
						localPlayerController.isHoldingObject = true;
						localPlayerController.DestroyItemInSlotAndSync(num);
					}
					Logger.LogInfo((object)string.Format("UseKey: was ({0}) to use key in inventory got slot {1}", flag2 ? "ABLE" : "UNABLE", num));
					return flag2;
				}
				case KeyUsage.Hand:
				{
					bool flag = Object.op_Implicit((Object)(object)localPlayerController.currentlyHeldObjectServer) && localPlayerController.currentlyHeldObjectServer is KeyItem;
					if (flag)
					{
						localPlayerController.DespawnHeldObject();
					}
					Logger.LogInfo((object)("UseKey: was (" + (flag ? "ABLE" : "UNABLE") + ") to use currently held key"));
					return flag;
				}
				}
			}

			private static bool CanEnter(bool isMainEntrance)
			{
				if (isLocked)
				{
					if (isMainEntrance)
					{
						return CanEnterMainEntranceDuringLockout;
					}
					return CanEnterFireExitDuringLockout;
				}
				if (isMainEntrance)
				{
					return CanEnterMainEntranceDuringUnlock;
				}
				return CanEnterFireExitDuringUnlock;
			}

			private static bool CanExit(bool isMainEntrance)
			{
				if (isLocked)
				{
					if (isMainEntrance)
					{
						return CanExitMainEntranceDuringLockout;
					}
					return CanExitFireExitDuringLockout;
				}
				if (isMainEntrance)
				{
					return CanExitMainEntranceDuringUnlock;
				}
				return CanExitFireExitDuringUnlock;
			}

			[HarmonyPatch("TeleportPlayer")]
			[HarmonyPrefix]
			public static bool TeleportPlayerPrefix(bool ___isEntranceToBuilding, int ___entranceId)
			{
				bool flag = ___entranceId == 0;
				bool flag2 = ___isEntranceToBuilding;
				bool flag3 = (flag2 ? CanEnter(flag) : CanExit(flag)) || UseKey();
				Logger.LogInfo((object)("Player is " + (flag3 ? "ALLOWED" : "UNALLOWED") + " to " + (flag2 ? "ENTER" : "EXIT") + " through the " + (flag ? "MAIN ENTRANCE" : "FIRE EXIT")));
				if (!flag3)
				{
					HUDManager.Instance.DisplayTip("???", (flag2 ? "ENTERING" : "EXITING") + " through the " + (flag ? "MAIN ENTRANCE" : "FIRE EXIT") + " seems blocked", false, false, "LC_Tip1");
				}
				return flag3;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB))]
		internal class PlayerControllerBPatch : HarmonyPatch
		{
			[CompilerGenerated]
			private static class <>O
			{
				public static HandleNamedMessageDelegate <0>__OnRequestSync;

				public static HandleNamedMessageDelegate <1>__OnReceiveSync;
			}

			[HarmonyPatch("ConnectClientToPlayerObject")]
			[HarmonyPostfix]
			public static void ConnectClientToPlayerObjectPostfix()
			{
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Expected O, but got Unknown
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				if (SyncedInstance<LockoutConfig>.IsHost)
				{
					Logger.LogInfo((object)"ConnectClientToPlayerObjectPostfix: Host is syncing config");
					CustomMessagingManager messageManager = SyncedInstance<LockoutConfig>.MessageManager;
					object obj = <>O.<0>__OnRequestSync;
					if (obj == null)
					{
						HandleNamedMessageDelegate val = LockoutConfig.OnRequestSync;
						<>O.<0>__OnRequestSync = val;
						obj = (object)val;
					}
					messageManager.RegisterNamedMessageHandler("Lockout_OnRequestConfigSync", (HandleNamedMessageDelegate)obj);
					SyncedInstance<LockoutConfig>.Synced = true;
					return;
				}
				Logger.LogInfo((object)"ConnectClientToPlayerObjectPostfix: Client is requesting config sync");
				SyncedInstance<LockoutConfig>.Synced = false;
				CustomMessagingManager messageManager2 = SyncedInstance<LockoutConfig>.MessageManager;
				object obj2 = <>O.<1>__OnReceiveSync;
				if (obj2 == null)
				{
					HandleNamedMessageDelegate val2 = LockoutConfig.OnReceiveSync;
					<>O.<1>__OnReceiveSync = val2;
					obj2 = (object)val2;
				}
				messageManager2.RegisterNamedMessageHandler("Lockout_OnReceiveConfigSync", (HandleNamedMessageDelegate)obj2);
				LockoutConfig.RequestSync();
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager))]
		internal class GameNetworkManagerPatch : HarmonyPatch
		{
			[HarmonyPatch("StartDisconnect")]
			[HarmonyPostfix]
			public static void StartDisconnectPostfix()
			{
				Logger.LogInfo((object)"StartDisconnectPostfix: Disconnecting");
				SyncedInstance<LockoutConfig>.RevertSync();
			}
		}

		[HarmonyPatch(typeof(RoundManager))]
		internal class RoundManagerPatch : HarmonyPatch
		{
			[HarmonyPatch("Start")]
			[HarmonyPostfix]
			private static void StartPostfix()
			{
				Logger.LogInfo((object)"Start: Registering event handlers");
				((UnityEvent<bool>)(object)RoundManager.Instance.onPowerSwitch).AddListener((UnityAction<bool>)OnPowerSwitch);
			}

			[HarmonyPatch("OnDestroy")]
			[HarmonyPostfix]
			private static void OnDestroy()
			{
				Logger.LogInfo((object)"OnDestroy: Unregistering event handlers");
				((UnityEvent<bool>)(object)RoundManager.Instance.onPowerSwitch).RemoveListener((UnityAction<bool>)OnPowerSwitch);
			}

			[HarmonyPatch("SetLevelObjectVariables")]
			[HarmonyPrefix]
			private static void SetLevelObjectVariablesPrefix()
			{
				OnPowerSwitch(on: true);
				isLocked = false;
			}

			private static void OnPowerSwitch(bool on)
			{
				Logger.LogInfo((object)$"OnPowerSwitch: {on}");
				powerOn = on;
			}
		}

		private readonly Harmony harmony = new Harmony("com.github.somindras.lethal-company-lockout");

		private static LockoutBase Instance;

		private static float timeRatio = 0f;

		private static bool isLocked = false;

		private static bool powerOn = true;

		private static readonly DialogueSegment[] lockoutDialog = (DialogueSegment[])(object)new DialogueSegment[1]
		{
			new DialogueSegment
			{
				speakerText = "Facility AI",
				bodyText = "The building is now locked down.",
				waitTime = 3f
			}
		};

		private static readonly DialogueSegment[] unlockDialog = (DialogueSegment[])(object)new DialogueSegment[1]
		{
			new DialogueSegment
			{
				speakerText = "Facility AI",
				bodyText = "The building is now unlocked.",
				waitTime = 3f
			}
		};

		internal static ManualLogSource Logger { get; private set; }

		public static LockoutConfig Config { get; internal set; }

		private static float TimeBeforeLockout => SyncedInstance<LockoutConfig>.Instance.timeBeforeLockout;

		private static float TimeBeforeUnlock => SyncedInstance<LockoutConfig>.Instance.timeBeforeUnlock;

		private static bool CanEnterFireExitDuringLockout => SyncedInstance<LockoutConfig>.Instance.canEnterFireExitDuringLockout;

		private static bool CanEnterFireExitDuringUnlock => SyncedInstance<LockoutConfig>.Instance.canEnterFireExitDuringUnlock;

		private static bool CanExitFireExitDuringLockout => SyncedInstance<LockoutConfig>.Instance.canExitFireExitDuringLockout;

		private static bool CanExitFireExitDuringUnlock => SyncedInstance<LockoutConfig>.Instance.canExitFireExitDuringUnlock;

		private static bool CanEnterMainEntranceDuringLockout => SyncedInstance<LockoutConfig>.Instance.canEnterMainEntranceDuringLockout;

		private static bool CanEnterMainEntranceDuringUnlock => SyncedInstance<LockoutConfig>.Instance.canEnterMainEntranceDuringUnlock;

		private static bool CanExitMainEntranceDuringLockout => SyncedInstance<LockoutConfig>.Instance.canExitMainEntranceDuringLockout;

		private static bool CanExitMainEntranceDuringUnlock => SyncedInstance<LockoutConfig>.Instance.canExitMainEntranceDuringUnlock;

		private static bool CanPowerOffLockout => SyncedInstance<LockoutConfig>.Instance.canPowerOffLockout;

		private static KeyUsage CanUseKey => SyncedInstance<LockoutConfig>.Instance.canUseKey;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Logger = Logger.CreateLogSource("com.github.somindras.lethal-company-lockout");
			Logger.LogInfo((object)"Plugin Lockout is loaded!");
			Config = new LockoutConfig(((BaseUnityPlugin)this).Config);
			harmony.PatchAll(typeof(TimeOfDayPatch));
			harmony.PatchAll(typeof(EntranceTeleportPatch));
			harmony.PatchAll(typeof(LockoutConfig));
			harmony.PatchAll(typeof(PlayerControllerBPatch));
			harmony.PatchAll(typeof(GameNetworkManagerPatch));
			harmony.PatchAll(typeof(RoundManagerPatch));
		}
	}
	[Serializable]
	public class LockoutConfig : SyncedInstance<LockoutConfig>
	{
		public float timeBeforeLockout = 0.2f;

		public float timeBeforeUnlock = 0.9f;

		public bool canEnterFireExitDuringLockout = false;

		public bool canEnterFireExitDuringUnlock = false;

		public bool canExitFireExitDuringLockout = true;

		public bool canExitFireExitDuringUnlock = true;

		public bool canEnterMainEntranceDuringLockout = false;

		public bool canEnterMainEntranceDuringUnlock = true;

		public bool canExitMainEntranceDuringLockout = false;

		public bool canExitMainEntranceDuringUnlock = true;

		public bool canPowerOffLockout = true;

		public LockoutBase.KeyUsage canUseKey = LockoutBase.KeyUsage.Inventory;

		public LockoutConfig(ConfigFile cfg)
		{
			InitInstance(this);
			timeBeforeLockout = cfg.Bind<float>("Time", "Time Before Lockout", 0.2f, "The time of day when the building lockout (0-1)").Value;
			timeBeforeUnlock = cfg.Bind<float>("Time", "Time Before Unlock", 0.9f, "The time of day when the building unlocks (0-1)").Value;
			canEnterFireExitDuringLockout = cfg.Bind<bool>("Fire Exit", "Can Enter Fire Exit During Lockout", false, "Can enter the fire exit during lockout").Value;
			canEnterFireExitDuringUnlock = cfg.Bind<bool>("Fire Exit", "Can Enter Fire Exit During Unlock", false, "Can enter the fire exit during unlock").Value;
			canExitFireExitDuringLockout = cfg.Bind<bool>("Fire Exit", "Can Exit Fire Exit During Lockout", true, "Can exit the fire exit during lockout").Value;
			canExitFireExitDuringUnlock = cfg.Bind<bool>("Fire Exit", "Can Exit Fire Exit During Unlock", true, "Can exit the fire exit during unlock").Value;
			canEnterMainEntranceDuringLockout = cfg.Bind<bool>("Main Entrance", "Can Enter Main Entrance During Lockout", false, "Can enter the main entrance during lockout").Value;
			canEnterMainEntranceDuringUnlock = cfg.Bind<bool>("Main Entrance", "Can Enter Main Entrance During Unlock", true, "Can enter the main entrance during unlock").Value;
			canExitMainEntranceDuringLockout = cfg.Bind<bool>("Main Entrance", "Can Exit Main Entrance During Lockout", false, "Can exit the main entrance during lockout").Value;
			canExitMainEntranceDuringUnlock = cfg.Bind<bool>("Main Entrance", "Can Exit Main Entrance During Unlock", true, "Can exit the main entrance during unlock").Value;
			canPowerOffLockout = cfg.Bind<bool>("Power", "Can Power Off Lockout", true, "Can power off the lockout").Value;
			canUseKey = (LockoutBase.KeyUsage)cfg.Bind<int>("Key", "Can use key", 1, "Can use the key to enter/exit during lockout |0: No|1: Key in inventory slot|2: Key must be held|").Value;
			if (timeBeforeLockout < 0f || timeBeforeLockout > 1f)
			{
				LockoutBase.Logger.LogWarning((object)$"Time Before Lockout was set to {timeBeforeLockout}. Setting to default.");
				timeBeforeLockout = 0.2f;
			}
			if (timeBeforeUnlock < 0f || timeBeforeUnlock > 1f)
			{
				LockoutBase.Logger.LogWarning((object)$"Time Before Unlock was set to {timeBeforeUnlock}. Setting to default.");
				timeBeforeUnlock = 0.9f;
			}
			if (timeBeforeLockout > timeBeforeUnlock)
			{
				LockoutBase.Logger.LogWarning((object)$"Time Before Lockout was set to {timeBeforeLockout} and is Greater than Time Before Unlock was set to {timeBeforeUnlock}. Setting to default.");
				timeBeforeLockout = 0.2f;
				timeBeforeUnlock = 0.9f;
			}
			if (!Enum.IsDefined(typeof(LockoutBase.KeyUsage), canUseKey))
			{
				LockoutBase.Logger.LogWarning((object)$"Can Use Key was set to {canUseKey}. Setting to default.");
				canUseKey = LockoutBase.KeyUsage.Inventory;
			}
			LockoutBase.Logger.LogInfo((object)"Config loaded.");
			LockoutBase.Logger.LogInfo((object)$"Time Before Lockout: {timeBeforeLockout}");
			LockoutBase.Logger.LogInfo((object)$"Time Before Unlock: {timeBeforeUnlock}");
			LockoutBase.Logger.LogInfo((object)$"Can Enter Fire Exit During Lockout: {canEnterFireExitDuringLockout}");
			LockoutBase.Logger.LogInfo((object)$"Can Enter Fire Exit During Unlock: {canEnterFireExitDuringUnlock}");
			LockoutBase.Logger.LogInfo((object)$"Can Exit Fire Exit During Lockout: {canExitFireExitDuringLockout}");
			LockoutBase.Logger.LogInfo((object)$"Can Exit Fire Exit During Unlock: {canExitFireExitDuringUnlock}");
			LockoutBase.Logger.LogInfo((object)$"Can Enter Main Entrance During Lockout: {canEnterMainEntranceDuringLockout}");
			LockoutBase.Logger.LogInfo((object)$"Can Enter Main Entrance During Unlock: {canEnterMainEntranceDuringUnlock}");
			LockoutBase.Logger.LogInfo((object)$"Can Exit Main Entrance During Lockout: {canExitMainEntranceDuringLockout}");
			LockoutBase.Logger.LogInfo((object)$"Can Exit Main Entrance During Unlock: {canExitMainEntranceDuringUnlock}");
			LockoutBase.Logger.LogInfo((object)$"Can Power Off Lockout: {canPowerOffLockout}");
			LockoutBase.Logger.LogInfo((object)$"Can Use Key: {canUseKey}");
		}

		public static void RequestSync()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<LockoutConfig>.IsClient)
			{
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(SyncedInstance<LockoutConfig>.IntSize, (Allocator)2, -1);
			try
			{
				SyncedInstance<LockoutConfig>.MessageManager.SendNamedMessage("Lockout_OnRequestConfigSync", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnRequestSync(ulong clientId, FastBufferReader _)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (!SyncedInstance<LockoutConfig>.IsHost)
			{
				return;
			}
			LockoutBase.Logger.LogInfo((object)$"Config sync request received from client: {clientId}");
			byte[] array = SyncedInstance<LockoutConfig>.SerializeToBytes(SyncedInstance<LockoutConfig>.Instance);
			int num = array.Length;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(num + SyncedInstance<LockoutConfig>.IntSize, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
				SyncedInstance<LockoutConfig>.MessageManager.SendNamedMessage("Lockout_OnReceiveConfigSync", clientId, val, (NetworkDelivery)3);
			}
			catch (Exception arg)
			{
				LockoutBase.Logger.LogInfo((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnReceiveSync(ulong _, FastBufferReader reader)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!((FastBufferReader)(ref reader)).TryBeginRead(SyncedInstance<LockoutConfig>.IntSize))
			{
				LockoutBase.Logger.LogError((object)"Config sync error: Could not begin reading buffer.");
				return;
			}
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
			{
				LockoutBase.Logger.LogError((object)"Config sync error: Host could not sync.");
				return;
			}
			byte[] data = new byte[num];
			((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
			SyncedInstance<LockoutConfig>.SyncInstance(data);
			LockoutBase.Logger.LogInfo((object)"Successfully synced config with host.");
		}
	}
	public static class LockoutInfo
	{
		public const string GUID = "com.github.somindras.lethal-company-lockout";

		public const string NAME = "Lockout";

		public const string VERSION = "1.3.1";
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "Lockout";

		public const string PLUGIN_NAME = "Lockout";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}