using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.IL2CPP;
using BepInEx.Logging;
using CrabDevKit.Utilities;
using HarmonyLib;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using PermissionGroups;
using PersistentData;
using SteamworksNative;
using UnhollowerBaseLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[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: 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;
		}
	}
}
namespace ChatCommands
{
	public static class Api
	{
		internal static Dictionary<string, BaseCommand> commands = new Dictionary<string, BaseCommand>();

		internal static Dictionary<string, BaseExecutionMethod> executionMethods = new Dictionary<string, BaseExecutionMethod>();

		public static string CommandPrefix { get; internal set; }

		public static BaseExecutionMethod DefaultExecutionMethod { get; internal set; }

		public static CommandArgumentParser CommandArgumentParser { get; internal set; }

		public static bool RegisterCommand(BaseCommand command)
		{
			if (HasCommand(command.Id))
			{
				return false;
			}
			commands.Add(command.Id, command);
			return true;
		}

		public static bool HasCommand(string commandId)
		{
			return commands.ContainsKey(commandId);
		}

		public static BaseCommand GetCommand(string commandId)
		{
			if (!HasCommand(commandId))
			{
				return null;
			}
			return commands[commandId];
		}

		public static BaseCommand[] GetCommands()
		{
			return commands.Values.ToArray();
		}

		public static bool RegisterExecutionMethod(BaseExecutionMethod executionMethod)
		{
			if (HasExecutionMethod(executionMethod.Id))
			{
				return false;
			}
			executionMethods.Add(executionMethod.Id, executionMethod);
			return true;
		}

		public static bool HasExecutionMethod(string executionMethodId)
		{
			return executionMethods.ContainsKey(executionMethodId);
		}

		public static BaseExecutionMethod GetExecutionMethod(string executionMethodId)
		{
			if (!HasExecutionMethod(executionMethodId))
			{
				return null;
			}
			return executionMethods[executionMethodId];
		}

		public static BaseExecutionMethod[] GetExecutionMethods()
		{
			return executionMethods.Values.ToArray();
		}

		public static BaseCommandResponse HandleInput(BaseExecutionMethod executionMethod, object executorDetails, string input, bool ignorePermissions = false)
		{
			CommandArgumentParser.ParsedResult<BaseCommand> parsedResult = CommandArgumentParser.Parse<BaseCommand>(input);
			if (!parsedResult.successful || (!ignorePermissions && !executionMethod.HasPermission(executorDetails, "command." + parsedResult.result.Id)))
			{
				return new BasicCommandResponse(new string[1] { "'" + parsedResult.parsedArg + "' is not a command." }, CommandResponseType.Private);
			}
			return parsedResult.result.Execute(executionMethod, executorDetails, parsedResult.newArgs, ignorePermissions);
		}
	}
	public class CommandArgumentParser
	{
		public struct ParsedResult<T>
		{
			public T result;

			public string parsedArg;

			public string newArgs;

			public bool successful;

			public ParsedResult(T result, string parsedArg, string newArgs, bool successful)
			{
				this.result = result;
				this.parsedArg = parsedArg;
				this.newArgs = newArgs;
				this.successful = successful;
			}
		}

		public struct GenericParsedResult
		{
			public string parsedArg;

			public string newArgs;

			public bool successful;

			public GenericParsedResult(string parsedArg, string newArgs, bool successful)
			{
				this.parsedArg = parsedArg;
				this.newArgs = newArgs;
				this.successful = successful;
			}
		}

		public struct OptionsResult
		{
			public string[] options;

			public string parsedArg;

			public string newArgs;

			public bool valid;

			public OptionsResult(string[] options, string parsedArg, string newArgs, bool valid)
			{
				this.options = options;
				this.parsedArg = parsedArg;
				this.newArgs = newArgs;
				this.valid = valid;
			}
		}

		public delegate object ParserDelegate(ref string args, out string parsedArg, out bool successful);

		public delegate string[] OptionDelegate(ref string args, out string parsedArg, out bool valid);

		internal Dictionary<Type, ParserDelegate> parsers;

		internal Dictionary<Type, OptionDelegate> options;

		internal CommandArgumentParser()
		{
			parsers = new Dictionary<Type, ParserDelegate>();
			options = new Dictionary<Type, OptionDelegate>();
			RegisterType(typeof(string), DefaultCommandArgumentParsers.ParseString, DefaultCommandArgumentParsers.StringOptions);
			RegisterType(typeof(DefaultCommandArgumentParsers.Default), DefaultCommandArgumentParsers.ParseDefault, DefaultCommandArgumentParsers.DefaultOptions);
			RegisterType(typeof(DefaultCommandArgumentParsers.Reset), DefaultCommandArgumentParsers.ParseReset, DefaultCommandArgumentParsers.ResetOptions);
			RegisterType(typeof(DefaultCommandArgumentParsers.QuotedString), DefaultCommandArgumentParsers.ParseQuotedString, DefaultCommandArgumentParsers.QuotedStringOptions);
			RegisterType(typeof(bool), DefaultCommandArgumentParsers.ParseBoolean, DefaultCommandArgumentParsers.BooleanOptions);
			RegisterType(typeof(int), DefaultCommandArgumentParsers.ParseInt, DefaultCommandArgumentParsers.IntOptions);
			RegisterType(typeof(float), DefaultCommandArgumentParsers.ParseFloat, DefaultCommandArgumentParsers.FloatOptions);
			RegisterType(typeof(Map), DefaultCommandArgumentParsers.ParseMap, DefaultCommandArgumentParsers.MapOptions);
			RegisterType(typeof(GameModeData), DefaultCommandArgumentParsers.ParseGameMode, DefaultCommandArgumentParsers.GameModeOptions);
			RegisterType(typeof(ItemData), DefaultCommandArgumentParsers.ParseItem, DefaultCommandArgumentParsers.ItemOptions);
			RegisterType(typeof(DefaultCommandArgumentParsers.OnlineClientId), DefaultCommandArgumentParsers.ParseOnlineClientId, DefaultCommandArgumentParsers.OnlineClientIdOptions);
			RegisterType(typeof(DefaultCommandArgumentParsers.OnlineClientId[]), DefaultCommandArgumentParsers.ParseOnlineClientIds, DefaultCommandArgumentParsers.OnlineClientIdsOptions);
			RegisterType(typeof(DefaultCommandArgumentParsers.OfflineClientId), DefaultCommandArgumentParsers.ParseOfflineClientId, DefaultCommandArgumentParsers.OfflineClientIdOptions);
			RegisterType(typeof(BaseCommand), DefaultCommandArgumentParsers.ParseCommand, DefaultCommandArgumentParsers.CommandOptions);
		}

