using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using Brigadier.NET;
using Brigadier.NET.ArgumentTypes;
using Brigadier.NET.Builder;
using Brigadier.NET.Context;
using Brigadier.NET.Tree;
using GameNetcodeStuff;
using HarmonyLib;
using Lethal Cheat.NetcodePatcher;
using Microsoft.CodeAnalysis;
using Rumi.BrigadierForLethalCompany;
using Rumi.BrigadierForLethalCompany.API;
using Rumi.BrigadierForLethalCompany.API.Arguments;
using Rumi.BrigadierForLethalCompany.API.Arguments.Selectors;
using Rumi.BrigadierForLethalCompany.Networking;
using Rumi.LCNetworks;
using Rumi.LCNetworks.API;
using Rumi.LethalCheat.Networking;
using Unity.Netcode;
using UnityEngine;

[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: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Rumi.LethalCheat
{
	internal static class Debug
	{
		public static void Log(object data)
		{
			ManualLogSource? logger = LCheatPlugin.logger;
			if (logger != null)
			{
				logger.LogInfo(data);
			}
		}

		public static void LogWarning(object data)
		{
			ManualLogSource? logger = LCheatPlugin.logger;
			if (logger != null)
			{
				logger.LogWarning(data);
			}
		}

		public static void LogError(object data)
		{
			ManualLogSource? logger = LCheatPlugin.logger;
			if (logger != null)
			{
				logger.LogError(data);
			}
		}
	}
	[BepInPlugin("Rumi.LethalCheat", "LethalCheat", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class LCheatPlugin : BaseUnityPlugin
	{
		public const string modGuid = "Rumi.LethalCheat";

		public const string modName = "LethalCheat";

		public const string modVersion = "1.0.1";

		internal static ManualLogSource? logger { get; private set; } = null;


		internal static Harmony harmony { get; } = new Harmony("Rumi.LethalCheat");


		private void Awake()
		{
			logger = ((BaseUnityPlugin)this).Logger;
			Debug.Log("Start loading plugin...");
			LCNHPlugin.NetcodePatcher();
			Debug.Log("Plugin LethalCheat is loaded!");
		}
	}
}
namespace Rumi.LethalCheat.Networking
{
	public sealed class LCheatNetworkHandler : LCNHNetworkBehaviour<LCheatNetworkHandler>
	{
		public override string name => "LCheat Network Handler";

		public override uint globalIdHash => 591605829u;

		public static void TeleportEntity(NetworkBehaviour entity, Vector3 position)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				EnemyAI val = (EnemyAI)(object)((entity is EnemyAI) ? entity : null);
				if (val != null)
				{
					val.SetEnemyOutside(((Component)val).transform.position.y >= -100f);
					val.agent.Warp(position);
				}
				((Component)entity).transform.position = position;
				LCNHNetworkBehaviour<LCheatNetworkHandler>.instance.InternalTeleportEntityClientRpc(NetworkBehaviourReference.op_Implicit(entity), position);
			}
		}

		[ClientRpc]
		private void InternalTeleportEntityClientRpc(NetworkBehaviourReference entityRef, Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2730150009u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref entityRef, default(ForNetworkSerializable));
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2730150009u, val, (RpcDelivery)0);
			}
			NetworkBehaviour val3 = default(NetworkBehaviour);
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && ((NetworkBehaviourReference)(ref entityRef)).TryGet(ref val3, (NetworkManager)null))
			{
				EnemyAI val4 = (EnemyAI)(object)((val3 is EnemyAI) ? val3 : null);
				if (val4 != null)
				{
					val4.SetEnemyOutside(((Component)val4).transform.position.y >= -100f);
					val4.agent.Warp(position);
				}
				((Component)val3).transform.position = position;
			}
		}

		public static void KillEntity(NetworkBehaviour entity)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer && ((entity is PlayerControllerB || entity is EnemyAI) ? true : false))
			{
				LCNHNetworkBehaviour<LCheatNetworkHandler>.instance.InternalKillEntityClientRpc(NetworkBehaviourReference.op_Implicit(entity));
			}
		}

		[ClientRpc]
		private void InternalKillEntityClientRpc(NetworkBehaviourReference entityRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1098298866u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref entityRef, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1098298866u, val, (RpcDelivery)0);
			}
			NetworkBehaviour val3 = default(NetworkBehaviour);
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost) || !((NetworkBehaviourReference)(ref entityRef)).TryGet(ref val3, (NetworkManager)null))
			{
				return;
			}
			PlayerControllerB val4 = (PlayerControllerB)(object)((val3 is PlayerControllerB) ? val3 : null);
			if (val4 != null)
			{
				val4.KillPlayer(Vector3.up * 5f, true, (CauseOfDeath)0, 0, default(Vector3));
				return;
			}
			EnemyAI val5 = (EnemyAI)(object)((val3 is EnemyAI) ? val3 : null);
			if (val5 != null)
			{
				val5.KillEnemy(false);
			}
		}

		public static void DestroyEntity(NetworkBehaviour entity)
		{
			NetworkObject val = default(NetworkObject);
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer && !(entity is PlayerControllerB) && ((Component)entity).TryGetComponent<NetworkObject>(ref val))
			{
				val.Despawn(true);
			}
		}

		public static void DamageEntity(NetworkBehaviour entity, int damage)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer && ((entity is PlayerControllerB || entity is EnemyAI) ? true : false))
			{
				LCNHNetworkBehaviour<LCheatNetworkHandler>.instance.InternalDamageEntityClientRpc(NetworkBehaviourReference.op_Implicit(entity), damage);
			}
		}

		[ClientRpc]
		private void InternalDamageEntityClientRpc(NetworkBehaviourReference entityRef, int damage)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3275742794u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref entityRef, default(ForNetworkSerializable));
				BytePacker.WriteValueBitPacked(val2, damage);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3275742794u, val, (RpcDelivery)0);
			}
			NetworkBehaviour val3 = default(NetworkBehaviour);
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost) || !((NetworkBehaviourReference)(ref entityRef)).TryGet(ref val3, (NetworkManager)null))
			{
				return;
			}
			PlayerControllerB val4 = (PlayerControllerB)(object)((val3 is PlayerControllerB) ? val3 : null);
			if (val4 != null)
			{
				val4.DamagePlayer(damage, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
				return;
			}
			EnemyAI val5 = (EnemyAI)(object)((val3 is EnemyAI) ? val3 : null);
			if (val5 != null)
			{
				val5.HitEnemy(damage, (PlayerControllerB)null, true, -1);
			}
		}

		public static void SummonEntity(EnemyType entityType, Vector3 position)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				NetworkObjectReference val = RoundManager.Instance.SpawnEnemyGameObject(position, 0f, 0, entityType);
				NetworkObject val2 = default(NetworkObject);
				if (((NetworkObjectReference)(ref val)).TryGet(ref val2, (NetworkManager)null))
				{
					((Component)val2).GetComponent<EnemyAI>().SetEnemyOutside(((Component)val2).transform.position.y >= -100f);
				}
			}
		}

		public static void SummonEntity(AnomalyType entityType, Vector3 position)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				GameObject obj = Object.Instantiate<GameObject>(entityType.anomalyPrefab, position, Quaternion.identity);
				obj.GetComponentInChildren<NetworkObject>().Spawn(true);
				Anomaly component = obj.GetComponent<Anomaly>();
				RoundManager.Instance.SpawnedAnomalies.Add(component);
			}
		}

		public static void SummonEntity(Item entityType, Vector3 position, int price = 0)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				NetworkObject component = Object.Instantiate<GameObject>(entityType.spawnPrefab, position, Quaternion.Euler(entityType.restingRotation)).GetComponent<NetworkObject>();
				component.Spawn(true);
				LCNHNetworkBehaviour<LCheatNetworkHandler>.instance.InternalSummonEntityClientRpc(NetworkObjectReference.op_Implicit(component), price);
			}
		}

		[ClientRpc]
		private void InternalSummonEntityClientRpc(NetworkObjectReference entityRef, int price)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2731279092u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref entityRef, default(ForNetworkSerializable));
				BytePacker.WriteValueBitPacked(val2, price);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2731279092u, val, (RpcDelivery)0);
			}
			NetworkObject val3 = default(NetworkObject);
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && ((NetworkObjectReference)(ref entityRef)).TryGet(ref val3, (NetworkManager)null))
			{
				GrabbableObject component = ((Component)val3).gameObject.GetComponent<GrabbableObject>();
				if ((Object)(object)((Component)component).GetComponentInChildren<ScanNodeProperties>() != (Object)null)
				{
					component.SetScrapValue(price);
				}
			}
		}

		public static float GetTimeHour()
		{
			if ((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null || !((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				return 0f;
			}
			TimeOfDay instance = TimeOfDay.Instance;
			SelectableLevel currentLevel = instance.currentLevel;
			return instance.globalTime * currentLevel.DaySpeedMultiplier / instance.lengthOfHours + 6f;
		}

		public static void SetTimeHour(float time)
		{
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				LCNHNetworkBehaviour<LCheatNetworkHandler>.instance.InternalSetTimeHourClientRpc(time);
			}
		}

		[ClientRpc]
		private void InternalSetTimeHourClientRpc(float time)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1185526508u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref time, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1185526508u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					TimeOfDay instance = TimeOfDay.Instance;
					SelectableLevel currentLevel = instance.currentLevel;
					float num = (instance.globalTime = (time - 6f) / currentLevel.DaySpeedMultiplier * instance.lengthOfHours);
					instance.currentDayTime = instance.CalculatePlanetTime(currentLevel);
					instance.hour = (int)(instance.currentDayTime / instance.lengthOfHours);
					instance.previousHour = instance.hour;
					instance.globalTimeAtEndOfDay = num + (instance.totalTime - instance.currentDayTime) / currentLevel.DaySpeedMultiplier;
					instance.normalizedTimeOfDay = instance.currentDayTime / instance.totalTime;
					instance.RefreshClockUI();
				}
			}
		}

		public static float GetTimeSpeed()
		{
			return TimeOfDay.Instance.globalTimeSpeedMultiplier;
		}

		public static void SetTimeSpeed(float speed)
		{
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				LCNHNetworkBehaviour<LCheatNetworkHandler>.instance.InternalSetTimeSpeedClientRpc(speed);
			}
		}

		[ClientRpc]
		private void InternalSetTimeSpeedClientRpc(float speed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3090384912u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref speed, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3090384912u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					TimeOfDay.Instance.globalTimeSpeedMultiplier = speed;
				}
			}
		}

		public static int GetCredit()
		{
			if ((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null || !((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				return 0;
			}
			return Object.FindAnyObjectByType<Terminal>().groupCredits;
		}

		public static void SetCredit(int credit)
		{
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				Terminal val = Object.FindAnyObjectByType<Terminal>();
				val.useCreditsCooldown = true;
				val.groupCredits = credit;
				val.SyncGroupCreditsServerRpc(val.groupCredits, val.numberOfItemsInDropship);
			}
		}

		public static float GetGameSpeed()
		{
			if ((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null || !((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				return 0f;
			}
			return Time.timeScale;
		}

		public static void SetGameSpeed(float timeScale)
		{
			if (!((Object)(object)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance == (Object)null) && ((NetworkBehaviour)LCNHNetworkBehaviour<LCheatNetworkHandler>.instance).IsServer)
			{
				LCNHNetworkBehaviour<LCheatNetworkHandler>.instance.InternalSetGameSpeedClientRpc(timeScale);
			}
		}

		[ClientRpc]
		private void InternalSetGameSpeedClientRpc(float timeScale)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3143656681u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref timeScale, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3143656681u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					Time.timeScale = timeScale;
				}
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_LCheatNetworkHandler()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(2730150009u, new RpcReceiveHandler(__rpc_handler_2730150009));
			NetworkManager.__rpc_func_table.Add(1098298866u, new RpcReceiveHandler(__rpc_handler_1098298866));
			NetworkManager.__rpc_func_table.Add(3275742794u, new RpcReceiveHandler(__rpc_handler_3275742794));
			NetworkManager.__rpc_func_table.Add(2731279092u, new RpcReceiveHandler(__rpc_handler_2731279092));
			NetworkManager.__rpc_func_table.Add(1185526508u, new RpcReceiveHandler(__rpc_handler_1185526508));
			NetworkManager.__rpc_func_table.Add(3090384912u, new RpcReceiveHandler(__rpc_handler_3090384912));
			NetworkManager.__rpc_func_table.Add(3143656681u, new RpcReceiveHandler(__rpc_handler_3143656681));
		}

		private static void __rpc_handler_2730150009(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference entityRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref entityRef, default(ForNetworkSerializable));
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((LCheatNetworkHandler)(object)target).InternalTeleportEntityClientRpc(entityRef, position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1098298866(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference entityRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref entityRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((LCheatNetworkHandler)(object)target).InternalKillEntityClientRpc(entityRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3275742794(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference entityRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref entityRef, default(ForNetworkSerializable));
				int damage = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref damage);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((LCheatNetworkHandler)(object)target).InternalDamageEntityClientRpc(entityRef, damage);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2731279092(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference entityRef = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref entityRef, default(ForNetworkSerializable));
				int price = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref price);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((LCheatNetworkHandler)(object)target).InternalSummonEntityClientRpc(entityRef, price);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1185526508(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float time = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref time, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((LCheatNetworkHandler)(object)target).InternalSetTimeHourClientRpc(time);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3090384912(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float speed = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref speed, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((LCheatNetworkHandler)(object)target).InternalSetTimeSpeedClientRpc(speed);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3143656681(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float timeScale = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref timeScale, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((LCheatNetworkHandler)(object)target).InternalSetGameSpeedClientRpc(timeScale);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "LCheatNetworkHandler";
		}
	}
}
namespace Rumi.LethalCheat.API.Commands
{
	public sealed class Credit : ServerCommand
	{
		public const string resultGetText = "The credit is {value}";

		public const string resultAddText = "Add the credit to {value}";

		public const string resultSetText = "Set the credit to {value}";

		private Credit()
		{
		}

		public override void Register()
		{
			ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "credit")).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "get")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				int credit = LCheatNetworkHandler.GetCredit();
				x.Source.SendCommandResult("The credit is {value}".Replace("{value}", credit.ToString()), false);
				return credit;
			})))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "add")).Then<ArgumentCommandNode<ServerCommandSource, int>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "credit", (ArgumentType<int>)(object)RuniArguments.Integer(0, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				int integer2 = RuniArguments.GetInteger<ServerCommandSource>(x, "credit");
				LCheatNetworkHandler.SetCredit(LCheatNetworkHandler.GetCredit() + integer2);
				x.Source.SendCommandResult("Add the credit to {value}".Replace("{value}", integer2.ToString()), true);
				return integer2;
			})))))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "set")).Then<ArgumentCommandNode<ServerCommandSource, int>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "credit", (ArgumentType<int>)(object)RuniArguments.Integer(0, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				int integer = RuniArguments.GetInteger<ServerCommandSource>(x, "credit");
				LCheatNetworkHandler.SetCredit(integer);
				x.Source.SendCommandResult("Set the credit to {value}".Replace("{value}", integer.ToString()), true);
				return integer;
			})))))));
		}
	}
	public sealed class Damage : ServerCommand
	{
		public const string resultText = "Applied {value} damage to {targets}";

		private Damage()
		{
		}

		public override void Register()
		{
			ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "damage")).Then<ArgumentCommandNode<ServerCommandSource, int>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "amount", (ArgumentType<int>)(object)RuniArguments.Integer(int.MinValue, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				if ((Object)(object)x.Source.sender != (Object)null)
				{
					int integer2 = RuniArguments.GetInteger<ServerCommandSource>(x, "amount");
					LCheatNetworkHandler.DamageEntity(x.Source.sender, integer2);
					x.Source.SendCommandResult("Applied {value} damage to {targets}".Replace("{value}", integer2.ToString()).Replace("{targets}", BFLCUtility.GetEntityName(x.Source.sender)), true);
					return 1;
				}
				return 0;
			})))).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (ArgumentType<SelectorArgumentValue>)(object)RuniArguments.Selector(false, false))).Then<ArgumentCommandNode<ServerCommandSource, int>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "amount", (ArgumentType<int>)(object)RuniArguments.Integer(int.MinValue, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				SelectorArgumentValue selector = RuniArguments.GetSelector<ServerCommandSource>(x, "targets");
				IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
				int integer = RuniArguments.GetInteger<ServerCommandSource>(x, "amount");
				int num = 0;
				foreach (NetworkBehaviour item in entitys)
				{
					if ((item is PlayerControllerB || item is EnemyAI) ? true : false)
					{
						try
						{
							LCheatNetworkHandler.DamageEntity(item, integer);
							num++;
						}
						catch (Exception data)
						{
							Debug.LogError(data);
						}
					}
				}
				x.Source.SendCommandResult("Applied {value} damage to {targets}".Replace("{value}", integer.ToString()).Replace("{targets}", BFLCUtility.GetEntityName(entitys, num)), true);
				return num;
			})))))));
		}
	}
	public sealed class Destroy : ServerCommand
	{
		public const string resultText = "Destroyed {targets}";

		private Destroy()
		{
		}

		public override void Register()
		{
			ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "destroy")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				if ((Object)(object)x.Source.sender != (Object)null && (Object)(object)x.Source.player == (Object)null)
				{
					LCheatNetworkHandler.DestroyEntity(x.Source.sender);
					x.Source.SendCommandResult("Destroyed {targets}".Replace("{targets}", BFLCUtility.GetEntityName(x.Source.sender)), true);
					return 1;
				}
				return 0;
			})).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (ArgumentType<SelectorArgumentValue>)(object)RuniArguments.Selector(false, false))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)x.Source.sender != (Object)null)
				{
					SelectorArgumentValue selector = RuniArguments.GetSelector<ServerCommandSource>(x, "targets");
					IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
					int num = 0;
					foreach (NetworkBehaviour item in entitys)
					{
						if (!(item is PlayerControllerB))
						{
							try
							{
								LCheatNetworkHandler.DestroyEntity(item);
								num++;
							}
							catch (Exception data)
							{
								Debug.LogError(data);
							}
						}
					}
					x.Source.SendCommandResult("Destroyed {targets}".Replace("{targets}", BFLCUtility.GetEntityName(entitys, num)), true);
					return num;
				}
				return 0;
			})))));
		}
	}
	public sealed class GameSpeed : ServerCommand
	{
		public const string resultGetText = "The game speed is {value}";

		public const string resultSetText = "Set the game speed to {value}";

		private GameSpeed()
		{
		}

		public override void Register()
		{
			ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "gamespeed")).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "get")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				float gameSpeed = LCheatNetworkHandler.GetGameSpeed();
				x.Source.SendCommandResult("The game speed is {value}".Replace("{value}", gameSpeed.ToString()), false);
				return Mathf.RoundToInt(LCheatNetworkHandler.GetGameSpeed() * 100f);
			})))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "set")).Then<ArgumentCommandNode<ServerCommandSource, float>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, float>, ArgumentCommandNode<ServerCommandSource, float>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, float>(x, "timescale", (ArgumentType<float>)(object)RuniArguments.Float(0f, 100f))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				float @float = RuniArguments.GetFloat<ServerCommandSource>(x, "timescale");
				LCheatNetworkHandler.SetGameSpeed(@float);
				x.Source.SendCommandResult("Set the game speed to {value}".Replace("{value}", @float.ToString()), true);
				return Mathf.RoundToInt(@float * 100f);
			})))))));
		}
	}
	public sealed class Invincibility : ServerCommand
	{
		private Invincibility()
		{
		}

		public override void Register()
		{
		}
	}
	public sealed class Kill : ServerCommand
	{
		public const string resultText = "Killed {targets}";

		private Kill()
		{
		}

		public override void Register()
		{
			ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "kill")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				if ((Object)(object)x.Source.sender != (Object)null)
				{
					LCheatNetworkHandler.KillEntity(x.Source.sender);
					x.Source.SendCommandResult("Killed {targets}".Replace("{targets}", BFLCUtility.GetEntityName(x.Source.sender)), true);
					return 1;
				}
				return 0;
			})).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (ArgumentType<SelectorArgumentValue>)(object)RuniArguments.Selector(false, false))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				SelectorArgumentValue selector = RuniArguments.GetSelector<ServerCommandSource>(x, "targets");
				IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
				int num = 0;
				foreach (NetworkBehaviour item in entitys)
				{
					if ((item is PlayerControllerB || item is EnemyAI) ? true : false)
					{
						try
						{
							LCheatNetworkHandler.KillEntity(item);
							num++;
						}
						catch (Exception data)
						{
							Debug.LogError(data);
						}
					}
				}
				x.Source.SendCommandResult("Killed {targets}".Replace("{targets}", BFLCUtility.GetEntityName(entitys, num)), true);
				return num;
			})))));
		}
	}
	public sealed class Summon : ServerCommand
	{
		public const string resultText = "Summoned new {name}";

		private Summon()
		{
		}

		public override void Register()
		{
			ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "summon")).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "enemy")).Then<ArgumentCommandNode<ServerCommandSource, EnemyType>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, EnemyType>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, EnemyType>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, EnemyType>, ArgumentCommandNode<ServerCommandSource, EnemyType>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, EnemyType>, ArgumentCommandNode<ServerCommandSource, EnemyType>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, EnemyType>(x, "entity", (ArgumentType<EnemyType>)(object)RuniArguments.EnemyType())).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				EnemyType enemyType2 = RuniArguments.GetEnemyType<ServerCommandSource>(x, "entity");
				LCheatNetworkHandler.SummonEntity(enemyType2, x.Source.position);
				x.Source.SendCommandResult("Summoned new {name}".Replace("{name}", enemyType2.enemyName), true);
				return 1;
			})).Then<ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, CoordinatesArgumentValue<float>[]>(x, "location", (ArgumentType<CoordinatesArgumentValue<float>[]>)(object)RuniArguments.Vector3((float?)null, (float?)null, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				EnemyType enemyType = RuniArguments.GetEnemyType<ServerCommandSource>(x, "entity");
				Vector3 vector4 = RuniArguments.GetVector3<ServerCommandSource>(x, "location");
				LCheatNetworkHandler.SummonEntity(enemyType, vector4);
				x.Source.SendCommandResult("Summoned new {name}".Replace("{name}", enemyType.enemyName), true);
				return 1;
			})))))))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "anomaly")).Then<ArgumentCommandNode<ServerCommandSource, AnomalyType>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, AnomalyType>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, AnomalyType>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, AnomalyType>, ArgumentCommandNode<ServerCommandSource, AnomalyType>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, AnomalyType>, ArgumentCommandNode<ServerCommandSource, AnomalyType>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, AnomalyType>(x, "entity", (ArgumentType<AnomalyType>)(object)RuniArguments.AnomalyType())).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				AnomalyType anomalyType2 = RuniArguments.GetAnomalyType<ServerCommandSource>(x, "entity");
				LCheatNetworkHandler.SummonEntity(anomalyType2, x.Source.position);
				x.Source.SendCommandResult("Summoned new {name}".Replace("{name}", anomalyType2.anomalyName), true);
				return 1;
			})).Then<ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, CoordinatesArgumentValue<float>[]>(x, "location", (ArgumentType<CoordinatesArgumentValue<float>[]>)(object)RuniArguments.Vector3((float?)null, (float?)null, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				AnomalyType anomalyType = RuniArguments.GetAnomalyType<ServerCommandSource>(x, "entity");
				Vector3 vector3 = RuniArguments.GetVector3<ServerCommandSource>(x, "location");
				LCheatNetworkHandler.SummonEntity(anomalyType, vector3);
				x.Source.SendCommandResult("Summoned new {name}".Replace("{name}", anomalyType.anomalyName), true);
				return 1;
			})))))))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "item")).Then<ArgumentCommandNode<ServerCommandSource, Item>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, Item>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, Item>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, Item>, ArgumentCommandNode<ServerCommandSource, Item>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, Item>, ArgumentCommandNode<ServerCommandSource, Item>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, Item>, ArgumentCommandNode<ServerCommandSource, Item>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, Item>(x, "item", (ArgumentType<Item>)(object)RuniArguments.ItemType())).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				Item itemType4 = RuniArguments.GetItemType<ServerCommandSource>(x, "item");
				LCheatNetworkHandler.SummonEntity(itemType4, x.Source.position);
				x.Source.SendCommandResult("Summoned new {name}".Replace("{name}", itemType4.itemName), true);
				return 1;
			})).Then<ArgumentCommandNode<ServerCommandSource, int>>((IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "price", (ArgumentType<int>)(object)RuniArguments.Integer(int.MinValue, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				Item itemType3 = RuniArguments.GetItemType<ServerCommandSource>(x, "item");
				int integer2 = RuniArguments.GetInteger<ServerCommandSource>(x, "price");
				LCheatNetworkHandler.SummonEntity(itemType3, x.Source.position, integer2);
				x.Source.SendCommandResult("Summoned new {name}".Replace("{name}", itemType3.itemName), true);
				return 1;
			}))).Then<ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, CoordinatesArgumentValue<float>[]>(x, "location", (ArgumentType<CoordinatesArgumentValue<float>[]>)(object)RuniArguments.Vector3((float?)null, (float?)null, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				Item itemType2 = RuniArguments.GetItemType<ServerCommandSource>(x, "item");
				Vector3 vector2 = RuniArguments.GetVector3<ServerCommandSource>(x, "location");
				LCheatNetworkHandler.SummonEntity(itemType2, vector2);
				x.Source.SendCommandResult("Summoned new {name}".Replace("{name}", itemType2.itemName), true);
				return 1;
			})).Then<ArgumentCommandNode<ServerCommandSource, int>>((IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "price", (ArgumentType<int>)(object)RuniArguments.Integer(int.MinValue, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				Item itemType = RuniArguments.GetItemType<ServerCommandSource>(x, "item");
				Vector3 vector = RuniArguments.GetVector3<ServerCommandSource>(x, "location");
				int integer = RuniArguments.GetInteger<ServerCommandSource>(x, "price");
				LCheatNetworkHandler.SummonEntity(itemType, vector, integer);
				x.Source.SendCommandResult("Summoned new {name}".Replace("{name}", itemType.itemName), true);
				return 1;
			}))))))))));
		}
	}
	public sealed class Teleport : ServerCommand
	{
		public const string resultEntityText = "Teleported {targets} to {destination}";

		public const string resultLocationText = "Teleported {targets} to {x}, {y}, {z}";

		private Teleport()
		{
		}

		public override void Register()
		{
			LiteralCommandNode<ServerCommandSource> node = ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "teleport")).Then<ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, CoordinatesArgumentValue<float>[]>(x, "location", (ArgumentType<CoordinatesArgumentValue<float>[]>)(object)RuniArguments.Vector3((float?)null, (float?)null, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)x.Source.sender != (Object)null)
				{
					Vector3 vector2 = RuniArguments.GetVector3<ServerCommandSource>(x, "location");
					LCheatNetworkHandler.TeleportEntity(x.Source.sender, vector2);
					x.Source.SendCommandResult("Teleported {targets} to {x}, {y}, {z}".Replace("{targets}", BFLCUtility.GetEntityName(x.Source.sender)).Replace("{x}", vector2.x.ToString()).Replace("{y}", vector2.y.ToString())
						.Replace("{z}", vector2.z.ToString()), true);
					return 1;
				}
				return 0;
			})))).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "destination", (ArgumentType<SelectorArgumentValue>)(object)RuniArguments.Selector(false, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)x.Source.sender != (Object)null)
				{
					SelectorArgumentValue selector3 = RuniArguments.GetSelector<ServerCommandSource>(x, "destination");
					IEnumerable<NetworkBehaviour> entitys4 = ((SelectorArgumentValue)(ref selector3)).GetEntitys(x.Source);
					if (LinqExtras.CountIsOne<NetworkBehaviour>(entitys4))
					{
						LCheatNetworkHandler.TeleportEntity(x.Source.sender, ((Component)entitys4.First()).transform.position);
						x.Source.SendCommandResult("Teleported {targets} to {destination}".Replace("{targets}", BFLCUtility.GetEntityName(x.Source.sender)).Replace("{destination}", BFLCUtility.GetEntityName(entitys4, -1)), true);
						return 1;
					}
				}
				return 0;
			})))).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (ArgumentType<SelectorArgumentValue>)(object)RuniArguments.Selector(false, false))).Then<ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, CoordinatesArgumentValue<float>[]>(x, "location", (ArgumentType<CoordinatesArgumentValue<float>[]>)(object)RuniArguments.Vector3((float?)null, (float?)null, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				SelectorArgumentValue selector2 = RuniArguments.GetSelector<ServerCommandSource>(x, "targets");
				IEnumerable<NetworkBehaviour> entitys3 = ((SelectorArgumentValue)(ref selector2)).GetEntitys(x.Source);
				Vector3 vector = RuniArguments.GetVector3<ServerCommandSource>(x, "location");
				int num2 = 0;
				foreach (NetworkBehaviour item in entitys3)
				{
					LCheatNetworkHandler.TeleportEntity(item, vector);
					num2++;
				}
				x.Source.SendCommandResult("Teleported {targets} to {x}, {y}, {z}".Replace("{targets}", BFLCUtility.GetEntityName(entitys3, num2)).Replace("{x}", vector.x.ToString()).Replace("{y}", vector.y.ToString())
					.Replace("{z}", vector.z.ToString()), true);
				return num2;
			})))).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "destination", (ArgumentType<SelectorArgumentValue>)(object)RuniArguments.Selector(false, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				SelectorArgumentValue selector = RuniArguments.GetSelector<ServerCommandSource>(x, "targets");
				IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
				selector = RuniArguments.GetSelector<ServerCommandSource>(x, "destination");
				IEnumerable<NetworkBehaviour> entitys2 = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
				if (LinqExtras.CountIsOne<NetworkBehaviour>(entitys2))
				{
					Vector3 position = ((Component)entitys2.First()).transform.position;
					int num = 0;
					foreach (NetworkBehaviour item2 in entitys)
					{
						LCheatNetworkHandler.TeleportEntity(item2, position);
						num++;
					}
					x.Source.SendCommandResult("Teleported {targets} to {destination}".Replace("{targets}", BFLCUtility.GetEntityName(entitys, num)).Replace("{destination}", BFLCUtility.GetEntityName(entitys2, -1)), true);
					return num;
				}
				return 0;
			})))))));
			ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "tp")).Redirect((CommandNode<ServerCommandSource>)(object)node)));
		}
	}
	public sealed class Tellraw : ServerCommand
	{
		private Tellraw()
		{
		}

		public override void Register()
		{
			ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "tellraw")).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (ArgumentType<SelectorArgumentValue>)(object)RuniArguments.Selector(true, false))).Then<ArgumentCommandNode<ServerCommandSource, string>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, string>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, string>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, string>, ArgumentCommandNode<ServerCommandSource, string>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, string>(x, "message", (ArgumentType<string>)(object)RuniArguments.GreedyString())).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				SelectorArgumentValue selector = RuniArguments.GetSelector<ServerCommandSource>(x, "targets");
				IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
				string @string = RuniArguments.GetString<ServerCommandSource>(x, "message");
				int result = 0;
				foreach (NetworkBehaviour item in entitys)
				{
					PlayerControllerB val = (PlayerControllerB)(object)((item is PlayerControllerB) ? item : null);
					if (val != null)
					{
						BFLCNetworkHandler.AddChat(@string, val);
					}
				}
				return result;
			})))))));
		}
	}
	public sealed class Time : ServerCommand
	{
		public const string resultGetText = "The time is {h}:{m} ({value})";

		public const string resultSetText = "Set the time to {h}:{m} ({value})";

		public const string resultSpeedGetText = "The time speed is {value}";

		public const string resultSpeedSetText = "Set the time speed to {value}";

		private Time()
		{
		}

		public override void Register()
		{
			ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "time")).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "get")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				float timeHour = LCheatNetworkHandler.GetTimeHour();
				int num3 = Mathf.FloorToInt(timeHour);
				int num4 = (int)((timeHour - (float)num3) * 60f);
				x.Source.SendCommandResult("The time is {h}:{m} ({value})".Replace("{h}", num3.ToString()).Replace("{m}", num4.ToString("00")).Replace("{value}", timeHour.ToString()), false);
				return num3;
			})))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "set")).Then<ArgumentCommandNode<ServerCommandSource, float>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, float>, ArgumentCommandNode<ServerCommandSource, float>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, float>(x, "time", (ArgumentType<float>)(object)RuniArguments.Float(6f, 24f))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				float float2 = RuniArguments.GetFloat<ServerCommandSource>(x, "time");
				LCheatNetworkHandler.SetTimeHour(float2);
				int num = Mathf.FloorToInt(float2);
				int num2 = (int)((float2 - (float)num) * 60f);
				x.Source.SendCommandResult("Set the time to {h}:{m} ({value})".Replace("{h}", num.ToString()).Replace("{m}", num2.ToString("00")).Replace("{value}", float2.ToString()), false);
				return num;
			})))))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "speed")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				float timeSpeed = LCheatNetworkHandler.GetTimeSpeed();
				x.Source.SendCommandResult("The time speed is {value}".Replace("{value}", timeSpeed.ToString()), false);
				return Mathf.FloorToInt(timeSpeed);
			})).Then<ArgumentCommandNode<ServerCommandSource, float>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, float>, ArgumentCommandNode<ServerCommandSource, float>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, float>(x, "speed", (ArgumentType<float>)(object)RuniArguments.Float(float.MinValue, float.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
			{
				float @float = RuniArguments.GetFloat<ServerCommandSource>(x, "speed");
				LCheatNetworkHandler.SetTimeSpeed(@float);
				x.Source.SendCommandResult("Set the time speed to {value}".Replace("{value}", @float.ToString()), true);
				return Mathf.FloorToInt(@float);
			})))))));
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace Lethal Cheat.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}