using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils;
using GameData;
using HarmonyLib;
using Hikaria.DevConsoleLite.Plugin;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Mono.CSharp;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Hikaria.DevConsole")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Hikaria.DevConsole")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("6445e8e3-afb9-4d0b-82cb-2c79e5995123")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Hikaria.DevConsoleLite
{
	public sealed class Command
	{
		public string Name { get; private set; }

		public string HelpText { get; private set; }

		public bool IsCustomCommand { get; private set; }

		internal string[] Aliases { get; private set; }

		internal Parameter[] Parameters { get; private set; }

		internal Action<object[]> Callback { get; private set; }

		internal Action DefaultCallback { get; private set; }

		public static Command Create(string name, string aliases, string helpText, Action callback)
		{
			Command command = new Command();
			command.Name = name;
			command.Aliases = aliases.Split(new char[1] { ',' });
			command.HelpText = helpText;
			command.Parameters = new Parameter[0];
			command.Callback = delegate
			{
				callback();
			};
			return command;
		}

		public static Command Create<T1>(string name, string aliases, string helpText, Parameter p1, Action<T1> callback, Action defaultCallback = null)
		{
			Command command = new Command();
			command.Name = name;
			command.Aliases = aliases.Split(new char[1] { ',' });
			command.HelpText = helpText;
			command.Parameters = new Parameter[1] { p1.SetType<T1>() };
			command.Callback = delegate(object[] o)
			{
				callback((T1)o[0]);
			};
			command.DefaultCallback = defaultCallback;
			return command;
		}

		public static Command Create<T1, T2>(string name, string aliases, string helpText, Parameter p1, Parameter p2, Action<T1, T2> callback, Action defaultCallback = null)
		{
			Command command = new Command();
			command.Name = name;
			command.Aliases = aliases.Split(new char[1] { ',' });
			command.HelpText = helpText;
			command.Parameters = new Parameter[2]
			{
				p1.SetType<T1>(),
				p2.SetType<T2>()
			};
			command.Callback = delegate(object[] o)
			{
				callback((T1)o[0], (T2)o[1]);
			};
			command.DefaultCallback = defaultCallback;
			return command;
		}

		public static Command Create<T1, T2, T3>(string name, string aliases, string helpText, Parameter p1, Parameter p2, Parameter p3, Action<T1, T2, T3> callback, Action defaultCallback = null)
		{
			Command command = new Command();
			command.Name = name;
			command.Aliases = aliases.Split(new char[1] { ',' });
			command.HelpText = helpText;
			command.Parameters = new Parameter[3]
			{
				p1.SetType<T1>(),
				p2.SetType<T2>(),
				p3.SetType<T3>()
			};
			command.Callback = delegate(object[] o)
			{
				callback((T1)o[0], (T2)o[1], (T3)o[2]);
			};
			command.DefaultCallback = defaultCallback;
			return command;
		}

		public static Command Create<T1, T2, T3, T4>(string name, string aliases, string helpText, Parameter p1, Parameter p2, Parameter p3, Parameter p4, Action<T1, T2, T3, T4> callback, Action defaultCallback = null)
		{
			Command command = new Command();
			command.Name = name;
			command.Aliases = aliases.Split(new char[1] { ',' });
			command.HelpText = helpText;
			command.Parameters = new Parameter[4]
			{
				p1.SetType<T1>(),
				p2.SetType<T2>(),
				p3.SetType<T3>(),
				p4.SetType<T4>()
			};
			command.Callback = delegate(object[] o)
			{
				callback((T1)o[0], (T2)o[1], (T3)o[2], (T4)o[3]);
			};
			command.DefaultCallback = defaultCallback;
			return command;
		}

		public static Command Create<T1, T2, T3, T4, T5>(string name, string aliases, string helpText, Parameter p1, Parameter p2, Parameter p3, Parameter p4, Parameter p5, Action<T1, T2, T3, T4, T5> callback, Action defaultCallback = null)
		{
			Command command = new Command();
			command.Name = name;
			command.Aliases = aliases.Split(new char[1] { ',' });
			command.HelpText = helpText;
			command.Parameters = new Parameter[5]
			{
				p1.SetType<T1>(),
				p2.SetType<T2>(),
				p3.SetType<T3>(),
				p4.SetType<T4>(),
				p5.SetType<T5>()
			};
			command.Callback = delegate(object[] o)
			{
				callback((T1)o[0], (T2)o[1], (T3)o[2], (T4)o[3], (T5)o[4]);
			};
			command.DefaultCallback = defaultCallback;
			return command;
		}

		internal static Command Create(DevConsoleCommandAttribute commandAttribute, MethodInfo method)
		{
			ParameterInfo[] parameters = method.GetParameters();
			Parameter[] array = new Parameter[parameters.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = Parameter.Create(parameters[i].Name, (i < commandAttribute.ParameterHelpText.Length) ? commandAttribute.ParameterHelpText[i] : "");
				array[i].SetType(parameters[i].ParameterType);
			}
			return new Command
			{
				Name = commandAttribute.Name,
				Aliases = commandAttribute.Aliases,
				HelpText = commandAttribute.HelpText,
				Parameters = array,
				Callback = delegate(object[] o)
				{
					method.Invoke(null, o);
				}
			};
		}

		private Command()
		{
		}

		public override string ToString()
		{
			return Name;
		}

		public string ToFormattedString()
		{
			string text = GetFormattedName();
			for (int i = 0; i < Parameters.Length; i++)
			{
				if (i < Parameters.Length)
				{
					text += " ";
				}
				text += GetFormattedParameter(i);
			}
			return text;
		}

		public string GetFormattedName()
		{
			return "<b>" + Name + "</b>";
		}

		public string GetFormattedParameter(int parameterIndex)
		{
			return Parameters[parameterIndex].ToFormattedString();
		}

		public IReadOnlyList<string> GetAliases()
		{
			return Aliases;
		}

		public IReadOnlyList<Parameter> GetParameters()
		{
			return Parameters;
		}

		internal void FixName()
		{
			Name = string.Concat(Name.Where((char c) => !char.IsWhiteSpace(c))).ToLower();
		}

		internal void FixAliases()
		{
			List<string> aliases = new List<string>();
			Array.ForEach(Aliases, delegate(string a)
			{
				string text = string.Concat(a.Where((char c) => !char.IsWhiteSpace(c))).ToLower();
				if (!string.IsNullOrEmpty(text))
				{
					aliases.Add(text);
				}
			});
			if (aliases.Count == 0)
			{
				aliases.Add("");
			}
			Aliases = aliases.ToArray();
		}

		internal bool HasAlias(params string[] aliases)
		{
			if (aliases.Length != 0)
			{
				return aliases.Any((string a) => !string.IsNullOrEmpty(a) && Aliases.Contains(a.ToLower()));
			}
			return false;
		}

		internal void SetAsCustomCommand()
		{
			IsCustomCommand = true;
		}
	}
	public static class DevConsole
	{
		private static DevConsoleMono _console;

		internal static Dictionary<string, Object> s_AssetLookup = new Dictionary<string, Object>();

		public static bool isInit;

		internal static Dictionary<Command, bool> _commandsNeedToAdd = new Dictionary<Command, bool>();

		internal static Dictionary<Type, Func<string, object>> _parametersNeedToAdd = new Dictionary<Type, Func<string, object>>();

		public static bool IsEnabled
		{
			get
			{
				return _console.ConsoleIsEnabled;
			}
			set
			{
				if (value)
				{
					EnableConsole();
				}
				else
				{
					DisableConsole();
				}
			}
		}

		public static bool IsOpen
		{
			get
			{
				return _console.ConsoleIsShowing;
			}
			set
			{
				if (value)
				{
					_console.OpenConsole();
				}
				else
				{
					_console.CloseConsole();
				}
			}
		}

		public static bool IsOpenAndFocused => _console.ConsoleIsShowingAndFocused;

		public static bool IsKeyBindingsEnabled
		{
			get
			{
				return _console.BindingsIsEnabled;
			}
			set
			{
				_console.BindingsIsEnabled = value;
			}
		}

		public static KeyCode? ToggleKey
		{
			get
			{
				return _console.ConsoleToggleKey;
			}
			set
			{
				_console.ConsoleToggleKey = value;
			}
		}

		public static int AverageFps => _console.AverageFps;

		public static float AverageMs => _console.AverageMs;

		public static event Action OnConsoleEnabled;

		public static event Action OnConsoleDisabled;

		public static event Action OnConsoleOpened;

		public static event Action OnConsoleClosed;

		public static event Action OnConsoleFocused;

		public static event Action OnConsoleFocusLost;

		public static bool AddCommand(Command command, bool onlyInDevBuild = false)
		{
			if (command == null)
			{
				throw new ArgumentNullException("command");
			}
			if (isInit)
			{
				return _console.AddCommand(command, onlyInDevBuild, isCustomCommand: true);
			}
			_commandsNeedToAdd.Add(command, onlyInDevBuild);
			return true;
		}

		public static bool RemoveCommand(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				throw new ArgumentNullException("name");
			}
			return _console.RemoveCommand(name);
		}

		public static bool RunCommand(string input)
		{
			if (string.IsNullOrEmpty(input))
			{
				throw new ArgumentNullException("input");
			}
			return _console.RunCommand(input);
		}

		public static Command GetCommand(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				throw new ArgumentNullException("name");
			}
			return _console.GetCommand(name);
		}

		public static bool GetCommand(string name, out Command command)
		{
			if (string.IsNullOrEmpty(name))
			{
				throw new ArgumentNullException("name");
			}
			return _console.GetCommand(name, out command);
		}

		public static bool AddParameterType<T>(Func<string, T> parseFunc)
		{
			if (parseFunc == null)
			{
				throw new ArgumentNullException("parseFunc");
			}
			if (isInit)
			{
				return _console.AddParameterType(typeof(T), (string s) => parseFunc(s));
			}
			_parametersNeedToAdd.Add(typeof(T), (string s) => parseFunc(s));
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Log(object message)
		{
			_console.Log(message);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Log(object message, Color colour)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			_console.Log(message, ColorUtility.ToHtmlStringRGBA(colour));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void LogVariable(string variableName, object value, string suffix = "")
		{
			_console.LogVariable(variableName, value, suffix);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void LogException(Exception exception)
		{
			_console.LogException(exception);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void LogError(object message)
		{
			_console.LogError(message);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void LogWarning(object message)
		{
			_console.LogWarning(message);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void LogSuccess(object message)
		{
			_console.LogSuccess(message);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void LogSeperator(object message = null)
		{
			_console.LogSeperator(message);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void LogCollection<T>(in IReadOnlyCollection<T> collection, Func<T, string> toString = null, string prefix = "", string suffix = "")
		{
			_console.LogCollection(in collection, toString, prefix, suffix);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void LogCommand()
		{
			_console.LogCommand();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void LogCommand(string name)
		{
			_console.LogCommand(name);
		}

		public static void SetToggleKey(KeyCode? toggleKey)
		{
			_console.ConsoleToggleKey = toggleKey;
		}

		public static void DisableToggleKey()
		{
			_console.ConsoleToggleKey = null;
		}

		public static void EnableConsole()
		{
			_console.EnableConsole();
		}

		public static void DisableConsole()
		{
			_console.DisableConsole();
		}

		public static void OpenConsole()
		{
			_console.OpenConsole();
		}

		public static void CloseConsole()
		{
			_console.CloseConsole();
		}

		public static void ClearConsole()
		{
			_console.ClearConsole();
		}

		public static void SetTrackedStat(string name, Func<object> func, bool startEnabled = true)
		{
			_console.SetTrackedStat(name, func, startEnabled);
		}

		public static bool RemoveTrackedStat(string name)
		{
			return _console.RemoveTrackedStat(name);
		}

		public static Coroutine InvokeCoroutine(IEnumerator enumerator)
		{
			return MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)_console, enumerator);
		}

		public static Coroutine InvokeDelayed(Action action, float delay)
		{
			return MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)_console, Invoke());
			IEnumerator Invoke()
			{
				yield return (object)new WaitForSeconds(delay);
				action?.Invoke();
			}
		}

		internal static string GetFriendlyName(Type type)
		{
			if (type.IsGenericType)
			{
				Type underlyingType = Nullable.GetUnderlyingType(type);
				if (underlyingType != null)
				{
					return GetFriendlyName(underlyingType) + "?";
				}
				return type.Name.Split(new char[1] { '`' })[0] + "<" + string.Join(", ", from x in type.GetGenericArguments()
					select GetFriendlyName(x)) + ">";
			}
			return type.Name;
		}

		internal static void InvokeOnConsoleEnabled()
		{
			DevConsole.OnConsoleEnabled?.Invoke();
		}

		internal static void InvokeOnConsoleDisabled()
		{
			DevConsole.OnConsoleDisabled?.Invoke();
		}

		internal static void InvokeOnConsoleOpened()
		{
			DevConsole.OnConsoleOpened?.Invoke();
		}

		internal static void InvokeOnConsoleClosed()
		{
			DevConsole.OnConsoleClosed?.Invoke();
		}

		internal static void InvokeOnConsoleFocused()
		{
			DevConsole.OnConsoleFocused?.Invoke();
		}

		internal static void InvokeOnConsoleFocusLost()
		{
			DevConsole.OnConsoleFocusLost?.Invoke();
		}

		public static void Init()
		{
			if (isInit)
			{
				return;
			}
			isInit = true;
			AssetBundle val = AssetBundle.LoadFromFile(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\devconsole");
			string[] array = Il2CppArrayBase<string>.op_Implicit((Il2CppArrayBase<string>)(object)val.AllAssetNames());
			foreach (string text in array)
			{
				Object val2 = val.LoadAsset(text);
				if (val2 != (Object)null)
				{
					string key = text.ToUpper();
					s_AssetLookup.Add(key, val2);
				}
			}
			_console = Object.Instantiate<GameObject>(((Il2CppObjectBase)s_AssetLookup["ASSETS/UNITY-DEVELOPERCONSOLE/RESOURCES/PREFABS/FAB_DEVCONSOLE.INSTANCE.PREFAB"]).Cast<GameObject>()).AddComponent<DevConsoleMono>();
			foreach (KeyValuePair<Command, bool> item in _commandsNeedToAdd)
			{
				_console.AddCommand(item.Key, item.Value, isCustomCommand: true);
			}
			foreach (KeyValuePair<Type, Func<string, object>> item2 in _parametersNeedToAdd)
			{
				_console.AddParameterType(item2.GetType(), item2.Value);
			}
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = true)]
	public sealed class DevConsoleCommandAttribute : Attribute
	{
		internal string Name { get; }

		internal string[] Aliases { get; }

		internal string HelpText { get; }

		internal string[] ParameterHelpText { get; }

		internal bool OnlyInDevBuild { get; }

		public DevConsoleCommandAttribute(string name, string aliases, string helpText, bool onlyInDevBuild, params string[] parameterHelpText)
		{
			Name = name;
			Aliases = aliases.Split(new char[1] { ',' });
			HelpText = helpText;
			ParameterHelpText = parameterHelpText ?? new string[0];
			OnlyInDevBuild = onlyInDevBuild;
		}

		public DevConsoleCommandAttribute(string name, string aliases, string helpText, params string[] parameterHelpText)
			: this(name, aliases, helpText, onlyInDevBuild: false, parameterHelpText)
		{
		}
	}
	internal static class DevConsoleData
	{
		private static Dictionary<string, object> _data;

		public static string FilePath { get; private set; }

		static DevConsoleData()
		{
			_data = new Dictionary<string, object>();
			FilePath = Paths.ConfigPath + "\\Hikaria\\DevConsole\\DevConsole.dat";
		}

		public static void SetObject(string key, object value)
		{
			_data[key] = value;
		}

		public static T GetObject<T>(string key, T defaultValue)
		{
			try
			{
				return (!_data.ContainsKey(key)) ? defaultValue : ((T)_data[key]);
			}
			catch (Exception)
			{
				return defaultValue;
			}
		}

		public static void Save()
		{
			FileStream fileStream = new FileStream(FilePath, FileMode.Create);
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			try
			{
				binaryFormatter.Serialize(fileStream, _data);
			}
			catch (Exception data)
			{
				Logs.LogError(data);
				Logs.LogError("Failed to save developer console preferences due to an exception.");
			}
			finally
			{
				fileStream.Close();
			}
		}

		public static void Load()
		{
			if (!File.Exists(FilePath))
			{
				return;
			}
			FileStream fileStream = new FileStream(FilePath, FileMode.Open);
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			bool flag = false;
			try
			{
				_data = (Dictionary<string, object>)binaryFormatter.Deserialize(fileStream);
			}
			catch (Exception data)
			{
				Logs.LogError(data);
				flag = true;
			}
			finally
			{
				fileStream.Close();
			}
			if (flag)
			{
				File.Delete(FilePath);
			}
		}

		public static void Clear()
		{
			_data.Clear();
		}
	}
	internal sealed class DevConsoleMono : MonoBehaviour
	{
		private abstract class StatBase
		{
			public abstract string Desc { get; }

			public abstract object GetResult(Evaluator evaluator);

			public abstract override string ToString();
		}

		private sealed class EvaluatedStat : StatBase
		{
			public override string Desc => "Evaluated";

			public string Expression { get; }

			public EvaluatedStat(string expression)
			{
				Expression = expression;
			}

			public override object GetResult(Evaluator evaluator)
			{
				if (evaluator == null)
				{
					return "C# expression evaluation is not supported on this platform.";
				}
				return ((evaluator != null) ? evaluator.Evaluate(Expression) : null) ?? null;
			}

			public override string ToString()
			{
				return Expression;
			}
		}

		private sealed class LambdaStat : StatBase
		{
			private readonly Func<object> _func;

			public override string Desc => "Lambda";

			public LambdaStat(Func<object> func)
			{
				_func = func;
			}

			public override object GetResult(Evaluator _ = null)
			{
				return _func?.Invoke() ?? null;
			}

			public override string ToString()
			{
				return "Cannot be viewed";
			}
		}

		private sealed class ReflectedStat : StatBase
		{
			private readonly FieldInfo _field;

			private readonly PropertyInfo _property;

			public override string Desc => "Reflected";

			public ReflectedStat(FieldInfo field)
			{
				_field = field;
			}

			public ReflectedStat(PropertyInfo property)
			{
				_property = property;
			}

			public override object GetResult(Evaluator _ = null)
			{
				object obj = _field?.GetValue(null);
				if (obj == null)
				{
					PropertyInfo property = _property;
					if ((object)property == null)
					{
						return null;
					}
					obj = property.GetValue(null);
				}
				return obj;
			}

			public override string ToString()
			{
				return _field?.FieldType.Name ?? _property.PropertyType.Name;
			}
		}

		private const string ErrorColour = "#E99497";

		private const string WarningColour = "#DEBF1F";

		private const string SuccessColour = "#B3E283";

		private const string ClearLogText = "Type <b>devconsole</b> for instructions on how to use the developer console.";

		private const int MaximumTextVertices = 64000;

		private const float MinConsoleWidth = 650f;

		private const float MaxConsoleWidth = 1600f;

		private const float MinConsoleHeight = 200f;

		private const float MaxConsoleHeight = 900f;

		private const int MinLogTextSize = 14;

		private const int MaxLogTextSize = 35;

		private const int CommandHistoryLength = 10;

		private const int MaxCachedEnumTypes = 6;

		private const float FpsUpdateRate = 4f;

		private const float StatUpdateRate = 0.1f;

		private const int StatDefaultFontSize = 18;

		private const string MonoNotSupportedText = "C# expression evaluation is not supported on this platform.";

		private const KeyCode DefaultToggleKey = 96;

		private const KeyCode UpArrowKey = 273;

		private const KeyCode DownArrowKey = 274;

		private const KeyCode BackspaceKey = 8;

		private const KeyCode LeftControlKey = 306;

		private const string InputSystemPrefabPath = "ASSETS/UNITY-DEVELOPERCONSOLE/RESOURCES/PREFABS/FAB_DEVCONSOLE.OLDEVENTSYSTEM.PREFAB";

		private const string PrefConsoleToggleKey = "DevConsole.legacyConsoleToggleKey";

		private const string PrefBindings = "DevConsole.legacyBindings";

		private const string PrefDisplayUnityLogs = "DevConsole.displayUnityLogs";

		private const string PrefDisplayUnityErrors = "DevConsole.displayUnityErrors";

		private const string PrefDisplayUnityExceptions = "DevConsole.displayUnityExceptions";

		private const string PrefDisplayUnityWarnings = "DevConsole.displayUnityWarnings";

		private const string PrefShowFps = "DevConsole.displayFps";

		private const string PrefLogTextSize = "DevConsole.logTextSize";

		private const string PrefIncludedUsings = "DevConsole.includedUsings";

		private const string PrefShowStats = "DevConsole.displayStats";

		private const string PrefStats = "DevConsole.stats";

		private const string PrefHiddenStats = "DevConsole.hiddenStats";

		private const string PrefStatsFontSize = "DevConsole.statsFontSize";

		private const string PrefPersistStats = "DevConsole.persistStats";

		private static readonly Version _version = new Version(1, 0, 12);

		private static readonly string[] _permanentCommands = new string[9] { "devconsole", "commands", "help", "print", "clear", "reset", "bind", "unbind", "bindings" };

		private CanvasGroup _canvasGroup;

		private Text _versionText;

		private InputField _inputField;

		private Text _suggestionText;

		private GameObject _logFieldPrefab;

		private RectTransform _logContentTransform;

		private ScrollRect _logScrollView;

		private RectTransform _dynamicTransform;

		private Image _resizeButtonImage;

		private Color _resizeButtonHoverColour;

		private Button _closeButton;

		private Button _decreaseTextSizeButton;

		private Button _increaseTextSizeButton;

		private EventTrigger _resizeButtonEventTrigger;

		private EventTrigger _repositioningButtonEventTrigger;

		private bool _init;

		private bool _focusInputField;

		private bool _oldFocusInputField;

		private Dictionary<KeyCode, string> _bindings = new Dictionary<KeyCode, string>();

		private bool _ignoreCtrlBackspace;

		private readonly List<InputField> _logFields = new List<InputField>();

		private string _logTextStore = "";

		private readonly TextGenerator _textGenerator = new TextGenerator();

		private int _vertexCount;

		private int _initLogTextSize;

		private bool _pretendScrollAtBottom;

		private bool _scrollToBottomNextFrame;

		private bool _repositioning;

		private Vector2 _initPosition;

		private Vector2 _repositionOffset;

		private bool _resizing;

		private Vector2 _initSize;

		private Color _resizeButtonColour;

		private float _initLogFieldWidth;

		private float _currentLogFieldWidth;

		private Vector2Int _screenSize;

		private readonly Dictionary<string, Command> _commands = new Dictionary<string, Command>();

		private readonly Dictionary<Type, Func<string, object>> _parameterParseFuncs = new Dictionary<Type, Func<string, object>>();

		private readonly List<string> _commandHistory = new List<string>(10);

		private string _currentCommand = string.Empty;

		private string _previousCommand = string.Empty;

		private int _commandHistoryIndex = -1;

		private bool _displayUnityLogs = true;

		private bool _displayUnityErrors = true;

		private bool _displayUnityExceptions = true;

		private bool _displayUnityWarnings = true;

		private string[] _commandStringSuggestions;

		private Command[] _commandSuggestions;

		private int _commandSuggestionIndex;

		private readonly List<Type> _cacheEnumTypes = new List<Type>(6);

		private Evaluator _monoEvaluator;

		private List<string> _includedUsings = new List<string>();

		private bool _isDisplayingFps;

		private float _fpsDeltaTime;

		private int _fps;

		private float _fpsMs;

		private float _fpsElapsed;

		private GUIStyle _fpsStyle;

		private Vector2 _fpsLabelSize;

		private Color _fpsTextColour;

		private bool _isDisplayingStats;

		private GUIStyle _statStyle;

		private readonly Dictionary<string, StatBase> _stats = new Dictionary<string, StatBase>();

		private HashSet<string> _hiddenStats = new HashSet<string>();

		private readonly Dictionary<string, object> _cachedStats = new Dictionary<string, object>();

		private List<string> _persistStats = new List<string>();

		private float _statUpdateTime;

		private int _statFontSize = 18;

		internal static CursorLockMode lastLockMode;

		internal static bool lastVisible;

		public static DevConsoleMono Instance { get; private set; }

		internal KeyCode? ConsoleToggleKey { get; set; } = (KeyCode)96;


		internal bool ConsoleIsEnabled { get; private set; }

		internal bool ConsoleIsShowing { get; private set; }

		internal bool ConsoleIsShowingAndFocused
		{
			get
			{
				if (ConsoleIsShowing)
				{
					return _inputField.isFocused;
				}
				return false;
			}
		}

		internal bool BindingsIsEnabled { get; set; } = true;


		internal int AverageFps
		{
			get
			{
				if (!_isDisplayingFps)
				{
					return -1;
				}
				return _fps;
			}
		}

		internal float AverageMs
		{
			get
			{
				if (!_isDisplayingFps)
				{
					return -1f;
				}
				return _fpsMs;
			}
		}

		private string InputText
		{
			get
			{
				return _inputField.text;
			}
			set
			{
				_inputField.text = value;
			}
		}

		private int InputCaretPosition
		{
			get
			{
				return _inputField.caretPosition;
			}
			set
			{
				_inputField.caretPosition = value;
			}
		}

		private string StoredLogText
		{
			get
			{
				lock (_logTextStore)
				{
					return _logTextStore;
				}
			}
			set
			{
				lock (_logTextStore)
				{
					_logTextStore = value;
				}
			}
		}

		private int LogTextSize
		{
			get
			{
				return _logFieldPrefab.GetComponent<InputField>().textComponent.fontSize;
			}
			set
			{
				Text textComponent = _logFieldPrefab.GetComponent<InputField>().textComponent;
				if (textComponent.fontSize == value)
				{
					return;
				}
				textComponent.fontSize = value;
				List<InputField> logFields = _logFields;
				if (logFields != null && logFields.Count > 0)
				{
					_logFields.ForEach(delegate(InputField x)
					{
						x.textComponent.fontSize = value;
					});
					RefreshLogFieldsSize();
				}
			}
		}

		internal void EnableConsole()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (_init || !ConsoleIsEnabled)
			{
				Application.logMessageReceivedThreaded += LogCallback.op_Implicit((Action<string, string, LogType>)OnLogMessageReceived);
				ClearConsole();
				InputText = string.Empty;
				_screenSize = new Vector2Int(Screen.width, Screen.height);
				ConsoleIsEnabled = true;
				((Behaviour)this).enabled = true;
				DevConsole.InvokeOnConsoleEnabled();
			}
		}

		internal void DisableConsole()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (_init || ConsoleIsEnabled)
			{
				if (ConsoleIsShowing)
				{
					CloseConsole();
				}
				_dynamicTransform.anchoredPosition = _initPosition;
				_dynamicTransform.sizeDelta = _initSize;
				_commandHistory.Clear();
				_cacheEnumTypes.Clear();
				ClearConsole();
				Application.logMessageReceived -= LogCallback.op_Implicit((Action<string, string, LogType>)OnLogMessageReceived);
				ConsoleIsEnabled = false;
				((Behaviour)this).enabled = false;
				DevConsole.InvokeOnConsoleDisabled();
			}
		}

		internal void OpenConsole()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (_init || (ConsoleIsEnabled && !ConsoleIsShowing))
			{
				lastLockMode = Cursor.lockState;
				lastVisible = Cursor.visible;
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				if ((Object)(object)EventSystem.current == (Object)null)
				{
					EventSystem.current = Object.Instantiate<GameObject>(((Il2CppObjectBase)DevConsole.s_AssetLookup["ASSETS/UNITY-DEVELOPERCONSOLE/RESOURCES/PREFABS/FAB_DEVCONSOLE.OLDEVENTSYSTEM.PREFAB"]).Cast<GameObject>()).GetComponent<EventSystem>();
					((Object)((Component)EventSystem.current).gameObject).name = "EventSystem";
				}
				_canvasGroup.alpha = 1f;
				_canvasGroup.interactable = true;
				_canvasGroup.blocksRaycasts = true;
				ConsoleIsShowing = true;
				_focusInputField = true;
				DevConsole.InvokeOnConsoleOpened();
			}
		}

		internal void CloseConsole()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (_init || (ConsoleIsEnabled && ConsoleIsShowing))
			{
				Cursor.lockState = lastLockMode;
				Cursor.visible = lastVisible;
				_canvasGroup.alpha = 0f;
				_canvasGroup.interactable = false;
				_canvasGroup.blocksRaycasts = false;
				ConsoleIsShowing = false;
				_repositioning = false;
				_resizing = false;
				_focusInputField = false;
				if (_inputField.isFocused && (Object)(object)EventSystem.current != (Object)null)
				{
					EventSystem.current.SetSelectedGameObject((GameObject)null);
				}
				DevConsole.InvokeOnConsoleClosed();
			}
		}

		internal void ToggleConsole()
		{
			if (ConsoleIsShowing)
			{
				CloseConsole();
			}
			else
			{
				OpenConsole();
			}
		}

		internal void ClearConsole()
		{
			ClearLogFields();
			_vertexCount = 0;
			StoredLogText = "Type <b>devconsole</b> for instructions on how to use the developer console.";
			_pretendScrollAtBottom = true;
		}

		internal void ResetConsole()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			_dynamicTransform.anchoredPosition = _initPosition;
			_dynamicTransform.sizeDelta = _initSize;
			_currentLogFieldWidth = _initLogFieldWidth;
			RefreshLogFieldsSize();
		}

		internal void SubmitInput()
		{
			if (!string.IsNullOrWhiteSpace(InputText) && RunCommand(InputText))
			{
				_scrollToBottomNextFrame = true;
			}
			InputText = string.Empty;
		}

		internal bool RunCommand(string rawInput)
		{
			string[] input = GetInput(rawInput);
			Command command = GetCommand(input[0]);
			AddToCommandHistory(input[0], rawInput);
			if (command == null)
			{
				string text = TryEvaluateInput(rawInput);
				if (!string.IsNullOrEmpty(text))
				{
					Log(text);
					return false;
				}
				LogError("Could not find the specified command: \"" + input[0] + "\".");
				return false;
			}
			input = ConvertInput(input, command.Parameters.Length);
			if (input.Length == 1 && command.DefaultCallback != null)
			{
				try
				{
					command.DefaultCallback();
				}
				catch (Exception ex)
				{
					LogError("Command default callback threw an exception.");
					Logs.LogMessage(ex.Message);
					return false;
				}
				return true;
			}
			if (command.Parameters.Length != input.Length - 1)
			{
				LogError("Invalid number of parameters: " + command.ToFormattedString() + ".");
				return false;
			}
			object[] array = new object[command.Parameters.Length];
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = input[i + 1];
				try
				{
					array[i] = ParseParameter(text2, command.Parameters[i].Type);
				}
				catch (Exception)
				{
					LogError("Invalid parameter type: \"" + text2 + "\". Expected " + command.GetFormattedParameter(i) + ".");
					return false;
				}
			}
			try
			{
				command.Callback((array.Length == 0) ? null : array);
			}
			catch (Exception ex3)
			{
				LogError("Command callback threw an exception.");
				Logs.LogMessage(ex3.Message);
				return false;
			}
			return true;
		}

		internal bool AddCommand(Command command, bool onlyInDevBuild = false, bool isCustomCommand = false)
		{
			if (onlyInDevBuild && !Debug.isDebugBuild)
			{
				return false;
			}
			command.FixName();
			command.FixAliases();
			if (!string.IsNullOrEmpty(command.Name) && !_commands.ContainsKey(command.Name) && !_commands.Values.Select((Command c) => c.Aliases).Any((string[] a) => command.HasAlias(a)))
			{
				if (DevConsole.isInit)
				{
					_commands.Add(command.Name, command);
				}
				else
				{
					DevConsole._commandsNeedToAdd.Add(command, onlyInDevBuild);
				}
				if (isCustomCommand)
				{
					command.SetAsCustomCommand();
				}
				return true;
			}
			return false;
		}

		internal bool RemoveCommand(string name)
		{
			Command command = GetCommand(name);
			if (command == null)
			{
				return true;
			}
			if (_permanentCommands.Contains(command.Name))
			{
				return false;
			}
			return _commands.Remove(command.Name);
		}

		internal Command GetCommand(string name)
		{
			if (!_commands.TryGetValue(name.ToLower(), out var value))
			{
				return _commands.Values.FirstOrDefault((Command c) => c.HasAlias(name));
			}
			return value;
		}

		internal bool GetCommand(string name, out Command command)
		{
			if (!_commands.TryGetValue(name.ToLower(), out command))
			{
				return (command = _commands.Values.FirstOrDefault((Command c) => c.HasAlias(name))) != null;
			}
			return true;
		}

		internal bool AddParameterType(Type type, Func<string, object> parseFunc)
		{
			if (!_parameterParseFuncs.ContainsKey(type))
			{
				_parameterParseFuncs.Add(type, parseFunc);
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void Log(object message)
		{
			StoredLogText += $"\n{message}";
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void Log(object message, string htmlColour)
		{
			Log($"<color={htmlColour}>{message}</color>");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void LogVariable(string variableName, object value, string suffix = "")
		{
			Log($"{variableName}: {value}{suffix}.");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void LogException(Exception exception)
		{
			if (exception != null)
			{
				Log(string.Format("({0:HH:mm:ss}) <color={1}><b>Exception:</b> </color>{2}", DateTime.Now, "#E99497", exception.Message));
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void LogError(object message)
		{
			Log(message, "#E99497");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void LogWarning(object message)
		{
			Log(message, "#DEBF1F");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void LogSuccess(object message)
		{
			Log(message, "#B3E283");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void LogSeperator(object message = null)
		{
			if (message == null)
			{
				Log("-");
			}
			else
			{
				Log($"- <b>{message}</b> -");
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void LogCollection<T>(in IReadOnlyCollection<T> collection, Func<T, string> toString = null, string prefix = "", string suffix = "")
		{
			if (collection != null && collection.Count != 0)
			{
				Log(string.Join("\n", collection.Select((T x) => prefix + (toString?.Invoke(x) ?? x.ToString()) + suffix)));
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void LogCommand()
		{
			LogCommand(_currentCommand);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void LogCommand(string name)
		{
			if (GetCommand(name, out var command))
			{
				Log(">> " + command.ToFormattedString() + ".");
			}
		}

		internal void OnInputValueChanged(string _)
		{
			if (!_ignoreCtrlBackspace && GetKey((KeyCode)306) && GetKeyDown((KeyCode)8))
			{
				string text = InputText.Substring(0, InputCaretPosition);
				string text2 = InputText.Substring(InputCaretPosition, InputText.Length - InputCaretPosition);
				string[] array = text.Split(new char[1] { ' ' });
				int num = 0;
				for (int i = 0; i < array.Length - 1; i++)
				{
					num += array[i].Length + 1;
				}
				_ignoreCtrlBackspace = true;
				InputText = InputText.Substring(0, num) + text2;
				_ignoreCtrlBackspace = false;
				InputCaretPosition = num;
			}
			RefreshCommandSuggestions();
			RefreshCommandParameterSuggestions();
			if (_inputField.text.Length != 0 && !GetKeyDown((KeyCode)273))
			{
				OnValidateInput();
			}
		}

		internal void OnValidateInput()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (InputText.Length != 0 && ConsoleToggleKey.HasValue && GetKeyDown(ConsoleToggleKey.Value))
			{
				InputText = InputText.Substring(0, InputText.Length - 1);
			}
			else if (InputText[Math.Max(0, InputCaretPosition - 1)] == '\t')
			{
				InputText = InputText.Substring(0, InputText.Length - 1);
				AutoComplete();
			}
			else if (InputText[Math.Max(0, InputCaretPosition - 1)] == '\n')
			{
				StringBuilder stringBuilder = new StringBuilder(InputText);
				stringBuilder.Remove(InputCaretPosition - 1, 1);
				InputText = stringBuilder.ToString();
				SubmitInput();
			}
		}

		internal void OnRepositionButtonPointerDown(BaseEventData eventData)
		{
			//IL_000e: 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)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			_repositioning = true;
			_repositionOffset = ((Il2CppObjectBase)eventData).Cast<PointerEventData>().position - Vector2.op_Implicit(((Transform)_dynamicTransform).position);
		}

		internal void OnRepositionButtonPointerUp(BaseEventData _)
		{
			_repositioning = false;
		}

		internal void OnResizeButtonPointerDown(BaseEventData _)
		{
			_resizing = true;
		}

		internal void OnResizeButtonPointerUp(BaseEventData _)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			_resizing = false;
			((Graphic)_resizeButtonImage).color = _resizeButtonColour;
			RefreshLogFieldsSize();
		}

		internal void OnResizeButtonPointerEnter(BaseEventData _)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)_resizeButtonImage).color = _resizeButtonColour * _resizeButtonHoverColour;
		}

		internal void OnResizeButtonPointerExit(BaseEventData _)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!_resizing)
			{
				((Graphic)_resizeButtonImage).color = _resizeButtonColour;
			}
		}

		internal void OnAuthorButtonPressed()
		{
		}

		internal void OnIncreaseTextSizeButtonPressed()
		{
			LogTextSize = Math.Min(35, LogTextSize + 4);
		}

		internal void OnDecreaseTextSizeButtonPressed()
		{
			LogTextSize = Math.Max(14, LogTextSize - 4);
		}

		private void OnLogMessageReceived(string logString, string _, LogType type)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected I4, but got Unknown
			string text = DateTime.Now.ToString("HH:mm:ss");
			switch ((int)type)
			{
			case 3:
				if (_displayUnityLogs)
				{
					Log("(" + text + ") <b>Log:</b> " + logString);
				}
				break;
			case 0:
				if (_displayUnityErrors)
				{
					Log("(" + text + ") <color=#E99497><b>Error:</b> </color>" + logString);
				}
				break;
			case 4:
				if (_displayUnityExceptions)
				{
					Log("(" + text + ") <color=#E99497><b>Exception:</b> </color>" + logString);
				}
				break;
			case 2:
				if (_displayUnityWarnings)
				{
					Log("(" + text + ") <color=#DEBF1F><b>Warning:</b> </color>" + logString);
				}
				break;
			case 1:
				break;
			}
		}

		private void Awake()
		{
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Expected O, but got Unknown
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Expected O, but got Unknown
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Expected O, but got Unknown
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Expected O, but got Unknown
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Expected O, but got Unknown
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Expected O, but got Unknown
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_053f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0576: Unknown result type (might be due to invalid IL or missing references)
			//IL_057b: Unknown result type (might be due to invalid IL or missing references)
			//IL_058c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ce: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			_init = true;
			((Object)((Component)this).gameObject).name = "DevConsoleInstance";
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			_canvasGroup = ((Component)((Component)this).transform).GetComponentInChildren<CanvasGroup>();
			foreach (Text item in ((IEnumerable<Text>)((Component)((Component)this).transform).GetComponentsInChildren<Text>()).ToList())
			{
				switch (((Object)item).name)
				{
				case "SuggestionText":
					_suggestionText = item;
					break;
				case "VersionText":
					_versionText = item;
					break;
				case "AuthorText":
					item.text = "Hikaria";
					break;
				}
			}
			foreach (RectTransform item2 in ((IEnumerable<RectTransform>)((Component)((Component)this).transform).GetComponentsInChildren<RectTransform>()).ToList())
			{
				switch (((Object)item2).name)
				{
				case "Content":
					_logContentTransform = item2;
					break;
				case "BackPanel":
					_dynamicTransform = item2;
					break;
				case "ResizeButton":
					_resizeButtonEventTrigger = ((Component)item2).GetComponent<EventTrigger>();
					break;
				case "RepositionButton":
					_repositioningButtonEventTrigger = ((Component)item2).GetComponent<EventTrigger>();
					break;
				}
			}
			foreach (Image item3 in ((IEnumerable<Image>)((Component)((Component)this).transform).GetComponentsInChildren<Image>()).ToList())
			{
				if (((Object)item3).name == "ResizeButton")
				{
					_resizeButtonImage = item3;
				}
			}
			foreach (InputField item4 in ((IEnumerable<InputField>)((Component)((Component)this).transform).GetComponentsInChildren<InputField>()).ToList())
			{
				if (((Object)item4).name == "InputField")
				{
					_inputField = item4;
				}
			}
			foreach (ScrollRect item5 in ((IEnumerable<ScrollRect>)((Component)((Component)this).transform).GetComponentsInChildren<ScrollRect>()).ToList())
			{
				if (((Object)item5).name == "Scroll View")
				{
					_logScrollView = item5;
				}
			}
			foreach (RectTransform item6 in ((IEnumerable<RectTransform>)((Component)((Component)this).transform).GetComponentsInChildren<RectTransform>()).ToList())
			{
				if (((Object)((Component)((Transform)item6).parent).gameObject).name == "LogField.Instance")
				{
					_logFieldPrefab = ((Component)((Transform)item6).parent).gameObject;
				}
			}
			foreach (Button item7 in ((IEnumerable<Button>)((Component)((Component)this).transform).GetComponentsInChildren<Button>()).ToList())
			{
				switch (((Object)item7).name)
				{
				case "DecreaseTextSizeButton":
					_decreaseTextSizeButton = item7;
					break;
				case "IncreaseTextSizeButton":
					_increaseTextSizeButton = item7;
					break;
				case "CloseButton":
					_closeButton = item7;
					break;
				}
			}
			Entry val = new Entry();
			val.eventID = (EventTriggerType)3;
			((UnityEvent<BaseEventData>)(object)val.callback).AddListener(UnityAction<BaseEventData>.op_Implicit((Action<BaseEventData>)OnResizeButtonPointerUp));
			_resizeButtonEventTrigger.triggers.Add(val);
			Entry val2 = new Entry();
			val2.eventID = (EventTriggerType)2;
			((UnityEvent<BaseEventData>)(object)val2.callback).AddListener(UnityAction<BaseEventData>.op_Implicit((Action<BaseEventData>)OnResizeButtonPointerDown));
			_resizeButtonEventTrigger.triggers.Add(val2);
			Entry val3 = new Entry();
			val3.eventID = (EventTriggerType)1;
			((UnityEvent<BaseEventData>)(object)val3.callback).AddListener(UnityAction<BaseEventData>.op_Implicit((Action<BaseEventData>)OnResizeButtonPointerExit));
			_resizeButtonEventTrigger.triggers.Add(val3);
			Entry val4 = new Entry();
			val4.eventID = (EventTriggerType)0;
			((UnityEvent<BaseEventData>)(object)val4.callback).AddListener(UnityAction<BaseEventData>.op_Implicit((Action<BaseEventData>)OnResizeButtonPointerEnter));
			_resizeButtonEventTrigger.triggers.Add(val4);
			Entry val5 = new Entry();
			val5.eventID = (EventTriggerType)3;
			((UnityEvent<BaseEventData>)(object)val5.callback).AddListener(UnityAction<BaseEventData>.op_Implicit((Action<BaseEventData>)OnRepositionButtonPointerUp));
			_repositioningButtonEventTrigger.triggers.Add(val5);
			Entry val6 = new Entry();
			val6.eventID = (EventTriggerType)2;
			((UnityEvent<BaseEventData>)(object)val6.callback).AddListener(UnityAction<BaseEventData>.op_Implicit((Action<BaseEventData>)OnRepositionButtonPointerDown));
			_repositioningButtonEventTrigger.triggers.Add(val6);
			((UnityEvent)_closeButton.onClick).AddListener(UnityAction.op_Implicit((Action)CloseConsole));
			((UnityEvent)_increaseTextSizeButton.onClick).AddListener(UnityAction.op_Implicit((Action)OnIncreaseTextSizeButtonPressed));
			((UnityEvent)_decreaseTextSizeButton.onClick).AddListener(UnityAction.op_Implicit((Action)OnDecreaseTextSizeButtonPressed));
			_resizeButtonHoverColour = Color.white;
			_versionText.text = $"v{_version}";
			_initPosition = _dynamicTransform.anchoredPosition;
			_initSize = _dynamicTransform.sizeDelta;
			_initLogFieldWidth = _logFieldPrefab.GetComponent<RectTransform>().sizeDelta.x;
			_initLogTextSize = _logFieldPrefab.GetComponent<InputField>().textComponent.fontSize;
			_currentLogFieldWidth = _initLogFieldWidth;
			_resizeButtonColour = ((Graphic)_resizeButtonImage).color;
			_logFieldPrefab.SetActive(false);
			((UnityEvent<string>)(object)_inputField.onValueChanged).AddListener(UnityAction<string>.op_Implicit((Action<string>)delegate(string s)
			{
				OnInputValueChanged(s);
			}));
			LoadPreferences();
			InitBuiltInCommands();
			InitBuiltInParsers();
			InitAttributes();
			InitMonoEvaluator();
			_persistStats.Clear();
			EnableConsole();
			ClearConsole();
			CloseConsole();
			if (_monoEvaluator == null)
			{
				LogWarning("Some features may not be available: C# expression evaluation is not supported on this platform.");
			}
			_init = false;
		}

		private void Update()
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			if (!ConsoleIsEnabled || !ConsoleIsShowing)
			{
				return;
			}
			if (_scrollToBottomNextFrame)
			{
				_logScrollView.verticalNormalizedPosition = 0f;
				LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)((Component)_logScrollView).transform).GetComponent<RectTransform>());
				if (_pretendScrollAtBottom && (_logScrollView.verticalNormalizedPosition < 0f || Mathf.Approximately(_logScrollView.verticalNormalizedPosition, 0f)))
				{
					_pretendScrollAtBottom = false;
				}
				_scrollToBottomNextFrame = false;
			}
			if (((Vector2Int)(ref _screenSize)).x != Screen.width || ((Vector2Int)(ref _screenSize)).y != Screen.height)
			{
				_screenSize = new Vector2Int(Screen.width, Screen.height);
				ResetConsole();
			}
			if (_focusInputField)
			{
				EventSystem.current.SetSelectedGameObject(((Component)_inputField).gameObject, (BaseEventData)null);
				_focusInputField = false;
			}
			if (_inputField.isFocused != _oldFocusInputField)
			{
				if (_inputField.isFocused)
				{
					DevConsole.InvokeOnConsoleFocused();
				}
				else
				{
					DevConsole.InvokeOnConsoleFocusLost();
				}
				_oldFocusInputField = _inputField.isFocused;
			}
			if (_repositioning)
			{
				Vector2 mousePosition = GetMousePosition();
				((Transform)_dynamicTransform).position = new Vector3(mousePosition.x - _repositionOffset.x, mousePosition.y - _repositionOffset.y, ((Transform)_dynamicTransform).position.z);
			}
			if (_resizing)
			{
				Vector2 val = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle(_dynamicTransform, GetMousePosition(), (Camera)null, ref val);
				val.x = Mathf.Clamp(Mathf.Abs(val.x), 650f, 1600f);
				val.y = Mathf.Clamp(Mathf.Abs(val.y), 200f, 900f);
				_dynamicTransform.sizeDelta = val;
				_currentLogFieldWidth = _initLogFieldWidth * (_dynamicTransform.sizeDelta.x / _initSize.x);
			}
		}

		private void LateUpdate()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Invalid comparison between Unknown and I4
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			if (!ConsoleIsEnabled)
			{
				return;
			}
			if (_isDisplayingFps)
			{
				_fpsDeltaTime += (Time.unscaledDeltaTime - _fpsDeltaTime) * 0.1f;
				_fpsElapsed += Time.deltaTime;
				if (_fpsElapsed > 0.25f)
				{
					_fpsMs = _fpsDeltaTime * 1000f;
					_fps = Mathf.RoundToInt(1f / _fpsDeltaTime);
					_fpsElapsed -= 0.25f;
					_fpsTextColour = Color.white;
					if ((Application.targetFrameRate == -1 && _fps >= 60) || (Application.targetFrameRate != -1 && _fps >= Application.targetFrameRate))
					{
						_fpsTextColour = Color.green;
					}
					else if (_fps < 10)
					{
						_fpsTextColour = Color.red;
					}
					else if (_fps < 30 && (Application.targetFrameRate > 30 || Application.targetFrameRate == -1))
					{
						_fpsTextColour = Color.yellow;
					}
				}
			}
			if (BindingsIsEnabled && !_inputField.isFocused && ((Object)(object)EventSystem.current == (Object)null || (Object)(object)EventSystem.current.currentSelectedGameObject == (Object)null))
			{
				if ((int)FocusStateManager.CurrentState == 8 || PlayerChatManager.InChatMode)
				{
					return;
				}
				try
				{
					foreach (KeyCode key in _bindings.Keys)
					{
						if (GetKeyDown(key))
						{
							RunCommand(_bindings[key]);
						}
					}
				}
				catch (Exception ex)
				{
					LogError("Checking bindings failed with an exception: " + ex.Message);
				}
			}
			if (StoredLogText != string.Empty)
			{
				if (_pretendScrollAtBottom || _logScrollView.verticalNormalizedPosition < 0.001f || Mathf.Approximately(_logScrollView.verticalNormalizedPosition, 0.001f))
				{
					_scrollToBottomNextFrame = true;
				}
				string logText = string.Copy(StoredLogText);
				StoredLogText = string.Empty;
				ProcessLogText(in logText);
				RebuildLayout();
			}
			if (ConsoleToggleKey.HasValue && (!ConsoleIsShowing || !_inputField.isFocused || InputText.Length <= 1) && GetKeyDown(ConsoleToggleKey.Value))
			{
				ToggleConsole();
			}
			else
			{
				if (!ConsoleIsShowing || !_inputField.isFocused)
				{
					return;
				}
				if (_commandStringSuggestions != null && _commandStringSuggestions.Length != 0)
				{
					if (GetKeyDown((KeyCode)273))
					{
						CycleCommandSuggestions(1);
					}
					else if (GetKeyDown((KeyCode)274))
					{
						CycleCommandSuggestions(-1);
					}
					return;
				}
				if (string.IsNullOrEmpty(InputText) && _commandHistoryIndex != -1)
				{
					_commandHistoryIndex = -1;
				}
				if (GetKeyDown((KeyCode)273))
				{
					CycleCommandHistory(1);
				}
				else if (GetKeyDown((KeyCode)274))
				{
					CycleCommandHistory(-1);
				}
			}
		}

		private void OnGUI()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Expected O, but got Unknown
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			if (!ConsoleIsEnabled)
			{
				return;
			}
			if (_isDisplayingFps)
			{
				if (_fpsStyle == null || _statFontSize != _fpsStyle.fontSize)
				{
					GUIStyle val = new GUIStyle(GUI.skin.box)
					{
						alignment = (TextAnchor)4,
						fontSize = _statFontSize
					};
					val.normal.textColor = Color.white;
					val.normal.background = Texture2D.whiteTexture;
					_fpsStyle = val;
					_fpsLabelSize = _fpsStyle.CalcSize(new GUIContent("0.00 ms (000 fps)"));
				}
				Color backgroundColor = GUI.backgroundColor;
				Color contentColor = GUI.contentColor;
				GUI.backgroundColor = new Color(0f, 0f, 0f, 0.75f);
				GUI.contentColor = _fpsTextColour;
				GUI.Box(new Rect(10f, 10f, _fpsLabelSize.x + 10f, _fpsLabelSize.y + 10f), $"{_fpsMs:0.00} ms ({_fps:0.} fps)", _fpsStyle);
				GUI.backgroundColor = backgroundColor;
				GUI.contentColor = contentColor;
			}
			if (!_isDisplayingStats || !_stats.Any())
			{
				return;
			}
			if (_statStyle == null || _statFontSize != _statStyle.fontSize)
			{
				GUIStyle val2 = new GUIStyle(GUI.skin.box)
				{
					alignment = (TextAnchor)4,
					fontSize = _statFontSize
				};
				val2.normal.textColor = Color.white;
				val2.normal.background = Texture2D.whiteTexture;
				_statStyle = val2;
			}
			Color backgroundColor2 = GUI.backgroundColor;
			Color contentColor2 = GUI.contentColor;
			GUI.backgroundColor = new Color(0f, 0f, 0f, 0.75f);
			float num = 10f + (_isDisplayingFps ? (_fpsLabelSize.y + 10f) : 0f);
			int num2 = 0;
			bool flag = Time.time > _statUpdateTime;
			if (flag)
			{
				_statUpdateTime = Time.time + 0.1f;
			}
			foreach (KeyValuePair<string, StatBase> stat in _stats)
			{
				if (_hiddenStats.Contains(stat.Key))
				{
					continue;
				}
				object obj;
				if (stat.Value is EvaluatedStat && !flag && _cachedStats.ContainsKey(stat.Key))
				{
					obj = _cachedStats[stat.Key];
				}
				else
				{
					try
					{
						obj = stat.Value.GetResult(_monoEvaluator);
					}
					catch (Exception)
					{
						obj = "ERROR";
					}
					if (stat.Value is EvaluatedStat)
					{
						_cachedStats[stat.Key] = obj;
					}
				}
				string text = string.Format("{0}: {1}", stat.Key, obj ?? "NULL");
				GUI.contentColor = ((obj == null) ? Color.yellow : ((obj.Equals("ERROR") || obj.Equals("C# expression evaluation is not supported on this platform.")) ? Color.red : Color.white));
				Vector2 val3 = _statStyle.CalcSize(new GUIContent(text));
				GUI.Box(new Rect(10f, num + ((float)num2 * (val3.y + 10f + 5f) + 5f), val3.x + 10f, val3.y + 10f), text, _statStyle);
				num2++;
			}
			GUI.backgroundColor = backgroundColor2;
			GUI.contentColor = contentColor2;
		}

		private void OnDestroy()
		{
			SavePreferences();
		}

		private void InitBuiltInCommands()
		{
			AddCommand(Command.Create("devconsole", "", "Display instructions on how to use the developer console", delegate
			{
				LogSeperator($"Developer console (v{_version})");
				Log("Use <b>commands</b> to display a list of available commands.");
				Log("Use " + GetCommand("help").ToFormattedString() + " to display information about a specific command.");
				Log("Use UP / DOWN to cycle through command history or suggested commands.");
				Log("Use TAB to autocomplete a suggested command.\n");
				Log("Created by @Hikaria.");
				LogSeperator();
			}));
			AddCommand(Command.Create("print", "echo", "Display a message in the developer console", Parameter.Create("message", "Message to display"), delegate(string s)
			{
				Log(s);
			}));
			AddCommand(Command.Create("clear", "", "Clear the developer console", delegate
			{
				ClearConsole();
			}));
			AddCommand(Command.Create("reset", "", "Reset the position and size of the developer console", delegate
			{
				ResetConsole();
			}));
			AddCommand(Command.Create("closeconsole", "hideconsole", "Close the developer console window", delegate
			{
				CloseConsole();
			}));
			AddCommand(Command.Create("help", "info", "Display information about a specified command", Parameter.Create("commandName", "Name of the command to get information about"), delegate(string s)
			{
				Command command8 = GetCommand(s);
				if (command8 == null)
				{
					LogError("Unknown command name specified: \"" + s + "\". Use <b>list</b> for a list of all commands.");
				}
				else
				{
					LogSeperator(command8.Name);
					if (!string.IsNullOrEmpty(command8.HelpText))
					{
						Log(command8.HelpText + ".");
					}
					string[] aliases = command8.Aliases;
					if (aliases != null && aliases.Length != 0 && command8.Aliases.Any((string a) => !string.IsNullOrEmpty(a)))
					{
						string[] value = command8.Aliases.Select((string alias) => "<i>" + alias + "</i>").ToArray();
						Log("Aliases: " + string.Join(", ", value) + ".");
					}
					if (command8.Parameters.Length != 0)
					{
						Log("Syntax: " + command8.ToFormattedString() + ".");
					}
					Parameter[] parameters = command8.Parameters;
					foreach (Parameter parameter in parameters)
					{
						if (!string.IsNullOrEmpty(parameter.HelpText))
						{
							Log(" <b>" + parameter.Name + "</b>: " + parameter.HelpText + ".");
						}
					}
					LogSeperator();
				}
			}, delegate
			{
				if (string.IsNullOrWhiteSpace(_previousCommand) || _previousCommand.ToLower().Equals("help"))
				{
					RunCommand("help help");
				}
				else
				{
					RunCommand("help " + _previousCommand);
				}
			}));
			AddCommand(Command.Create("enum", "", "Display information about a specified enum", Parameter.Create("enumName", "Name of the enum to get information about (case-sensitive)"), delegate(string s)
			{
				Type type = _cacheEnumTypes.FirstOrDefault((Type t) => t.Name.Equals(s));
				if (type == null)
				{
					List<Type> list2 = new List<Type>();
					Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
					foreach (Assembly assembly in assemblies)
					{
						type = assembly.GetTypes().SelectMany((Type t) => t.GetMembers()).Union(assembly.GetTypes())
							.FirstOrDefault((MemberInfo t) => t.ReflectedType != null && t.ReflectedType.IsEnum && (t.ReflectedType.Name.Equals(s) || s.Equals(t.ReflectedType.Namespace + "." + t.ReflectedType.Name)))?.ReflectedType;
						if (type != null)
						{
							if (s.Equals(type.Namespace + "." + type.Name))
							{
								list2 = new List<Type> { type };
								break;
							}
							list2.Add(type);
						}
					}
					if (list2.Count > 1)
					{
						LogError("Multiple results found: " + string.Join(", ", list2.Select((Type x) => x.Namespace + "." + x.Name)) + ".");
						return;
					}
					if (list2.Count != 1)
					{
						LogError("Could not find enum type with the specified name: \"" + s + "\"");
						return;
					}
					type = list2.FirstOrDefault();
					_cacheEnumTypes.Add(type);
					if (_cacheEnumTypes.Count > 6)
					{
						_cacheEnumTypes.RemoveAt(0);
					}
				}
				LogSeperator(type.Namespace + "." + type.Name + " (" + type.GetEnumUnderlyingType().Name + ")" + ((type.GetCustomAttribute(typeof(FlagsAttribute)) == null) ? "" : " [Flags]"));
				FieldInfo[] fields = type.GetFields();
				string text2 = string.Empty;
				bool flag = true;
				for (int num4 = 0; num4 < fields.Length; num4++)
				{
					if (!fields[num4].Name.Equals("value__"))
					{
						text2 += string.Format("{0}{1} = {2}", flag ? "" : "\n", fields[num4].Name, fields[num4].GetRawConstantValue());
						flag = false;
					}
				}
				Log(text2);
				LogSeperator();
			}));
			AddCommand(Command.Create("commands", "", "Display a sorted list of all available commands", delegate
			{
				LogSeperator("Commands");
				Log(string.Join(", ", _commands.Keys.OrderBy((string s) => s)));
				LogSeperator();
			}));
			AddCommand(Command.Create("customcommands", "", "Display a sorted list of all available custom commands", delegate
			{
				IList<string> list = _commands.Keys.Where((string s) => _commands[s].IsCustomCommand).ToList();
				if (list != null && list.Count == 0)
				{
					Log("There are no custom commands defined.");
				}
				else
				{
					LogSeperator("Custom commands");
					Log(string.Join(", ", list.OrderBy((string s) => s)));
					LogSeperator();
				}
			}));
			AddCommand(Command.Create("consoleversion", "", "Display the developer console version", delegate
			{
				Log($"Developer console version: {_version}.");
			}));
			AddCommand(Command.Create("bind", "addbind", "Add a key binding for a command", Parameter.Create("Key", "Key to bind the command to"), Parameter.Create("Command", "Command to execute when the key bind is pressed"), delegate(KeyCode key, string command)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (_bindings.ContainsKey(key))
				{
					LogError(string.Format("A key binding already exists for <i>{0}</i>. Use {1} to remove the key binding.", key, GetCommand("unbind").ToFormattedString()));
				}
				else
				{
					_bindings[key] = command;
					LogSuccess($"Successfully added a key binding for <i>{key}</i>.");
				}
			}));
			AddCommand(Command.Create("unbind", "removebind", "Remove a key binding", Parameter.Create("Key", "Key binding to remove"), delegate(KeyCode key)
			{
				//IL_0006: 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_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (!_bindings.ContainsKey(key))
				{
					LogError($"A key binding doesn't exist for <i>{key}</i>.");
				}
				else
				{
					_bindings.Remove(key);
					LogSuccess($"Successfully removed a key binding for <i>{key}</i>.");
				}
			}));
			AddCommand(Command.Create("binds", "", "List all the key bindings", delegate
			{
				if (_bindings.Count == 0)
				{
					Log("There are no key bindings. Use " + GetCommand("bind").GetFormattedName() + " to add a key binding.");
				}
				else
				{
					LogSeperator($"Key bindings ({_bindings.Count})");
					Log(string.Join("\n", _bindings.Keys.Select((KeyCode x) => $"<i>{x}</i>: \"{_bindings[x]}\"")));
					LogSeperator();
				}
			}));
			AddCommand(Command.Create("log_size", "", "Query or set the font size used in the developer console log", Parameter.Create("fontSize", ""), delegate(int fontSize)
			{
				if (fontSize < 14 || fontSize > 35)
				{
					LogError($"Invalid font size specified: {fontSize}. Must be between {14} and {35}.");
				}
				else
				{
					int logTextSize = LogTextSize;
					LogTextSize = fontSize;
					LogSuccess($"Successfully changed the log font size to {fontSize} (was {logTextSize}).");
				}
			}, delegate
			{
				LogVariable("Log font size", _logFields.First().textComponent.fontSize, $" (Default: {_initLogTextSize})");
			}));
			AddCommand(Command.Create("quit", "exit", "Exit the player application", delegate
			{
				if (Application.isEditor)
				{
					LogError("Cannot quit the player application when running in the Editor.");
				}
				else
				{
					Application.Quit();
				}
			}));
			AddCommand(Command.Create("appversion", "", "Display the application version", delegate
			{
				LogVariable("App version", Application.version);
			}));
			AddCommand(Command.Create("unityversion", "", "Display the engine version", delegate
			{
				LogVariable("Engine version", Application.unityVersion);
			}));
			AddCommand(Command.Create("unityinput", "", "Display the input system being used by the developer console", delegate
			{
				Log("The legacy input system is currently being used.");
			}));
			AddCommand(Command.Create("path", "", "Display the path to the application executable", delegate
			{
				LogVariable("Application path", AppDomain.CurrentDomain.BaseDirectory);
			}));
			AddCommand(Command.Create("fullscreen", "", "Query or set whether the window is full screen", Parameter.Create("enabled", "Whether the window is full screen (use \"NULL\" to toggle)"), delegate(bool? b)
			{
				if (!b.HasValue)
				{
					b = !Screen.fullScreen;
				}
				Screen.fullScreen = b.Value;
				LogSuccess((b.Value ? "Enabled" : "Disabled") + " fullscreen mode.");
			}, delegate
			{
				LogVariable("Full screen", Screen.fullScreen);
			}));
			AddCommand(Command.Create("fullscreen_mode", "", "Query or set the full screen mode", Parameter.Create("mode", ""), delegate(FullScreenMode m)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				Screen.fullScreenMode = m;
				LogSuccess($"Full screen mode set to {m}.");
			}, delegate
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				LogVariable("Full screen mode", Screen.fullScreenMode);
			}));
			AddCommand(Command.Create("vsync", "", "Query or set whether VSync is enabled", Parameter.Create("vSyncCount", "The number of VSyncs that should pass between each frame (0, 1, 2, 3, or 4)"), delegate(int i)
			{
				if (i < 0 || i > 4)
				{
					LogError($"Provided VSyncCount is not an accepted value: \"{i}\".");
				}
				else
				{
					QualitySettings.vSyncCount = i;
					LogSuccess($"VSyncCount set to {i}.");
				}
			}, delegate
			{
				LogVariable("VSync count", QualitySettings.vSyncCount);
			}));
			AddCommand(Command.Create("monitor_size", "monitor_resolution", "Display the current monitor resolution", delegate
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				LogVariable("Monitor size", Screen.currentResolution);
			}));
			AddCommand(Command.Create("window_size", "window_resolution", "Display the current window resolution", delegate
			{
				LogVariable("Window size", $"{Screen.width} x {Screen.height}");
			}));
			AddCommand(Command.Create("targetfps", "", "Query or set the target frame rate", Parameter.Create("targetFrameRate", "Frame rate the application will try to render at."), delegate(int i)
			{
				Application.targetFrameRate = i;
				LogSuccess($"Target frame rate set to {i}.");
			}, delegate
			{
				LogVariable("Target frame rate", Application.targetFrameRate);
			}));
			AddCommand(Command.Create("cam_ortho", "", "Query or set whether the main camera is orthographic", Parameter.Create("enabled", "Whether the main camera is orthographic (use \"NULL\" to toggle)"), delegate(bool? b)
			{
				if ((Object)(object)Camera.main == (Object)null)
				{
					LogError("Could not find the main camera.");
				}
				else
				{
					if (!b.HasValue)
					{
						b = !Camera.main.orthographic;
					}
					Camera.main.orthographic = b.Value;
					LogSuccess((b.Value ? "Enabled" : "Disabled") + " orthographic mode on the main camera.");
				}
			}, delegate
			{
				if ((Object)(object)Camera.main == (Object)null)
				{
					LogError("Could not find the main camera.");
				}
				else
				{
					LogVariable("Orthographic", Camera.main.orthographic);
				}
			}));
			AddCommand(Command.Create("cam_fov", "", "Query or set the main camera field of view", Parameter.Create("fieldOfView", "Field of view"), delegate(int f)
			{
				if ((Object)(object)Camera.main == (Object)null)
				{
					LogError("Could not find the main camera.");
				}
				else
				{
					Camera.main.fieldOfView = f;
					LogSuccess($"Main camera's field of view set to {f}.");
				}
			}, delegate
			{
				if ((Object)(object)Camera.main == (Object)null)
				{
					LogError("Could not find the main camera.");
				}
				else
				{
					LogVariable("Field of view", Camera.main.fieldOfView);
				}
			}));
			AddCommand(Command.Create("scene_load", "", "Load the scene at the specified build index", Parameter.Create("buildIndex", "Build index of the scene to load, specified in the Unity build settings"), delegate(int i)
			{
				if (i >= SceneManager.sceneCountInBuildSettings)
				{
					LogError($"Invalid build index specified: \"{i}\". Check the Unity build settings.");
				}
				else
				{
					SceneManager.LoadScene(i);
					LogSuccess($"Loaded scene at build index {i}.");
				}
			}), onlyInDevBuild: true);
			AddCommand(Command.Create("scene_info", "", "Display information about the current scene", Parameter.Create("sceneIndex", "Index of the scene in the currently loaded scenes"), delegate(int i)
			{
				//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)
				if (i >= SceneManager.sceneCount)
				{
					LogError($"Could not find active scene at index: {i}.");
				}
				else
				{
					Scene sceneAt2 = SceneManager.GetSceneAt(i);
					LogSeperator(((Scene)(ref sceneAt2)).name);
					Log($"Scene index: {i}.");
					Log($"Build index: {((Scene)(ref sceneAt2)).buildIndex}.");
					Log("Path: " + ((Scene)(ref sceneAt2)).path + ".");
					LogSeperator();
				}
			}, delegate
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				if (SceneManager.sceneCount == 0)
				{
					Log("Could not find any active scenes.");
				}
				else
				{
					LogSeperator("Active scenes");
					for (int num2 = 0; num2 < SceneManager.sceneCount; num2++)
					{
						Scene sceneAt = SceneManager.GetSceneAt(num2);
						Log($" {num2}) {((Scene)(ref sceneAt)).name}, build index: {((Scene)(ref sceneAt)).buildIndex}.");
					}
					LogCommand();
					LogSeperator();
				}
			}));
			AddCommand(Command.Create("obj_info", "", "Display information about a game object in the scene", Parameter.Create("name", "Name of the game object"), delegate(string s)
			{
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				GameObject val2 = GameObject.Find(s);
				if ((Object)(object)val2 == (Object)null)
				{
					LogError("Could not find game object: \"" + s + "\".");
				}
				else
				{
					LogSeperator(((Object)val2).name + " (" + (val2.activeInHierarchy ? "enabled" : " disabled") + ")");
					RectTransform val3 = default(RectTransform);
					if (val2.TryGetComponent<RectTransform>(ref val3))
					{
						Log("RectTransform:");
						LogVariable(" Anchored position", val3.anchoredPosition);
						LogVariable(" Size", val3.sizeDelta);
						LogVariable(" Pivot", val3.pivot);
					}
					else
					{
						Log("Transform:");
						LogVariable(" Position", val2.transform.position);
						LogVariable(" Rotation", val2.transform.rotation);
						LogVariable(" Scale", val2.transform.localScale);
					}
					LogVariable("Tag", val2.tag);
					LogVariable("Physics layer", LayerMask.LayerToName(val2.layer));
					Component[] array3 = Il2CppArrayBase<Component>.op_Implicit(val2.GetComponents<Component>());
					if (array3.Length > 1)
					{
						Log("Components:");
						for (int n = 1; n < array3.Length; n++)
						{
							Component obj3 = array3[n];
							MonoBehaviour val4 = (MonoBehaviour)(object)((obj3 is MonoBehaviour) ? obj3 : null);
							if (val4 != null)
							{
								Log(string.Format(" {0}: {1} ({2}).", n, ((object)val4).GetType().Name, ((Behaviour)val4).enabled ? "enabled" : "disabled"));
							}
							else
							{
								Log($" {n}: {((object)array3[n]).GetType().Name}.");
							}
						}
					}
					if (val2.transform.childCount > 0)
					{
						Log("Children:");
						for (int num = 0; num < val2.transform.childCount; num++)
						{
							Transform child = val2.transform.GetChild(num);
							Log(string.Format(" {0}: {1} ({2}).", num, ((Object)((Component)child).gameObject).name, ((Component)child).gameObject.activeInHierarchy ? "enabled" : "disabled"));
						}
					}
					LogSeperator();
				}
			}));
			AddCommand(Command.Create("obj_list", "", "Display a hierarchical list of all game objects in the scene", delegate
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				Scene activeScene = SceneManager.GetActiveScene();
				GameObject[] array = Il2CppArrayBase<GameObject>.op_Implicit((Il2CppArrayBase<GameObject>)(object)((Scene)(ref activeScene)).GetRootGameObjects());
				string logResult = string.Empty;
				GameObject[] array2 = array;
				Transform t2;
				foreach (GameObject val in array2)
				{
					logResult = logResult + ((Object)val.gameObject).name + ".\n";
					logChildren(val, 2);
				}
				activeScene = SceneManager.GetActiveScene();
				LogSeperator("Hierarchy (" + ((Scene)(ref activeScene)).name + ")");
				Log(logResult.TrimEnd(new char[1] { '\n' }));
				LogSeperator();
				void logChildren(GameObject obj, int tabAmount)
				{
					string tabbed = getTabbed(tabAmount);
					for (int l = 0; l < obj.transform.childCount; l++)
					{
						t2 = obj.transform.GetChild(l);
						logResult = logResult + tabbed + ((Object)((Component)t2).gameObject).name + ".\n";
						logChildren(((Component)t2).gameObject, tabAmount + 2);
					}
				}
			}));
			AddCommand(Command.Create("log_logs", "", "Query, enable or disable displaying Unity logs in the developer console", Parameter.Create("enabled", "Whether Unity logs should be displayed in the developer console (use \"NULL\" to toggle)"), delegate(bool? b)
			{
				if (!b.HasValue)
				{
					b = !_displayUnityLogs;
				}
				_displayUnityLogs = b.Value;
				LogSuccess((b.Value ? "Enabled" : "Disabled") + " displaying Unity logs in the developer console.");
			}, delegate
			{
				LogVariable("Log unity logs", _displayUnityLogs);
			}));
			AddCommand(Command.Create("log_errors", "", "Query, enable or disable displaying Unity errors in the developer console", Parameter.Create("enabled", "Whether Unity errors should be displayed in the developer console (use \"NULL\" to toggle)"), delegate(bool? b)
			{
				if (!b.HasValue)
				{
					b = !_displayUnityErrors;
				}
				_displayUnityErrors = b.Value;
				LogSuccess((b.Value ? "Enabled" : "Disabled") + " displaying Unity errors in the developer console.");
			}, delegate
			{
				LogVariable("Log unity errors", _displayUnityErrors);
			}));
			AddCommand(Command.Create("log_exceptions", "", "Query, enable or disable displaying Unity exceptions in the developer console", Parameter.Create("enabled", "Whether Unity exceptions should be displayed in the developer console (use \"NULL\" to toggle)"), delegate(bool? b)
			{
				if (!b.HasValue)
				{
					b = !_displayUnityExceptions;
				}
				_displayUnityExceptions = b.Value;
				LogSuccess((b.Value ? "Enabled" : "Disabled") + " displaying Unity exceptions in the developer console.");
			}, delegate
			{
				LogVariable("Log unity exceptions", _displayUnityExceptions);
			}));
			AddCommand(Command.Create("log_warnings", "", "Query, enable or disable displaying Unity warnings in the developer console", Parameter.Create("enabled", "Whether Unity warnings should be displayed in the developer console (use \"NULL\" to toggle)"), delegate(bool? b)
			{
				if (!b.HasValue)
				{
					b = !_displayUnityWarnings;
				}
				_displayUnityWarnings = b.Value;
				LogSuccess((b.Value ? "Enabled" : "Disabled") + " displaying Unity warnings in the developer console.");
			}, delegate
			{
				LogVariable("Log unity warnings", _displayUnityWarnings);
			}));
			AddCommand(Command.Create("cs_evaluate", "cs_eval,evaluate,eval", "Evaluate a C# expression or statement and display the result", Parameter.Create("expression", "The expression to evaluate"), delegate(string input)
			{
				if (_monoEvaluator == null)
				{
					DevConsole.LogError("C# expression evaluation is not supported on this platform.");
					return;
				}
				try
				{
					if (!input.EndsWith(";"))
					{
						input += ";";
					}
					object obj2 = _monoEvaluator.Evaluate(input);
					if (obj2 == null)
					{
						Log("Null.");
					}
					else if (obj2.GetType() != typeof(string) && typeof(IEnumerable).IsAssignableFrom(obj2.GetType()))
					{
						Log("{ " + string.Join(", ", ((IEnumerable)obj2).Cast<object>()) + " }");
					}
					else
					{
						Log($"{obj2}.");
					}
				}
				catch (Exception ex2)
				{
					LogError("An exception was thrown whilst evaluating the C# expression or statement: " + ex2.Message + ".");
				}
			}));
			AddCommand(Command.Create("cs_run", "run", "Execute a C# expression or statement", Parameter.Create("statement", "The statement to execute"), delegate(string input)
			{
				if (_monoEvaluator == null)
				{
					DevConsole.LogError("C# expression evaluation is not supported on this platform.");
					return;
				}
				try
				{
					if (!input.EndsWith(";"))
					{
						input += ";";
					}
					if (_monoEvaluator.Run(input))
					{
						LogSuccess("Successfully executed the C# expression or statement.");
					}
					else
					{
						LogError("Failed to parse the C# expression or statement.");
					}
				}
				catch (Exception ex)
				{
					LogError("An exception was thrown whilst executing the C# expression or statement: " + ex.Message + ".");
				}
			}));
			AddCommand(Command.Create("cs_usings", "", "Display a list of all active using statements", delegate
			{
				if (_monoEvaluator == null)
				{
					DevConsole.LogError("C# expression evaluation is not supported on this platform.");
				}
				else
				{
					string @using = _monoEvaluator.GetUsing();
					if (string.IsNullOrEmpty(@using))
					{
						Log("There are no active using statements.");
					}
					else
					{
						LogSeperator("Usings");
						Log(@using.TrimEnd(new char[1] { '\n' }));
						LogSeperator();
					}
				}
			}));
			AddCommand(Command.Create("cs_variables", "cs_vars", "Display a list of all local variables defined", delegate
			{
				if (_monoEvaluator == null)
				{
					DevConsole.LogError("C# expression evaluation is not supported on this platform.");
				}
				else
				{
					string vars = _monoEvaluator.GetVars();
					if (string.IsNullOrEmpty(vars))
					{
						Log("There are no local variables defined.");
					}
					else
					{
						LogSeperator("Local variables");
						Log(vars.TrimEnd(new char[1] { '\n' }));
						LogSeperator();
					}
				}
			}));
			AddCommand(Command.Create("cs_setusing", "", "Set whether a using statement is included automatically when starting the developer console", Parameter.Create("namespace", "Namespace to use as the using statement (e.g. \"System.Collections\""), Parameter.Create("enabled", "Whether the using statement is automatically included upon starting the developer console"), delegate(string usingName, bool enabled)
			{
				if (enabled)
				{
					if (_includedUsings.Contains(usingName))
					{
						LogError("The specifed using statement is already enabled: \"" + usingName + "\".");
					}
					else
					{
						_includedUsings.Add(usingName);
						LogSuccess("Enabled \"" + usingName + "\" as an automatically included using statement.");
					}
				}
				else if (!_includedUsings.Contains(usingName))
				{
					LogError("The specified using statement is already disabled: \"" + usingName + "\".");
				}
				else
				{
					_includedUsings.Remove(usingName);
					LogSuccess("Disabled \"" + usingName + "\" as an automatically included using statement.");
				}
			}));
			AddCommand(Command.Create("cs_autousings", "", "Display a list of all user-defined using statements that are included automatically when starting the developer console", delegate
			{
				if (_includedUsings.Count == 0)
				{
					Log("There are no user-defined using statements.");
				}
				else
				{
					LogSeperator("User-defined usings");
					IReadOnlyCollection<string> collection2 = _includedUsings;
					LogCollection(in collection2);
					LogSeperator();
				}
			}));
			AddCommand(Command.Create("cs_help", "", "Display information about the reflection commands", delegate
			{
				Command command2 = GetCommand("cs_evaluate");
				Command command3 = GetCommand("cs_run");
				Command command4 = GetCommand("cs_usings");
				Command command5 = GetCommand("cs_vars");
				Command command6 = GetCommand("cs_setusing");
				Command command7 = GetCommand("cs_autousings");
				LogSeperator("Reflection commands help");
				LogVariable(command2.ToFormattedString(), command2.HelpText);
				LogVariable(command3.ToFormattedString(), command3.HelpText);
				LogVariable(command4.ToFormattedString(), command4.HelpText);
				LogVariable(command5.ToFormattedString(), command5.HelpText);
				LogVariable(command6.ToFormattedString(), command6.HelpText);
				LogVariable(command7.ToFormattedString(), command7.HelpText);
				LogSeperator();
			}));
			AddCommand(Command.Create("stats_help", "", "Display information about the developer console stats feature", delegate
			{
				DevConsole.LogSeperator("Developer console tracked stats display");
				DevConsole.Log("When enabled, stats such as variables can be displayed on-screen during gameplay.");
				DevConsole.Log("There are three ways to add tracked stats:");
				DevConsole.Log("1. Using commands (" + GetCommand("stats_set").GetFormattedName() + ") to add a stat that is evaluated as a C# expression;");
				DevConsole.Log("2. Declaring a <i>" + typeof(DevConsoleTrackedStatAttribute).Name + "</i> attribute on a declared static field or property; or");
				DevConsole.Log("3. Calling <i>DevConsole.SetTrackedStat()</i> to add a stat this is retrieved via a provided lambda function.");
				DevConsole.LogSeperator();
			}));
			AddCommand(Command.Create("stats_showfps", "stats_displayfps,showfps,displayfps", "Query or set whether the fps is being displayed on-screen", Parameter.Create("enabled", "Whether the fps is being displayed on-screen (use \"NULL\" to toggle)"), delegate(bool? b)
			{
				if (!b.HasValue)
				{
					b = !_isDisplayingFps;
				}
				if (b != _isDisplayingFps)
				{
					_isDisplayingFps = !_isDisplayingFps;
					if (_isDisplayingFps)
					{
						_fps = 0;
						_fpsMs = 0f;
						_fpsDeltaTime = 0f;
						_fpsElapsed = 0f;
						_fpsStyle = null;
					}
				}
				LogSuccess((b.Value ? "Enabled" : "Disabled") + " the on-screen fps.");
			}, delegate
			{
				LogVariable("Show fps", _isDisplayingFps);
			}));
			AddCommand(Command.Create("stats_list", "", "Display a list of the tracked developer console stats that can be displayed on-screen", delegate
			{
				if (!_stats.Any())
				{
					DevConsole.Log("There are no tracked developer console stats. Use " + GetCommand("stats_set").GetFormattedName() + " to set one up.");
				}
				else
				{
					LogSeperator("Tracked developer console stats");
					IReadOnlyCollection<KeyValuePair<string, StatBase>> collection = _stats;
					LogCollection(in collection, (KeyValuePair<string, StatBase> x) => string.Format("<b>{0}:</b> {1} ({2}){3}.", x.Key, x.Value, x.Value.Desc, _hiddenStats.Contains(x.Key) ? " <i>[Disabled]</i>" : ""));
					LogSeperator();
				}
			}));
			AddCommand(Command.Create("stats_display", "", "Set or query whether the developer console stats are being displayed on-screen", Parameter.Create("display", ""), delegate(bool? b)
			{
				if (!b.HasValue)
				{
					b = !_isDisplayingStats;
				}
				_isDisplayingStats = b.Value;
				DevConsole.LogSuccess((_isDisplayingStats ? "Enabled" : "Disabled") + " the on-screen developer console stats display.");
			}, delegate
			{
				DevConsole.LogVariable("Display on-screen developer console stats", _isDisplayingStats);
			}));
			AddCommand(Command.Create("stats_set", "", "Set a stat on the developer console which can be displayed on-screen", Parameter.Create("name", "Name of the stat"), Parameter.Create("expression", "The C# expression to evaluate"), delegate(string name, string expression)
			{
				if (name == null || expression == null)
				{
					DevConsole.LogError("Parameters cannot be null.");
				}
				else
				{
					if (!expression.EndsWith(";"))
					{
						expression += ";";
					}
					_stats[name] = new EvaluatedStat(expression);
					DevConsole.LogSuccess("Successfully set " + name + " as a developer console stat.");
				}
			}));
			AddCommand(Command.Create("stats_evaluate", "stats_eval", "Evaluate one of the developer console stats", Parameter.Create("name", "Name of the stat"), delegate(string name)
			{
				if (!_stats.ContainsKey(name))
				{
					DevConsole.LogError("Could not find " + name + ". Use " + GetCommand("stats_display").GetFormattedName() + " to display a list of all developer console stats.");
					return;
				}
				try
				{
					DevConsole.LogVariable(name, _stats[name].GetResult(_monoEvaluator) ?? "NULL");
				}
				catch (Exception exception)
				{
					DevConsole.LogException(exception);
				}
			}));
			AddCommand(Command.Create("stats_remove", "", "Remove a stat from the developer console", Parameter.Create("name", "Name of the stat"), delegate(string name)
			{
				if (!_stats.Remove(name))
				{
					DevConsole.LogError("Could not remove " + name + ". Use " + GetCommand("stats_display").GetFormattedName() + " to display a list of all developer console stats.");
				}
				else
				{
					_hiddenStats.Remove(name);
					_cachedStats.Remove(name);
					DevConsole.LogSuccess("Successfully removed " + name + " from the developer console stats.");
				}
			}));
			AddCommand(Command.Create("stats_toggle", "", "Set whether a particular developer console stat should be displayed or not", Parameter.Create("name", "Name of the stat"), Parameter.Create("display", ""), delegate(string name, bool? b)
			{
				if (!_stats.ContainsKey(name))
				{
					DevConsole.LogError("Could not find " + name + ". Use " + GetCommand("stats_display").GetFormattedName() + " to display a list of all developer console stats.");
				}
				else
				{
					if (!b.HasValue)
					{
						b = _hiddenStats.Contains(name);
					}
					if (b.Value)
					{
						_hiddenStats.Remove(name);
					}
					else
					{
						_hiddenStats.Add(name);
					}
					DevConsole.LogSuccess((b.Value ? "Enabled" : "Disabled") + " the on-screen developer console stats display for " + name + ".");
				}
			}));
			AddCommand(Command.Create("stats_fontsize", "", "Query or set the font size of the tracked developer console stats & fps display", Parameter.Create("fontSize", $"Size of the font (default: {18})"), delegate(int f)
			{
				if (f <= 0)
				{
					LogError("Font size must be non-zero and positive.");
				}
				else
				{
					int statFontSize = _statFontSize;
					_statFontSize = f;
					LogSuccess($"Set the stats font size to {_statFontSize} (was {statFontSize}).");
				}
			}, delegate
			{
				LogVariable("Stats font size", _statFontSize);
			}));
			AddCommand(Command.Create("time", "", "Display the current time", delegate
			{
				Log($"Current time: {DateTime.Now}.");
			}));
			AddCommand(Command.Create("sys_info", "", "Display system information", delegate
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: 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_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				LogSeperator("System information");
				LogVariable("Name", SystemInfo.deviceName);
				LogVariable("Model", SystemInfo.deviceModel);
				LogVariable("Type", SystemInfo.deviceType, ((int)SystemInfo.operatingSystemFamily == 0) ? "" : $" ({SystemInfo.operatingSystemFamily})");
				LogVariable("OS", SystemInfo.operatingSystem);
				if (SystemInfo.batteryLevel != -1f)
				{
					Log($"Battery status: {SystemInfo.batteryStatus} ({SystemInfo.batteryLevel * 100f}%).");
				}
				Log("");
				LogVariable("CPU", SystemInfo.processorType);
				LogVariable(" Memory size", SystemInfo.systemMemorySize, " megabytes");
				LogVariable(" Processors", SystemInfo.processorCount);
				LogVariable(" Frequency", SystemInfo.processorFrequency, " MHz");
				Log("");
				LogVariable("GPU", SystemInfo.graphicsDeviceName);
				LogVariable(" Type", SystemInfo.graphicsDeviceType);
				LogVariable(" Vendor", SystemInfo.graphicsDeviceVendor);
				LogVariable(" Version", SystemInfo.graphicsDeviceVersion);
				LogVariable(" Memory size", SystemInfo.graphicsMemorySize, " megabytes");
				LogVariable(" Multi threaded", SystemInfo.graphicsMultiThreaded);
				LogSeperator();
			}));
			AddCommand(Command.Create("datapath", "", "Display information about where data is stored by Unity and the developer console", delegate
			{
				LogSeperator("Data paths");
				LogVariable("Data path", Application.dataPath);
				LogVariable("Persistent data path", Application.persistentDataPath);
				LogVariable("Developer console data path", DevConsoleData.FilePath);
				LogSeperator();
			}));
			AddCommand(Command.Create("colour", "color", "Display a colour in the developer console", Parameter.Create("colour", "Colour to display. Formats: #RRGGBBAA (hex), #RRGGBB (hex), name (red,yellow,etc.), R.R,G.G,B.B (0.0-1.0), RRR,GGG,BBB (0-255)"), delegate(Color colour)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				LogVariable("<color=#" + ColorUtility.ToHtmlStringRGBA(colour) + ">Colour</color>", colour);
			}, delegate
			{
				Log("Supported formats: #RRGGBBAA (hex), #RRGGBB (hex), name (red,yellow,etc.), R.R,G.G,B.B (0.0-1.0), RRR,GGG,BBB (0-255).");
			}));
			static string getTabbed(int tabAmount)
			{
				string text = string.Empty;
				for (int j = 0; j < tabAmount; j++)
				{
					text += ((j % 2 == 0) ? '|' : ' ');
				}
				return text;
			}
		}

		private void InitBuiltInParsers()
		{
			AddParameterType(typeof(bool), delegate(string s)
			{
				if (int.TryParse(s, out var result))
				{
					switch (result)
					{
					case 0:
						return false;
					case 1:
						return true;
					}
				}
				return Convert.ChangeType(s, typeof(bool));
			});
			AddParameterType(typeof(bool?), (string s) => (s.ToLower() == "null" || s == "~") ? null : ParseParameter(s, typeof(bool)));
			AddParameterType(typeof(Color), delegate(string s)
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: 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)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				Color black = default(Color);
				if (ColorUtility.TryParseHtmlString(s, ref black))
				{
					return black;
				}
				string[] array = s.Split(new char[1] { ',' });
				int num = Math.Min(4, array.Length);
				try
				{
					black = Color.black;
					for (int i = 0; i < num; i++)
					{
						((Color)(ref black))[i] = Mathf.RoundToInt((float)int.Parse(array[i]) / 255f);
					}
				}
				catch
				{
					black = Color.black;
					for (int j = 0; j < num; j++)
					{
						((Color)(ref black))[j] = float.Parse(array[j]);
					}
				}
				return black;
			});
		}

		private void InitAttributes()
		{
			string[] source = new string[12]
			{
				"Unity", "System", "Mono.", "mscorlib", "netstandard", "TextMeshPro", "Microsoft.GeneratedCode", "I18N", "Boo.", "UnityScript.",
				"ICSharpCode.", "ExCSS.Unity"
			};
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				string assemblyName = assembly.GetName().Name;
				if (source.Any((string a) => assemblyName.ToLower().StartsWith(a.ToLower())))
				{
					continue;
				}
				try
				{
					Type[] exportedTypes = assembly.GetExportedTypes();
					foreach (Type type in exportedTypes)
					{
						MethodInfo[] methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
						foreach (MethodInfo methodInfo in methods)
						{
							object[] customAttributes = methodInfo.GetCustomAttributes(typeof(DevConsoleCommandAttribute), inherit: false);
							for (int l = 0; l < customAttributes.Length; l++)
							{
								DevConsoleCommandAttribute devConsoleCommandAttribute = (DevConsoleCommandAttribute)customAttributes[l];
								if (devConsoleCommandAttribute != null)
								{
									AddCommand(Command.Create(devConsoleCommandAttribute, methodInfo), devConsoleCommandAttribute.OnlyInDevBuild, isCustomCommand: true);
								}
							}
						}
						FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
						foreach (FieldInfo fieldInfo in fields)
						{
							DevConsoleTrackedStatAttribute customAttribute = fieldInfo.GetCustomAttribute<DevConsoleTrackedStatAttribute>();
							if (customAttribute != null)
							{
								string text = customAttribute.Name ?? fieldInfo.Name;
								_stats[text] = new ReflectedStat(fieldInfo);
								if (!customAttribute.StartEnabled && !_persistStats.Contains(text))
								{
									_hiddenStats.Add(text);
								}
							}
						}
						PropertyInfo[] properties = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
						foreach (PropertyInfo propertyInfo in properties)
						{
							DevConsoleTrackedStatAttribute customAttribute2 = propertyInfo.GetCustomAttribute<DevConsoleTrackedStatAttribute>();
							if (customAttribute2 != null)
							{
								string text2 = customAttribute2.Name ?? propertyInfo.Name;
								_stats[text2] = new ReflectedStat(propertyInfo);
								if (!customAttribute2.StartEnabled && !_persistStats.Contains(text2))
								{
									_hiddenStats.Add(text2);
								}
							}
						}
					}
				}
				catch (NotSupportedException)
				{
				}
				catch (FileNotFoundException)
				{
				}
				catch (Exception ex3)
				{
					Debug.LogErr