		public ParsedResult<T> Parse<T>(string args)
		{
			if (!parsers.ContainsKey(typeof(T)))
			{
				return new ParsedResult<T>(default(T), null, args, successful: false);
			}
			string parsedArg;
			bool successful;
			return new ParsedResult<T>((T)parsers[typeof(T)](ref args, out parsedArg, out successful), parsedArg, args, successful);
		}

		public GenericParsedResult GenericParse(Type type, string args)
		{
			if (!parsers.ContainsKey(type))
			{
				return new GenericParsedResult(null, args, successful: false);
			}
			parsers[type](ref args, out var parsedArg, out var successful);
			return new GenericParsedResult(parsedArg, args, successful);
		}

		public OptionsResult Options<T>(string args)
		{
			if (!options.ContainsKey(typeof(T)))
			{
				return new OptionsResult(null, null, args, valid: false);
			}
			string parsedArg;
			bool valid;
			return new OptionsResult(options[typeof(T)](ref args, out parsedArg, out valid), parsedArg, args, valid);
		}

		public OptionsResult GenericOptions(Type type, string args)
		{
			if (!options.ContainsKey(type))
			{
				return new OptionsResult(null, null, args, valid: false);
			}
			string parsedArg;
			bool valid;
			return new OptionsResult(options[type](ref args, out parsedArg, out valid), parsedArg, args, valid);
		}

		public bool RegisterType(Type type, ParserDelegate parserDelegate, OptionDelegate optionDelegate)
		{
			if (HasType(type))
			{
				return false;
			}
			parsers.Add(type, parserDelegate);
			options.Add(type, optionDelegate);
			return true;
		}

		public bool HasType(Type type)
		{
			return parsers.ContainsKey(type);
		}

		public Type[] GetTypes()
		{
			return parsers.Keys.ToArray();
		}
	}
	public static class DefaultCommandArgumentParsers
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct Default
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct Reset
		{
		}

		public struct QuotedString
		{
			public string qs;

			public QuotedString(string qs)
			{
				this.qs = qs;
			}

			public static implicit operator string(QuotedString qs)
			{
				return qs.qs;
			}
		}

		public struct OnlineClientId
		{
			public ulong clientId;

			public OnlineClientId(ulong clientId)
			{
				this.clientId = clientId;
			}

			public static implicit operator ulong(OnlineClientId onlineClientId)
			{
				return onlineClientId.clientId;
			}
		}

		public struct OfflineClientId
		{
			public ulong clientId;

			public OfflineClientId(ulong clientId)
			{
				this.clientId = clientId;
			}

			public static implicit operator ulong(OfflineClientId offlineClientId)
			{
				return offlineClientId.clientId;
			}
		}

		public static object ParseString(ref string args, out string parsedArg, out bool successful)
		{
			if (args.Length == 0)
			{
				parsedArg = string.Empty;
				successful = false;
				return null;
			}
			int num = args.IndexOf(' ');
			if (num == -1)
			{
				num = args.Length;
			}
			string text = args.Substring(0, num);
			string text2 = args;
			int num2 = Math.Min(num + 1, args.Length);
			args = text2.Substring(num2, text2.Length - num2);
			parsedArg = text;
			successful = true;
			return text;
		}

		public static string[] StringOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<string> parsedResult = Api.CommandArgumentParser.Parse<string>(args);
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			valid = parsedResult.successful;
			return Array.Empty<string>();
		}

		public static object ParseDefault(ref string args, out string parsedArg, out bool successful)
		{
			CommandArgumentParser.ParsedResult<string> parsedResult = Api.CommandArgumentParser.Parse<string>(args);
			if (!parsedResult.successful)
			{
				parsedArg = string.Empty;
				successful = false;
				return false;
			}
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			successful = parsedResult.result == "default";
			return new Default();
		}

		public static string[] DefaultOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<Default> parsedResult = Api.CommandArgumentParser.Parse<Default>(args);
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			valid = parsedResult.successful;
			return new string[1] { "default" };
		}

		public static object ParseReset(ref string args, out string parsedArg, out bool successful)
		{
			CommandArgumentParser.ParsedResult<string> parsedResult = Api.CommandArgumentParser.Parse<string>(args);
			if (!parsedResult.successful)
			{
				parsedArg = string.Empty;
				successful = false;
				return false;
			}
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			successful = parsedResult.result == "reset";
			return new Reset();
		}

		public static string[] ResetOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<Reset> parsedResult = Api.CommandArgumentParser.Parse<Reset>(args);
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			valid = parsedResult.successful;
			return new string[1] { "reset" };
		}

		public static object ParseQuotedString(ref string args, out string parsedArg, out bool successful)
		{
			if (args.Length == 0)
			{
				parsedArg = string.Empty;
				successful = false;
				return default(QuotedString);
			}
			string[] array = args.Split(' ');
			int num = 1;
			string text2;
			if (array[0].StartsWith('"'))
			{
				string text = array[0];
				array[0] = text.Substring(1, text.Length - 1);
				string[] array2 = array;
				for (int i = 0; i < array2.Length && !array2[i].EndsWith('"'); i++)
				{
					num++;
				}
				text2 = string.Join(' ', array[..num]);
				if (text2.EndsWith('"'))
				{
					text2 = text2.Substring(0, text2.Length - 1);
				}
			}
			else
			{
				text2 = array[0];
			}
			args = string.Join(' ', array[num..]);
			parsedArg = text2;
			successful = true;
			return new QuotedString(text2);
		}

		public static string[] QuotedStringOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<QuotedString> parsedResult = Api.CommandArgumentParser.Parse<QuotedString>(args);
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			valid = parsedResult.successful;
			return Array.Empty<string>();
		}

		public static object ParseBoolean(ref string args, out string parsedArg, out bool successful)
		{
			CommandArgumentParser.ParsedResult<string> parsedResult = Api.CommandArgumentParser.Parse<string>(args);
			if (!parsedResult.successful)
			{
				parsedArg = string.Empty;
				successful = false;
				return false;
			}
			bool flag = "true".StartsWith(parsedResult.result);
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			successful = flag || "false".StartsWith(parsedResult.result);
			return flag;
		}

		public static string[] BooleanOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<bool> result = Api.CommandArgumentParser.Parse<bool>(args);
			args = result.newArgs;
			parsedArg = result.parsedArg;
			valid = result.successful;
			return new string[2] { "true", "false" }.Where((string str) => str.StartsWith(result.parsedArg)).ToArray();
		}

		public static object ParseInt(ref string args, out string parsedArg, out bool successful)
		{
			CommandArgumentParser.ParsedResult<string> parsedResult = Api.CommandArgumentParser.Parse<string>(args);
			if (!parsedResult.successful)
			{
				parsedArg = string.Empty;
				successful = false;
				return 0;
			}
			args = parsedResult.newArgs;
			parsedArg = parsedResult.result;
			successful = int.TryParse(parsedResult.result, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture.NumberFormat, out var result);
			return result;
		}

		public static string[] IntOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<int> parsedResult = Api.CommandArgumentParser.Parse<int>(args);
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			valid = parsedResult.successful;
			return Array.Empty<string>();
		}

		public static object ParseFloat(ref string args, out string parsedArg, out bool successful)
		{
			CommandArgumentParser.ParsedResult<string> parsedResult = Api.CommandArgumentParser.Parse<string>(args);
			if (!parsedResult.successful)
			{
				parsedArg = string.Empty;
				successful = false;
				return 0f;
			}
			args = parsedResult.newArgs;
			parsedArg = parsedResult.result;
			successful = float.TryParse(parsedResult.result, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture.NumberFormat, out var result);
			return result;
		}

		public static string[] FloatOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<float> parsedResult = Api.CommandArgumentParser.Parse<float>(args);
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			valid = parsedResult.successful;
			return Array.Empty<string>();
		}

		public static object ParseMap(ref string args, out string parsedArg, out bool successful)
		{
			if (args.Length == 0)
			{
				parsedArg = string.Empty;
				successful = false;
				return null;
			}
			CommandArgumentParser.ParsedResult<int> parsedResult = Api.CommandArgumentParser.Parse<int>(args);
			successful = parsedResult.successful;
			if (successful)
			{
				args = parsedResult.newArgs;
				if (parsedResult.result < 0 || parsedResult.result >= ((Il2CppArrayBase<Map>)(object)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.maps).Count)
				{
					parsedArg = string.Empty;
					successful = false;
					return null;
				}
				parsedArg = parsedResult.parsedArg;
				successful = true;
				return ((Il2CppArrayBase<Map>)(object)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.maps)[parsedResult.result];
			}
			CommandArgumentParser.ParsedResult<string> parsedResult2 = Api.CommandArgumentParser.Parse<string>(args);
			parsedResult2.result = parsedResult2.result.ToLower();
			args = parsedResult2.newArgs;
			parsedArg = parsedResult2.parsedArg;
			successful = parsedResult2.successful;
			if (successful)
			{
				foreach (Map item in ((IEnumerable<Map>)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.maps).OrderBy((Map map) => map.mapName))
				{
					if (item.mapName.Replace(" ", string.Empty).ToLower().StartsWith(parsedResult2.result))
					{
						return item;
					}
				}
				successful = false;
			}
			return null;
		}

		public static string[] MapOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<Map> result = Api.CommandArgumentParser.Parse<Map>(args);
			args = result.newArgs;
			parsedArg = result.parsedArg;
			valid = result.successful;
			return (from map in (IEnumerable<Map>)MonoBehaviourPublicObInMamaLi1plMadeMaUnique.Instance.maps
				select map.mapName.Replace(" ", string.Empty).ToLower() into mapName
				where mapName.StartsWith(result.parsedArg)
				orderby mapName
				select mapName).ToArray();
		}

		public static object ParseGameMode(ref string args, out string parsedArg, out bool successful)
		{
			if (args.Length == 0)
			{
				parsedArg = string.Empty;
				successful = false;
				return null;
			}
			CommandArgumentParser.ParsedResult<int> parsedResult = Api.CommandArgumentParser.Parse<int>(args);
			successful = parsedResult.successful;
			if (successful)
			{
				args = parsedResult.newArgs;
				if (parsedResult.result < 0 || parsedResult.result >= ((Il2CppArrayBase<GameModeData>)(object)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.allGameModes).Count)
				{
					parsedArg = string.Empty;
					successful = false;
					return null;
				}
				parsedArg = parsedResult.parsedArg;
				successful = true;
				return ((Il2CppArrayBase<GameModeData>)(object)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.allGameModes)[parsedResult.result];
			}
			CommandArgumentParser.ParsedResult<string> parsedResult2 = Api.CommandArgumentParser.Parse<string>(args);
			parsedResult2.result = parsedResult2.result.ToLower();
			args = parsedResult2.newArgs;
			parsedArg = parsedResult2.parsedArg;
			successful = parsedResult2.successful;
			if (successful)
			{
				foreach (GameModeData item in ((IEnumerable<GameModeData>)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.allGameModes).OrderBy((GameModeData gameMode) => gameMode.modeName))
				{
					if (item.modeName.Replace(" ", string.Empty).ToLower().StartsWith(parsedResult2.result))
					{
						return item;
					}
				}
				successful = false;
			}
			return null;
		}

		public static string[] GameModeOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<GameModeData> result = Api.CommandArgumentParser.Parse<GameModeData>(args);
			args = result.newArgs;
			parsedArg = result.parsedArg;
			valid = result.successful;
			return (from gameMode in (IEnumerable<GameModeData>)MonoBehaviourPublicGadealGaLi1pralObInUnique.Instance.allGameModes
				select gameMode.modeName.Replace(" ", string.Empty).ToLower() into gameModeName
				where gameModeName.StartsWith(result.parsedArg)
				orderby gameModeName
				select gameModeName).ToArray();
		}

		public static object ParseItem(ref string args, out string parsedArg, out bool successful)
		{
			if (args.Length == 0)
			{
				parsedArg = string.Empty;
				successful = false;
				return null;
			}
			CommandArgumentParser.ParsedResult<int> parsedResult = Api.CommandArgumentParser.Parse<int>(args);
			successful = parsedResult.successful;
			if (successful)
			{
				args = parsedResult.newArgs;
				if (parsedResult.result < 0 || parsedResult.result >= MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem.Count)
				{
					parsedArg = string.Empty;
					successful = false;
					return null;
				}
				parsedArg = parsedResult.parsedArg;
				successful = true;
				return MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem[parsedResult.result];
			}
			CommandArgumentParser.ParsedResult<string> parsedResult2 = Api.CommandArgumentParser.Parse<string>(args);
			parsedResult2.result = parsedResult2.result.ToLower();
			args = parsedResult2.newArgs;
			parsedArg = parsedResult2.parsedArg;
			successful = parsedResult2.successful;
			if (successful)
			{
				ValueCollection<int, ItemData> values = MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem.Values;
				List<ItemData> list = new List<ItemData>(values.Count);
				Enumerator<int, ItemData> enumerator = values.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ItemData current = enumerator.Current;
					list.Add(current);
				}
				foreach (ItemData item in list.OrderBy((ItemData item) => item.itemName))
				{
					if (item.itemName.Replace(" ", string.Empty).ToLower().StartsWith(parsedResult2.result))
					{
						return item;
					}
				}
				successful = false;
			}
			return null;
		}

		public static string[] ItemOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<ItemData> result = Api.CommandArgumentParser.Parse<ItemData>(args);
			args = result.newArgs;
			parsedArg = result.parsedArg;
			valid = result.successful;
			ValueCollection<int, ItemData> values = MonoBehaviourPublicDi2InItidGamoObInUnique.idToItem.Values;
			List<ItemData> list = new List<ItemData>(values.Count);
			Enumerator<int, ItemData> enumerator = values.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemData current = enumerator.Current;
				list.Add(current);
			}
			return (from item in list
				select item.itemName.Replace(" ", string.Empty).ToLower() into itemName
				where itemName.StartsWith(result.parsedArg)
				orderby itemName
				select itemName).ToArray();
		}

		public static object ParseOnlineClientId(ref string args, out string parsedArg, out bool successful)
		{
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			if (args.Length == 0)
			{
				parsedArg = string.Empty;
				successful = false;
				return default(OnlineClientId);
			}
			if (args.StartsWith('@'))
			{
				CommandArgumentParser.ParsedResult<string> parsedResult = Api.CommandArgumentParser.Parse<string>(args);
				args = parsedResult.newArgs;
				parsedArg = parsedResult.parsedArg;
				if (parsedResult.successful)
				{
					string result = parsedResult.result;
					ulong result2;
					return new OnlineClientId((successful = ulong.TryParse(result.Substring(1, result.Length - 1), NumberStyles.None, CultureInfo.InvariantCulture.NumberFormat, out result2)) ? result2 : 0);
				}
				successful = false;
				return default(OnlineClientId);
			}
			if (args.StartsWith('#'))
			{
				CommandArgumentParser commandArgumentParser = Api.CommandArgumentParser;
				string result = args;
				CommandArgumentParser.ParsedResult<int> parsedResult2 = commandArgumentParser.Parse<int>(result.Substring(1, result.Length - 1));
				args = parsedResult2.newArgs;
				parsedArg = parsedResult2.parsedArg;
				if (parsedResult2.successful)
				{
					return new OnlineClientId((successful = parsedResult2.result >= 1 && parsedResult2.result <= ((Il2CppArrayBase<ulong>)(object)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.field_Private_ArrayOf_UInt64_0).Length) ? ((Il2CppArrayBase<ulong>)(object)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.field_Private_ArrayOf_UInt64_0)[parsedResult2.result - 1] : 0);
				}
				successful = false;
				return default(OnlineClientId);
			}
			CommandArgumentParser.ParsedResult<QuotedString> parsedResult3 = Api.CommandArgumentParser.Parse<QuotedString>(args);
			args = parsedResult3.newArgs;
			parsedArg = parsedResult3.parsedArg;
			if (parsedResult3.successful)
			{
				ulong num = 0uL;
				Enumerator<ulong, int> enumerator = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID.Keys.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ulong current = enumerator.Current;
					string friendPersonaName = SteamFriends.GetFriendPersonaName(new CSteamID(current));
					if (friendPersonaName.StartsWith(parsedResult3.result))
					{
						num = current;
					}
					if (friendPersonaName == parsedResult3.result)
					{
						num = current;
						break;
					}
				}
				if (num != 0L)
				{
					successful = true;
					return new OnlineClientId(num);
				}
			}
			successful = false;
			return default(OnlineClientId);
		}

		public static string[] OnlineClientIdOptions(ref string args, out string parsedArg, out bool valid)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			CommandArgumentParser.ParsedResult<OnlineClientId> result = Api.CommandArgumentParser.Parse<OnlineClientId>(args);
			args = result.newArgs;
			parsedArg = result.parsedArg;
			valid = result.successful;
			int count = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID.Count;
			string[] array = new string[count * 3];
			int num = 0;
			Enumerator<ulong, int> enumerator = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID.Keys.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ulong current = enumerator.Current;
				string friendPersonaName = SteamFriends.GetFriendPersonaName(new CSteamID(current));
				array[num] = ((friendPersonaName.Contains(' ') || friendPersonaName.Contains('"') || friendPersonaName.StartsWith('@') || friendPersonaName.StartsWith('#')) ? ("\"" + friendPersonaName + "\"") : friendPersonaName);
				array[count + num] = $"#{MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID[current] + 1}";
				array[count * 2 + num++] = $"@{current}";
			}
			return array.Where((string str) => str.StartsWith(result.parsedArg)).ToArray();
		}

		public static object ParseOnlineClientIds(ref string args, out string parsedArg, out bool successful)
		{
			if (args.Length == 0 || !args.StartsWith('*'))
			{
				parsedArg = string.Empty;
				successful = false;
				return null;
			}
			CommandArgumentParser.ParsedResult<string> parsedResult = Api.CommandArgumentParser.Parse<string>(args);
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			if (parsedResult.successful)
			{
				KeyCollection<ulong, int> keys = MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.steamIdToUID.Keys;
				int num = 0;
				ulong[] array = new ulong[keys.Count];
				Enumerator<ulong, int> enumerator = keys.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ulong current = enumerator.Current;
					array[num] = current;
					num++;
				}
				IEnumerable<ulong> source = new <>z__ReadOnlyArray<ulong>(array);
				if (parsedArg == "*")
				{
					successful = true;
					return (from clientId in source
						where MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers.ContainsKey(clientId) && !MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[clientId].dead
						select new OnlineClientId(clientId)).ToArray();
				}
				if (parsedArg == "*d")
				{
					successful = true;
					return (from clientId in source
						where !MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers.ContainsKey(clientId) || MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[clientId].dead
						select new OnlineClientId(clientId)).ToArray();
				}
				if (parsedArg == "*e")
				{
					successful = true;
					return source.Select((ulong clientId) => new OnlineClientId(clientId)).ToArray();
				}
			}
			successful = false;
			return null;
		}

		public static string[] OnlineClientIdsOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<OnlineClientId[]> parsedResult = Api.CommandArgumentParser.Parse<OnlineClientId[]>(args);
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			valid = parsedResult.successful;
			return new string[3] { "*", "*a", "*e" };
		}

		public static object ParseOfflineClientId(ref string args, out string parsedArg, out bool successful)
		{
			if (args.Length == 0 || !args.StartsWith('@'))
			{
				parsedArg = string.Empty;
				successful = false;
				return default(OfflineClientId);
			}
			CommandArgumentParser.ParsedResult<string> parsedResult = Api.CommandArgumentParser.Parse<string>(args);
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			if (parsedResult.successful)
			{
				string result = parsedResult.result;
				ulong result2;
				return new OfflineClientId((successful = ulong.TryParse(result.Substring(1, result.Length - 1), NumberStyles.None, CultureInfo.InvariantCulture.NumberFormat, out result2)) ? result2 : 0);
			}
			successful = false;
			return default(OfflineClientId);
		}

		public static string[] OfflineClientIdOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<OfflineClientId> result = Api.CommandArgumentParser.Parse<OfflineClientId>(args);
			args = result.newArgs;
			parsedArg = result.parsedArg;
			valid = result.successful;
			if (!PersistentDataCompatibility.Enabled)
			{
				return Array.Empty<string>();
			}
			string[] array = new string[PersistentDataCompatibility.GetPersistentClientDataIds().Count];
			int num = 0;
			foreach (ulong persistentClientDataId in PersistentDataCompatibility.GetPersistentClientDataIds())
			{
				array[num++] = $"@{persistentClientDataId}";
			}
			return array.Where((string str) => str.StartsWith(result.parsedArg)).ToArray();
		}

		public static object ParseCommand(ref string args, out string parsedArg, out bool successful)
		{
			CommandArgumentParser.ParsedResult<string> parsedResult = Api.CommandArgumentParser.Parse<string>(args);
			if (!parsedResult.successful)
			{
				parsedArg = string.Empty;
				successful = false;
				return null;
			}
			args = parsedResult.newArgs;
			parsedArg = parsedResult.parsedArg;
			successful = Api.HasCommand(parsedResult.result);
			return Api.GetCommand(parsedResult.result);
		}

		public static string[] CommandOptions(ref string args, out string parsedArg, out bool valid)
		{
			CommandArgumentParser.ParsedResult<BaseCommand> result = Api.CommandArgumentParser.Parse<BaseCommand>(args);
			args = result.newArgs;
			parsedArg = result.parsedArg;
			valid = result.successful;
			return (from command in Api.GetCommands()
				select command.Id into commandId
				where commandId.StartsWith(result.parsedArg)
				select commandId).ToArray();
		}
	}
	public readonly struct CommandArgument
	{
		public readonly Type[] types;

		public readonly string display;

		public readonly bool required;

		public CommandArgument(Type[] types, string display = null, bool required = false)
		{
			this.types = types;
			this.display = display;
			this.required = required;
		}

		public override string ToString()
		{
			return (required ? "<" : "[") + display + (required ? ">" : "]");
		}
	}
	public readonly struct CommandArguments
	{
		public readonly CommandArgument[] args;

		public CommandArguments(CommandArgument[] args)
		{
			this.args = args;
		}

		public override string ToString()
		{
			string[] array = new string[args.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = args[i].ToString();
			}
			return string.Join(" ", array);
		}
	}
	public enum CommandResponseType
	{
		Public,
		Private,
		Hidden
	}
	public abstract class BaseCommandResponse
	{
		protected Dictionary<string, object> data = new Dictionary<string, object>();

		public CommandResponseType CommandResponseType => Get<CommandResponseType>("commandResponseType");

		public BaseCommandResponse(CommandResponseType commandResponseType = CommandResponseType.Public)
		{
			data.Add("commandResponseType", commandResponseType);
		}

		public abstract string[] GetFormattedResponse();

		public T Get<T>(string key)
		{
			if (!data.TryGetValue(key, out var value))
			{
				return default(T);
			}
			return (T)value;
		}
	}
	public class BasicCommandResponse : BaseCommandResponse
	{
		public BasicCommandResponse(string[] lines, CommandResponseType commandResponseType = CommandResponseType.Public)
			: base(commandResponseType)
		{
			data.Add("lines", lines);
		}

		public override string[] GetFormattedResponse()
		{
			return Get<string[]>("lines");
		}
	}
	public class StyledCommandResponse : BasicCommandResponse
	{
		public string Title => Get<string>("title");

		public bool OnlyTitleFirstLine => Get<bool>("onlyTitleFirstLine");

		public StyledCommandResponse(string title, string[] lines, CommandResponseType commandResponseType = CommandResponseType.Public, bool onlyTitleFirstLine = true)
			: base(lines, commandResponseType)
		{
			data.Add("title", title);
			data.Add("onlyTitleFirstLine", onlyTitleFirstLine);
		}

		public override string[] GetFormattedResponse()
		{
			string text = Get<string>("title");
			string[] array = Get<string[]>("lines");
			int num = 0;
			string[] array2 = new string[1 + array.Length];
			array2[num] = text;
			num++;
			ReadOnlySpan<string> readOnlySpan = new ReadOnlySpan<string>(array);
			readOnlySpan.CopyTo(new Span<string>(array2).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			return array2;
		}
	}
	public abstract class BaseCommand
	{
		protected string id;

		protected string description;

		protected CommandArguments args;

		public string Id => id;

		public string Description => description;

		public CommandArguments Args => args;

		public abstract BaseCommandResponse Execute(BaseExecutionMethod executionMethod, object executorDetails, string args, bool ignorePermissions = false);
	}
	public class HelpCommand : BaseCommand
	{
		public HelpCommand()
		{
			id = "help";
			description = "View helpful information about available commands.";
			args = new CommandArguments(new CommandArgument[1]
			{
				new CommandArgument(new Type[2]
				{
					typeof(BaseCommand),
					typeof(int)
				}, "command/page")
			});
		}

		public BaseCommandResponse ShowHelpPage(BaseExecutionMethod executionMethod, object executorDetails, int page = 1, bool ignorePermissions = false)
		{
			if (page < 1)
			{
				return new BasicCommandResponse(new string[1] { "You didn't specify a valid page number." }, CommandResponseType.Private);
			}
			int num = 1;
			int num2 = 0;
			List<string> list = new List<string>(1) { string.Empty };
			BaseCommand[] commands = Api.GetCommands();
			for (int i = 0; i < commands.Length; i++)
			{
				BaseCommand baseCommand = commands[i];
				if (!ignorePermissions && !executionMethod.HasPermission(executorDetails, "command." + baseCommand.Id))
				{
					continue;
				}
				string text = Api.CommandPrefix + baseCommand.Id;
				if (i != commands.Length - 1)
				{
					text += ", ";
				}
				if (list[num2].Length + text.Length - 1 > executionMethod.MaxResponseLength)
				{
					num2++;
					if (num2 == 3)
					{
						if (num + 1 > page)
						{
							break;
						}
						num++;
						num2 = 0;
						list = new List<string>();
					}
					list.Add(string.Empty);
				}
				list[num2] += text;
			}
			if (page != num)
			{
				return new BasicCommandResponse(new string[1] { "You didn't specify a valid page number." }, CommandResponseType.Private);
			}
			return new StyledCommandResponse($"Help Page #{page}", list.ToArray(), CommandResponseType.Private);
		}

		public override BaseCommandResponse Execute(BaseExecutionMethod executionMethod, object executorDetails, string args, bool ignorePermissions = false)
		{
			if (args.Length == 0)
			{
				return ShowHelpPage(executionMethod, executorDetails, 1, ignorePermissions);
			}
			CommandArgumentParser.ParsedResult<int> parsedResult = Api.CommandArgumentParser.Parse<int>(args);
			if (parsedResult.successful)
			{
				return ShowHelpPage(executionMethod, executorDetails, parsedResult.result, ignorePermissions);
			}
			CommandArgumentParser.ParsedResult<BaseCommand> parsedResult2 = Api.CommandArgumentParser.Parse<BaseCommand>(args);
			if (!parsedResult2.successful || (!ignorePermissions && !executionMethod.HasPermission(executorDetails, "command." + parsedResult2.result.Id)))
			{
				return new BasicCommandResponse(new string[1] { "'" + args + "' is not a command." }, CommandResponseType.Private);
			}
			return new StyledCommandResponse("Command Info", new string[2]
			{
				$"!{parsedResult2.result.Id} {parsedResult2.result.Args}",
				parsedResult2.result.Description
			}, CommandResponseType.Private);
		}
	}
	public class SetClientDataCommand : BaseCommand
	{
		public SetClientDataCommand()
		{
			id = "setclientdata";
			description = "Sets the value of a key for a given player.";
			args = new CommandArguments(new CommandArgument[3]
			{
				new CommandArgument(new Type[2]
				{
					typeof(DefaultCommandArgumentParsers.OnlineClientId),
					typeof(DefaultCommandArgumentParsers.OfflineClientId)
				}, "player", required: true),
				new CommandArgument(new Type[1] { typeof(string) }, "key", required: true),
				new CommandArgument(new Type[1] { typeof(DefaultCommandArgumentParsers.QuotedString) }, "value", required: true)
			});
		}

		public override BaseCommandResponse Execute(BaseExecutionMethod executionMethod, object executorDetails, string args, bool ignorePermissions = false)
		{
			if (args.Length == 0)
			{
				return new BasicCommandResponse(new string[1] { "A player is required for the first argument." }, CommandResponseType.Hidden);
			}
			CommandArgumentParser.ParsedResult<DefaultCommandArgumentParsers.OnlineClientId> parsedResult = Api.CommandArgumentParser.Parse<DefaultCommandArgumentParsers.OnlineClientId>(args);
			ulong clientId;
			if (parsedResult.successful)
			{
				clientId = parsedResult.result;
				args = parsedResult.newArgs;
			}
			else
			{
				CommandArgumentParser.ParsedResult<DefaultCommandArgumentParsers.OfflineClientId> parsedResult2 = Api.CommandArgumentParser.Parse<DefaultCommandArgumentParsers.OfflineClientId>(args);
				if (!parsedResult2.successful)
				{
					return new BasicCommandResponse(new string[1] { "You did not select any players." }, CommandResponseType.Hidden);
				}
				clientId = parsedResult2.result;
				args = parsedResult2.newArgs;
			}
			if (args.Length == 0)
			{
				return new BasicCommandResponse(new string[1] { "A key is required for the second argument." }, CommandResponseType.Hidden);
			}
			CommandArgumentParser.ParsedResult<string> parsedResult3 = Api.CommandArgumentParser.Parse<string>(args);
			args = parsedResult3.newArgs;
			if (args.Length == 0)
			{
				return new BasicCommandResponse(new string[1] { "A value is required for the second argument." }, CommandResponseType.Hidden);
			}
			CommandArgumentParser.ParsedResult<DefaultCommandArgumentParsers.QuotedString> parsedResult4 = Api.CommandArgumentParser.Parse<DefaultCommandArgumentParsers.QuotedString>(args);
			if (!parsedResult4.successful)
			{
				return new BasicCommandResponse(new string[1] { "You did not provide a valid value." }, CommandResponseType.Hidden);
			}
			if (!PersistentDataCompatibility.SetClientData(clientId, parsedResult3.result, parsedResult4.result))
			{
				return new BasicCommandResponse(new string[1] { "Unable to save that key/value." }, CommandResponseType.Hidden);
			}
			return new BasicCommandResponse(new string[1] { "Saved." }, CommandResponseType.Hidden);
		}
	}
	public abstract class BaseExecutionMethod
	{
		protected string id;

		public string Id => id;

		public virtual int MaxResponseLength => -1;

		public abstract void SendResponse(object executorDetails, BaseCommandResponse response);

		public abstract bool HasPermission(object executorDetails, string permission);
	}
	public class ChatExecutionMethod : BaseExecutionMethod
	{
		public override int MaxResponseLength => ChatUtil.MaxMessageLength;

		public ChatExecutionMethod()
		{
			id = "chat";
		}

		public override void SendResponse(object executorDetails, BaseCommandResponse response)
		{
			if (response is StyledCommandResponse styledCommandResponse)
			{
				string text = null;
				string[] formattedResponse;
				if (response.CommandResponseType == CommandResponseType.Public)
				{
					formattedResponse = response.GetFormattedResponse();
					foreach (string text2 in formattedResponse)
					{
						if (text == null)
						{
							text = text2;
							continue;
						}
						ChatUtil.SendMessage(text2, (MessageType)2, text, (IEnumerable<ulong>)null);
						if (styledCommandResponse.OnlyTitleFirstLine && text.Length != 0)
						{
							text = string.Empty;
						}
					}
					return;
				}
				formattedResponse = response.GetFormattedResponse();
				foreach (string text3 in formattedResponse)
				{
					if (text == null)
					{
						text = text3;
						continue;
					}
					ChatUtil.SendMessage((ulong)executorDetails, text3, (MessageType)2, text);
					if (styledCommandResponse.OnlyTitleFirstLine && text.Length != 0)
					{
						text = string.Empty;
					}
				}
			}
			else if (response.CommandResponseType == CommandResponseType.Public)
			{
				string[] formattedResponse = response.GetFormattedResponse();
				for (int i = 0; i < formattedResponse.Length; i++)
				{
					ChatUtil.SendMessage(formattedResponse[i], (MessageType)1, (string)null, (IEnumerable<ulong>)null);
				}
			}
			else
			{
				string[] formattedResponse = response.GetFormattedResponse();
				foreach (string text4 in formattedResponse)
				{
					ChatUtil.SendMessage((ulong)executorDetails, text4, (MessageType)1, (string)null);
				}
			}
		}

		public override bool HasPermission(object clientDetails, string permission)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!PermissionGroupsCompatibility.Enabled)
			{
				return (ulong)clientDetails == MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.originalLobbyOwnerId.m_SteamID;
			}
			return PermissionGroupsCompatibility.PermissionGroupHasPermission(PermissionGroupsCompatibility.GetClientPermissionGroup((ulong)clientDetails), permission);
		}
	}
	internal static class PersistentDataCompatibility
	{
		internal static bool? enabled;

		internal static bool Enabled
		{
			get
			{
				if (enabled.HasValue)
				{
					return enabled.Value;
				}
				bool? flag = (enabled = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("lammas123.PersistentData"));
				return flag.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static HashSet<ulong> GetPersistentClientDataIds()
		{
			return Api.PersistentClientDataIds;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static bool SetClientData(ulong clientId, string key, string value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ClientDataFile clientDataFile = Api.GetClientDataFile(clientId);
			bool result = ((ClientDataFile)(ref clientDataFile)).Set(key, value);
			((ClientDataFile)(ref clientDataFile)).SaveFile();
			return result;
		}
	}
	internal static class PermissionGroupsCompatibility
	{
		internal static bool? enabled;

		internal static bool Enabled
		{
			get
			{
				if (enabled.HasValue)
				{
					return enabled.Value;
				}
				bool? flag = (enabled = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("lammas123.PermissionGroups"));
				return flag.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static bool PermissionGroupHasPermission(string permissionGroupId, string permission)
		{
			return Api.PermissionGroupHasPermission(permissionGroupId, permission);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static string GetClientPermissionGroup(ulong clientId)
		{
			return Api.GetClientPermissionGroup(clientId);
		}
	}
	internal static class Patches
	{
		[HarmonyPatch(typeof(MonoBehaviourPublicGataInefObInUnique), "Method_Private_Void_GameObject_Boolean_Vector3_Quaternion_0")]
		[HarmonyPatch(typeof(MonoBehaviourPublicCSDi2UIInstObUIloDiUnique), "Method_Private_Void_0")]
		[HarmonyPrefix]
		internal static bool PreBepinexDetection()
		{
			return false;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicInInUnique), "SendChatMessage")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		internal static bool PreServerSendSendChatMessage(ulong param_0, string param_1, ref BaseCommandResponse __state)
		{
			if (!MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() || param_0 <= 1 || !param_1.StartsWith(Api.CommandPrefix))
			{
				return true;
			}
			BaseExecutionMethod defaultExecutionMethod = Api.DefaultExecutionMethod;
			object executorDetails = param_0;
			int length = Api.CommandPrefix.Length;
			__state = Api.HandleInput(defaultExecutionMethod, executorDetails, param_1.Substring(length, param_1.Length - length));
			return __state.CommandResponseType != CommandResponseType.Hidden;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicInInUnique), "SendChatMessage")]
		[HarmonyPostfix]
		[HarmonyPriority(800)]
		internal static void PostServerSendSendChatMessage(ulong param_0, BaseCommandResponse __state)
		{
			if (__state != null)
			{
				Api.DefaultExecutionMethod.SendResponse(param_0, __state);
			}
		}
	}
	[BepInPlugin("lammas123.ChatCommands", "ChatCommands", "1.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class ChatCommands : BasePlugin
	{
		internal static ChatCommands Instance;

		public override void Load()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
			CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture;
			CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
			CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
			Instance = this;
			Api.CommandPrefix = ((BasePlugin)this).Config.Bind<string>("Chat Commands", "CommandPrefix", "!", "The prefix to use for chat commands.").Value.ToLower();
			Api.CommandArgumentParser = new CommandArgumentParser();
			Api.RegisterCommand(new HelpCommand());
			if (PersistentDataCompatibility.Enabled)
			{
				Api.RegisterCommand(new SetClientDataCommand());
			}
			Api.RegisterExecutionMethod(Api.DefaultExecutionMethod = new ChatExecutionMethod());
			new Harmony("ChatCommands").PatchAll(typeof(Patches));
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(15, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Initialized [");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("ChatCommands");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("1.1.1");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("]");
			}
			log.LogInfo(val);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "lammas123.ChatCommands";

		public const string PLUGIN_NAME = "ChatCommands";

		public const string PLUGIN_VERSION = "1.1.1";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

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

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

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

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

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

	bool ICollection<T>.IsReadOnly => true;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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