using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using BabyStepsMultiplayerClient;
using BabyStepsMultiplayerClient.Audio;
using BabyStepsMultiplayerClient.Components;
using BabyStepsMultiplayerClient.Config;
using BabyStepsMultiplayerClient.Extensions;
using BabyStepsMultiplayerClient.Localization;
using BabyStepsMultiplayerClient.Networking;
using BabyStepsMultiplayerClient.Player;
using BabyStepsMultiplayerClient.UI;
using BabyStepsMultiplayerClient.UI.Elements;
using Concentus.Enums;
using Concentus.Structs;
using HarmonyLib;
using Il2Cpp;
using Il2CppBabySteps.Core.Audio;
using Il2CppCinemachine;
using Il2CppFMOD;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppNWH.DWP2.WaterObjects;
using Il2CppRewired;
using Il2CppSteamworks;
using Il2CppSystem;
using Il2CppSystem.Collections;
using Il2CppSystem.Collections.Generic;
using Il2CppTMPro;
using LiteNetLib;
using LiteNetLib.Layers;
using LiteNetLib.Utils;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Tomlet;
using Tomlet.Models;
using Unity.LiveCapture.ARKitFaceCapture;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "BabyStepsMultiplayerClient", "1.2.4", "Caleb Orchard", "https://github.com/caleborchard/Baby-Steps-Multiplayer-Mod-Client")]
[assembly: MelonGame("DefaultCompany", "BabySteps")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Caleb Orchard")]
[assembly: AssemblyConfiguration("Retail - Debug")]
[assembly: AssemblyDescription("A MelonLoader mod for Baby Steps that adds multiplayer to the game.")]
[assembly: AssemblyFileVersion("1.2.4")]
[assembly: AssemblyInformationalVersion("1.2.4+931a551492ce62dccc6d631d92b57b4fb3a16b8c")]
[assembly: AssemblyProduct("BabyStepsMultiplayerClient")]
[assembly: AssemblyTitle("BabyStepsMultiplayerClient")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/caleborchard/Baby-Steps-Multiplayer-Mod-Client")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BabyStepsMultiplayerClient
{
	public class Core : MelonMod
	{
		public const string SERVER_VERSION = "106";

		public static string CLIENT_VERSION;

		public const string cloneText = "(Clone)";

		public static Instance logger;

		public static UIManager uiManager;

		public static NetworkManager networkManager;

		public static Action OnConnectionStateChanged;

		public override void OnLateInitializeMelon()
		{
			CLIENT_VERSION = ((MelonBase)this).Info.Version;
			logger = ((MelonBase)this).LoggerInstance;
			try
			{
				((MelonBase)this).HarmonyInstance.PatchAll(Assembly.GetExecutingAssembly());
			}
			catch (Exception value)
			{
				logger.Error($"Harmony patching failed: {value}");
			}
			ManagedEnumerator.Register();
			uiManager = new UIManager();
			networkManager = new NetworkManager();
			MultiplayerMenu.Initialize();
			logger.Msg("Initialized!");
			VersionCheck.CheckForUpdate();
		}

		public override void OnGUI()
		{
			if (uiManager != null)
			{
				uiManager.Draw();
			}
		}

		public override void OnUpdate()
		{
			if (uiManager == null || networkManager == null)
			{
				return;
			}
			uiManager.Update();
			networkManager.Update();
			MultiplayerMenu.Update();
			if (LocalPlayer.Instance != null)
			{
				LocalPlayer.Instance.Update();
			}
			if (MelonDebug.IsEnabled())
			{
				if (Input.GetKeyDown((KeyCode)284))
				{
					networkManager.Connect(ModSettings.connection.Address.Value, ModSettings.connection.Port.Value, ModSettings.connection.Password.Value);
				}
				if (Input.GetKeyDown((KeyCode)285))
				{
					networkManager.Disconnect();
				}
			}
		}

		public override void OnLateUpdate()
		{
			if (networkManager != null)
			{
				if (LocalPlayer.Instance != null)
				{
					LocalPlayer.Instance.LateUpdate();
				}
				networkManager.LateUpdate();
			}
		}

		public override void OnApplicationQuit()
		{
			if (networkManager != null)
			{
				networkManager.Disconnect();
			}
		}

		public static bool HasLoadedGame()
		{
			if ((Object)(object)Menu.me == (Object)null)
			{
				return false;
			}
			return Menu.me.gameInProgress;
		}

		public static void DebugMsg(string msg)
		{
			logger.Msg(msg);
		}

		public static bool RegisterComponent<T>(params Type[] interfaces) where T : class
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			try
			{
				RegisterTypeOptions val = new RegisterTypeOptions();
				val.set_LogSuccess(true);
				val.set_Interfaces(Il2CppInterfaceCollection.op_Implicit(interfaces));
				ClassInjector.RegisterTypeInIl2Cpp<T>(val);
			}
			catch (Exception value)
			{
				logger.Error($"Exception while attempting to Register {typeof(T).Name}: {value}");
				return false;
			}
			return true;
		}
	}
	public static class ModSettings
	{
		public static readonly ConnectionConfig connection = new ConnectionConfig();

		public static readonly PlayerConfig player = new PlayerConfig();

		public static readonly AudioConfig audio = new AudioConfig();

		public static void Load()
		{
			connection.Load();
			player.Load();
			audio.Load();
		}

		public static void Save()
		{
			connection.Save();
			player.Save();
			audio.Save();
		}
	}
}
namespace BabyStepsMultiplayerClient.UI
{
	internal static class InputBindingHelper
	{
		private static readonly bool CaptureLoggingEnabled = true;

		private const string RewiredActionPrefix = "RWACTION:";

		private const string RewiredButtonPrefix = "RWBTN:";

		private const string RewiredAxisPrefix = "RWAXIS:";

		private const float AxisThreshold = 0.5f;

		private const int MaxRawRewiredButtonId = 1023;

		private static readonly Dictionary<string, bool> _previousState = new Dictionary<string, bool>();

		private static readonly int[] _inputActionIds = BuildInputActionIdList();

		private static readonly KeyCode[] _joystickButtonKeyCodes = BuildJoystickButtonKeyCodes();

		public static bool IsInputHeldForCapture()
		{
			if (Input.anyKey)
			{
				return true;
			}
			for (int i = 0; i < _joystickButtonKeyCodes.Length; i++)
			{
				if (Input.GetKey(_joystickButtonKeyCodes[i]))
				{
					return true;
				}
			}
			return false;
		}

		public static bool TryCapturePressedBinding(out string binding, out string displayName)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Invalid comparison between Unknown and I4
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _joystickButtonKeyCodes.Length; i++)
			{
				KeyCode val = _joystickButtonKeyCodes[i];
				if (Input.GetKeyDown(val))
				{
					binding = ((object)(KeyCode)(ref val)).ToString();
					displayName = ((object)(KeyCode)(ref val)).ToString();
					LogCapture("joystick-keycode", binding, displayName);
					return true;
				}
			}
			foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
			{
				KeyCode val2 = value;
				if ((int)val2 == 0 || IsJoystickKeyCode(val2) || !Input.GetKeyDown(val2))
				{
					continue;
				}
				binding = ((object)(KeyCode)(ref val2)).ToString();
				displayName = ((object)(KeyCode)(ref val2)).ToString();
				LogCapture("keyboard", binding, displayName);
				return true;
			}
			Menu me = Menu.me;
			Player val3 = ((me != null) ? me.rwPlayer : null);
			if (val3 != null)
			{
				for (int j = 0; j < _inputActionIds.Length; j++)
				{
					int num = _inputActionIds[j];
					if (val3.GetButtonDown(num))
					{
						if (!TryGetInputActionName(num, out var actionName))
						{
							actionName = "Action_" + num;
						}
						if (!IsAxisLikeAction(num, actionName))
						{
							binding = "RWACTION:" + actionName;
							displayName = FormatActionDisplayName(actionName);
							LogCapture("rewired-action", binding, displayName);
							return true;
						}
					}
				}
				if (TryCaptureAxisDown(out binding, out displayName))
				{
					return true;
				}
				for (int k = 0; k <= 1023; k++)
				{
					if (val3.GetButtonDown(k))
					{
						binding = "RWBTN:" + k;
						displayName = GetRewiredButtonDisplayName(k);
						LogCapture("rewired-raw-button", binding, displayName);
						return true;
					}
				}
			}
			binding = null;
			displayName = null;
			return false;
		}

		public static bool IsPressed(string binding)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (TryParseKeyCode(binding, out var keyCode))
			{
				return Input.GetKey(keyCode);
			}
			if (TryParseRewiredButton(binding, out var actionId))
			{
				Menu me = Menu.me;
				int result;
				if (me == null)
				{
					result = 0;
				}
				else
				{
					Player rwPlayer = me.rwPlayer;
					result = (((rwPlayer != null) ? new bool?(rwPlayer.GetButton(actionId)) : null).GetValueOrDefault() ? 1 : 0);
				}
				return (byte)result != 0;
			}
			if (TryParseRewiredAction(binding, out var actionName) && TryGetInputActionId(actionName, out var actionId2))
			{
				Menu me2 = Menu.me;
				int result2;
				if (me2 == null)
				{
					result2 = 0;
				}
				else
				{
					Player rwPlayer2 = me2.rwPlayer;
					result2 = (((rwPlayer2 != null) ? new bool?(rwPlayer2.GetButton(actionId2)) : null).GetValueOrDefault() ? 1 : 0);
				}
				return (byte)result2 != 0;
			}
			if (TryParseRewiredAxis(binding, out var axisId, out var direction))
			{
				Menu me3 = Menu.me;
				Player val = ((me3 != null) ? me3.rwPlayer : null);
				if (val == null)
				{
					return false;
				}
				float axis = val.GetAxis(axisId);
				return (direction > 0) ? (axis > 0.5f) : (axis < -0.5f);
			}
			return false;
		}

		public static bool IsDown(string binding)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (TryParseKeyCode(binding, out var keyCode))
			{
				return Input.GetKeyDown(keyCode);
			}
			if (TryParseRewiredButton(binding, out var actionId))
			{
				Menu me = Menu.me;
				int result;
				if (me == null)
				{
					result = 0;
				}
				else
				{
					Player rwPlayer = me.rwPlayer;
					result = (((rwPlayer != null) ? new bool?(rwPlayer.GetButtonDown(actionId)) : null).GetValueOrDefault() ? 1 : 0);
				}
				return (byte)result != 0;
			}
			if (TryParseRewiredAction(binding, out var actionName) && TryGetInputActionId(actionName, out var actionId2))
			{
				Menu me2 = Menu.me;
				int result2;
				if (me2 == null)
				{
					result2 = 0;
				}
				else
				{
					Player rwPlayer2 = me2.rwPlayer;
					result2 = (((rwPlayer2 != null) ? new bool?(rwPlayer2.GetButtonDown(actionId2)) : null).GetValueOrDefault() ? 1 : 0);
				}
				return (byte)result2 != 0;
			}
			if (TryParseRewiredAxis(binding, out var _, out var _))
			{
				bool flag = IsPressed(binding);
				_previousState.TryGetValue(binding, out var value);
				_previousState[binding] = flag;
				return flag && !value;
			}
			return false;
		}

		public static bool IsControllerBinding(string binding)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(binding))
			{
				return false;
			}
			if (TryParseKeyCode(binding, out var keyCode))
			{
				return IsJoystickKeyCode(keyCode);
			}
			if (binding.StartsWith("RWACTION:", StringComparison.Ordinal) || binding.StartsWith("RWBTN:", StringComparison.Ordinal) || binding.StartsWith("RWAXIS:", StringComparison.Ordinal))
			{
				return true;
			}
			return false;
		}

		public static string GetDisplayName(string binding)
		{
			if (TryParseRewiredAction(binding, out var actionName))
			{
				return FormatActionDisplayName(actionName);
			}
			if (TryParseRewiredButton(binding, out var actionId))
			{
				return GetRewiredButtonDisplayName(actionId);
			}
			if (TryParseRewiredAxis(binding, out var axisId, out var direction))
			{
				switch (axisId)
				{
				case 13:
					return (direction > 0) ? "AXIS Up" : "AXIS Down";
				case 12:
					return (direction > 0) ? "AXIS Right" : "AXIS Left";
				}
			}
			return binding;
		}

		private static bool TryParseKeyCode(string binding, out KeyCode keyCode)
		{
			if (string.IsNullOrWhiteSpace(binding))
			{
				keyCode = (KeyCode)0;
				return false;
			}
			if (!Enum.TryParse<KeyCode>(binding, ignoreCase: true, out keyCode))
			{
				return false;
			}
			return (int)keyCode != 0;
		}

		private static bool TryParseRewiredButton(string binding, out int actionId)
		{
			actionId = -1;
			if (string.IsNullOrWhiteSpace(binding) || !binding.StartsWith("RWBTN:", StringComparison.Ordinal))
			{
				return false;
			}
			return int.TryParse(binding.Substring("RWBTN:".Length), out actionId);
		}

		private static bool TryParseRewiredAction(string binding, out string actionName)
		{
			actionName = null;
			if (string.IsNullOrWhiteSpace(binding) || !binding.StartsWith("RWACTION:", StringComparison.Ordinal))
			{
				return false;
			}
			actionName = binding.Substring("RWACTION:".Length);
			return !string.IsNullOrWhiteSpace(actionName);
		}

		private static bool TryParseRewiredAxis(string binding, out int axisId, out int direction)
		{
			axisId = -1;
			direction = 0;
			if (string.IsNullOrWhiteSpace(binding) || !binding.StartsWith("RWAXIS:", StringComparison.Ordinal))
			{
				return false;
			}
			string text = binding.Substring("RWAXIS:".Length);
			string[] array = text.Split(':');
			if (array.Length != 2)
			{
				return false;
			}
			if (!int.TryParse(array[0], out axisId))
			{
				return false;
			}
			if (array[1] == "+")
			{
				direction = 1;
				return true;
			}
			if (array[1] == "-")
			{
				direction = -1;
				return true;
			}
			return false;
		}

		private static bool TryCaptureAxisDown(out string binding, out string displayName)
		{
			Menu me = Menu.me;
			Player val = ((me != null) ? me.rwPlayer : null);
			if (val == null)
			{
				binding = null;
				displayName = null;
				return false;
			}
			float axis = val.GetAxis(12);
			float axisPrev = val.GetAxisPrev(12);
			float axis2 = val.GetAxis(13);
			float axisPrev2 = val.GetAxisPrev(13);
			if (axis2 > 0.5f && axisPrev2 <= 0.5f)
			{
				binding = "RWAXIS:" + 13 + ":+";
				displayName = "AXIS Up";
				LogCapture("rewired-axis", binding, displayName);
				return true;
			}
			if (axis2 < -0.5f && axisPrev2 >= -0.5f)
			{
				binding = "RWAXIS:" + 13 + ":-";
				displayName = "AXIS Down";
				LogCapture("rewired-axis", binding, displayName);
				return true;
			}
			if (axis > 0.5f && axisPrev <= 0.5f)
			{
				binding = "RWAXIS:" + 12 + ":+";
				displayName = "AXIS Right";
				LogCapture("rewired-axis", binding, displayName);
				return true;
			}
			if (axis < -0.5f && axisPrev >= -0.5f)
			{
				binding = "RWAXIS:" + 12 + ":-";
				displayName = "AXIS Left";
				LogCapture("rewired-axis", binding, displayName);
				return true;
			}
			binding = null;
			displayName = null;
			return false;
		}

		private static string GetRewiredButtonDisplayName(int actionId)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.IsDefined(typeof(InputActions), actionId))
			{
				InputActions val = (InputActions)actionId;
				return ((object)(InputActions)(ref val)).ToString();
			}
			return "Controller Button " + actionId;
		}

		private static int[] BuildInputActionIdList()
		{
			Array values = Enum.GetValues(typeof(InputActions));
			List<int> list = new List<int>(values.Length);
			HashSet<int> hashSet = new HashSet<int>();
			for (int i = 0; i < values.Length; i++)
			{
				int item = (int)values.GetValue(i);
				if (hashSet.Add(item))
				{
					list.Add(item);
				}
			}
			list.Sort();
			return list.ToArray();
		}

		private static bool TryGetInputActionName(int actionId, out string actionName)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			actionName = null;
			if (!Enum.IsDefined(typeof(InputActions), actionId))
			{
				return false;
			}
			InputActions val = (InputActions)actionId;
			actionName = ((object)(InputActions)(ref val)).ToString();
			return !string.IsNullOrWhiteSpace(actionName);
		}

		private static bool TryGetInputActionId(string actionName, out int actionId)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected I4, but got Unknown
			actionId = -1;
			if (string.IsNullOrWhiteSpace(actionName))
			{
				return false;
			}
			if (!Enum.TryParse<InputActions>(actionName, ignoreCase: true, out InputActions result))
			{
				return false;
			}
			actionId = (int)result;
			return true;
		}

		private static bool IsAxisLikeAction(int actionId, string actionName)
		{
			if (actionId == 12 || actionId == 13)
			{
				return true;
			}
			if (string.IsNullOrWhiteSpace(actionName))
			{
				return false;
			}
			return actionName.IndexOf("Horizontal", StringComparison.OrdinalIgnoreCase) >= 0 || actionName.IndexOf("Vertical", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static KeyCode[] BuildJoystickButtonKeyCodes()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			List<KeyCode> list = new List<KeyCode>();
			for (int i = 0; i <= 19; i++)
			{
				if (Enum.TryParse<KeyCode>("JoystickButton" + i, out KeyCode result))
				{
					list.Add(result);
				}
			}
			for (int j = 1; j <= 8; j++)
			{
				for (int k = 0; k <= 19; k++)
				{
					if (Enum.TryParse<KeyCode>("Joystick" + j + "Button" + k, out KeyCode result2))
					{
						list.Add(result2);
					}
				}
			}
			return list.ToArray();
		}

		private static bool IsJoystickKeyCode(KeyCode keyCode)
		{
			string text = ((object)(KeyCode)(ref keyCode)).ToString();
			return text.IndexOf("Joystick", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static string FormatActionDisplayName(string actionName)
		{
			if (string.IsNullOrWhiteSpace(actionName))
			{
				return actionName;
			}
			if (actionName.StartsWith("UI", StringComparison.OrdinalIgnoreCase))
			{
				return "DPAD " + actionName.Substring(2);
			}
			return actionName;
		}

		private static void LogCapture(string source, string binding, string displayName)
		{
			if (CaptureLoggingEnabled)
			{
				Core.DebugMsg($"[BindCapture] source={source} binding={binding} display={displayName}");
			}
		}
	}
	public static class MenuInjectionLibrary
	{
		public sealed class RuntimeTabMenu
		{
			private readonly string[] _tabNames;

			private readonly List<Selectable>[] _pageSelectables;

			private int _setTabFrame = -1;

			private Selectable[] _fixedItems;

			public RectTransform Root { get; internal set; }

			public RectTransform Header { get; internal set; }

			public Button[] Tabs { get; internal set; }

			public RectTransform[] Pages { get; internal set; }

			public int ActiveTab { get; private set; }

			public int TabCount
			{
				get
				{
					Button[] tabs = Tabs;
					return (tabs != null) ? tabs.Length : 0;
				}
			}

			internal MenuItemList ManagedItemList { get; set; }

			internal Color NativeHighlightedColor { get; set; } = TabHighlighted;


			internal void SetFixedMenuItems(params Selectable[] items)
			{
				_fixedItems = items;
			}

			internal RuntimeTabMenu(string[] tabNames)
			{
				//IL_0008: 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)
				_tabNames = tabNames;
				_pageSelectables = new List<Selectable>[tabNames.Length];
				for (int i = 0; i < tabNames.Length; i++)
				{
					_pageSelectables[i] = new List<Selectable>();
				}
			}

			public RectTransform GetPage(int index)
			{
				return (Pages != null && index >= 0 && index < Pages.Length) ? Pages[index] : null;
			}

			public void OnShown()
			{
				SetActiveTab(ActiveTab);
			}

			internal void RegisterPageSelectable(int page, Selectable s)
			{
				if (!((Object)(object)s == (Object)null) && _pageSelectables != null && page >= 0 && page < _pageSelectables.Length)
				{
					_pageSelectables[page].Add(s);
				}
			}

			public void SetActiveTab(int index)
			{
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_0213: Unknown result type (might be due to invalid IL or missing references)
				//IL_0218: Unknown result type (might be due to invalid IL or missing references)
				//IL_021c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_0235: Unknown result type (might be due to invalid IL or missing references)
				//IL_0243: Unknown result type (might be due to invalid IL or missing references)
				//IL_0250: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
				if (Tabs == null || Pages == null || index < 0 || index >= TabCount)
				{
					return;
				}
				int frameCount = Time.frameCount;
				if (frameCount == _setTabFrame)
				{
					return;
				}
				_setTabFrame = frameCount;
				ActiveTab = index;
				List<Selectable>[] pageSelectables = _pageSelectables;
				List<Selectable> list = ((pageSelectables != null) ? pageSelectables[index] : null);
				for (int i = 0; i < TabCount; i++)
				{
					bool flag = i == index;
					if ((Object)(object)Pages[i] != (Object)null)
					{
						CanvasGroup component = ((Component)Pages[i]).GetComponent<CanvasGroup>();
						if ((Object)(object)component != (Object)null)
						{
							component.alpha = (flag ? 1f : 0f);
							component.interactable = flag;
							component.blocksRaycasts = flag;
						}
						if (flag)
						{
							Il2CppArrayBase<TMP_Text> componentsInChildren = ((Component)Pages[i]).GetComponentsInChildren<TMP_Text>(true);
							for (int j = 0; j < componentsInChildren.Length; j++)
							{
								if ((Object)(object)componentsInChildren[j] != (Object)null)
								{
									componentsInChildren[j].ForceMeshUpdate(false, false);
								}
							}
						}
					}
					if (!((Object)(object)Tabs[i] != (Object)null))
					{
						continue;
					}
					Color val = (flag ? TabSelected : TabUnselected);
					Image component2 = ((Component)Tabs[i]).GetComponent<Image>();
					if ((Object)(object)component2 != (Object)null)
					{
						((Graphic)component2).color = Color.white;
						((Graphic)component2).CrossFadeColor(val, 0f, true, true);
					}
					TMP_Text componentInChildren = ((Component)Tabs[i]).GetComponentInChildren<TMP_Text>(true);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						if (_tabNames != null && i < _tabNames.Length)
						{
							componentInChildren.text = _tabNames[i];
						}
						((Graphic)componentInChildren).color = TabText;
						componentInChildren.ForceMeshUpdate(false, false);
					}
					ColorBlock colors = ((Selectable)Tabs[i]).colors;
					((ColorBlock)(ref colors)).normalColor = val;
					((ColorBlock)(ref colors)).selectedColor = NativeHighlightedColor;
					((ColorBlock)(ref colors)).highlightedColor = NativeHighlightedColor;
					((ColorBlock)(ref colors)).pressedColor = NativeHighlightedColor;
					((ColorBlock)(ref colors)).disabledColor = val;
					((ColorBlock)(ref colors)).colorMultiplier = 1f;
					((Selectable)Tabs[i]).colors = colors;
				}
				int num = list?.Count ?? 0;
				Selectable[] fixedItems = _fixedItems;
				int num2 = ((fixedItems != null) ? fixedItems.Length : 0);
				List<Selectable> list2 = new List<Selectable>(num + num2);
				for (int k = 0; k < num; k++)
				{
					if ((Object)(object)list[k] != (Object)null)
					{
						list2.Add(list[k]);
					}
				}
				for (int l = 0; l < num2; l++)
				{
					if ((Object)(object)_fixedItems[l] != (Object)null)
					{
						list2.Add(_fixedItems[l]);
					}
				}
				if ((Object)(object)ManagedItemList != (Object)null)
				{
					GameObject[] array = (GameObject[])(object)new GameObject[list2.Count];
					for (int m = 0; m < list2.Count; m++)
					{
						array[m] = ((Component)list2[m]).gameObject;
					}
					ManagedItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit(array);
				}
				for (int n = 0; n < list2.Count; n++)
				{
					Selectable val2 = list2[n];
					Navigation navigation = val2.navigation;
					navigation.mode = (Mode)4;
					navigation.selectOnUp = ((n > 0) ? list2[n - 1] : null);
					navigation.selectOnDown = ((n < list2.Count - 1) ? list2[n + 1] : null);
					navigation.selectOnLeft = null;
					navigation.selectOnRight = null;
					val2.navigation = navigation;
				}
			}
		}

		public sealed class TabBuilder
		{
			internal TabBuilder()
			{
			}

			public TMP_Text AddLabel(string text)
			{
				return MenuInjectionLibrary.AddLabel(text, (RectTransform)null);
			}

			public Button AddButton(string text, UnityAction onClick)
			{
				return MenuInjectionLibrary.AddButton(text, onClick, (RectTransform)null);
			}

			public Toggle AddToggle(string text, bool initial, UnityAction<bool> onChange)
			{
				return MenuInjectionLibrary.AddToggle(text, initial, onChange, (RectTransform)null);
			}

			public Slider AddSlider(string text, float min, float max, float value, UnityAction<float> onChange, bool wholeNumbers = false)
			{
				return MenuInjectionLibrary.AddSlider(text, min, max, value, onChange, wholeNumbers, (RectTransform)null);
			}

			public Button AddInputField(string placeholder = "", UnityAction<string> onChange = null, string initialValue = null)
			{
				return MenuInjectionLibrary.AddInputField(placeholder, onChange, initialValue, (RectTransform)null);
			}

			public Image AddImage(Color color, float height = 52f)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return MenuInjectionLibrary.AddImage(color, height, (RectTransform)null);
			}
		}

		public sealed class MenuBuilder
		{
			internal readonly string _mainButtonLabel;

			internal readonly List<(string name, Action<TabBuilder> configure)> _tabs = new List<(string, Action<TabBuilder>)>();

			internal readonly List<(string label, UnityAction action)> _fixed = new List<(string, UnityAction)>();

			internal float _sideMargin;

			internal float _topMargin;

			internal MenuBuilder(string mainButtonLabel)
			{
				_mainButtonLabel = mainButtonLabel;
			}

			public MenuBuilder AddTab(string name, Action<TabBuilder> configure)
			{
				_tabs.Add((name, configure));
				return this;
			}

			public MenuBuilder AddFixedButton(string label, UnityAction action = null)
			{
				_fixed.Add((label, action));
				return this;
			}

			public MenuBuilder WithMargin(float sideMargin, float topMargin)
			{
				_sideMargin = sideMargin;
				_topMargin = topMargin;
				return this;
			}

			public InjectedMenu Build()
			{
				InjectedMenu injectedMenu = new InjectedMenu(this);
				if (!_registeredMenus.Contains(injectedMenu))
				{
					_registeredMenus.Add(injectedMenu);
				}
				return injectedMenu;
			}
		}

		internal sealed class InputFieldInfo
		{
			public string Value = "";

			public TMP_Text DisplayText;

			public UnityAction<string> OnChanged;

			public string Placeholder = "";

			public RectTransform Viewport;

			public Color ActiveColor = Color.white;

			public Color PlaceholderColor = new Color(1f, 1f, 1f, 0.45f);

			public Button OwnerButton;

			public Image CursorImage;
		}

		public sealed class InjectedMenu
		{
			[CompilerGenerated]
			private sealed class <EnforceKeyboardFontSizesCoroutine>d__73 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public InjectedMenu <>4__this;

				private int <i>5__1;

				object IEnumerator<object>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <EnforceKeyboardFontSizesCoroutine>d__73(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<i>5__1 = 0;
						break;
					case 1:
						<>1__state = -1;
						<i>5__1++;
						break;
					}
					if (<i>5__1 < 3)
					{
						<>4__this.ForceKeyboardFontSizes();
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					return false;
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}
			}

			private readonly string _mainButtonLabel;

			private readonly List<(string name, Action<TabBuilder> configure)> _tabDescs;

			private readonly List<(string label, UnityAction action)> _fixedDescs;

			private Menu _activeMenu;

			private RuntimeTabMenu _tabMenu;

			private bool _contentBuilt;

			private bool _hasAttemptedInitialDump;

			private GameObject _mainButtonObj;

			private Button _mainButton;

			private Transform _mainMenuRoot;

			private CanvasGroup _mainMenuCG;

			private MenuItemList _mainMenuItemList;

			private GameObject _submenuObj;

			private CanvasGroup _submenuCG;

			private MenuItemList _submenuItemList;

			private readonly List<Button> _fixedButtonInstances = new List<Button>();

			private GameObject _kbRoot;

			private CanvasGroup _kbCG;

			private Button[][] _kbCharRows;

			private string[][] _kbLowerRows;

			private string[][] _kbUpperRows;

			private Button[] _kbSpecialRow;

			private readonly List<GameObject> _kbAllButtons = new List<GameObject>();

			private bool _kbShift;

			private bool _kbUseLowercaseFontForKeyLabels;

			private Button _kbShiftBtn;

			private InputFieldInfo _kbActiveField;

			private Button _kbReturnButton;

			private Action _kbOnDone;

			private bool _kbBuilt;

			private bool _kbHasEdited;

			private int _kbNavFrame = -1;

			private float _kbCursorTimer = 0f;

			private bool _kbCursorVisible = true;

			private InputFieldInfo _mouseTypingField;

			private bool _mouseTypingActive;

			private int _mouseTypingNavFrame = -1;

			private int _mouseCursorBlinkFrame = -1;

			private bool _mouseHasEdited;

			private float _mouseCursorTimer = 0f;

			private bool _mouseCursorVisible = true;

			private bool _kbUsingOverlay;

			private const float CanvasW = 860f;

			private const float CanvasH = 650f;

			private const float ContentH = 460f;

			private const float ContentPad = 10f;

			private readonly float _sideMargin;

			private readonly float _topMargin;

			private RectTransform _submenuRect;

			internal bool IsMouseTyping => _mouseTypingActive;

			private bool KbVisible => (Object)(object)_kbCG != (Object)null && _kbCG.alpha > 0.5f;

			internal bool IsKeyboardOpen => _kbActiveField != null;

			private bool IsKbButton(GameObject go)
			{
				return (Object)(object)go != (Object)null && _kbAllButtons.Contains(go);
			}

			internal InjectedMenu(MenuBuilder b)
			{
				_mainButtonLabel = b._mainButtonLabel;
				_tabDescs = b._tabs;
				_fixedDescs = b._fixed;
				_sideMargin = b._sideMargin;
				_topMargin = b._topMargin;
			}

			public Button GetFixedButton(int index)
			{
				return (index >= 0 && index < _fixedButtonInstances.Count) ? _fixedButtonInstances[index] : null;
			}

			public void OnMenuAwake(Menu menu)
			{
				_activeMenu = menu;
				TryInject(menu, "Awake");
			}

			public void OnMenuPreUpdate(Menu menu)
			{
				//IL_0485: Unknown result type (might be due to invalid IL or missing references)
				//IL_048b: Invalid comparison between Unknown and I4
				_activeMenu = menu;
				if ((Object)(object)menu == (Object)null)
				{
					return;
				}
				if ((Object)(object)_mainButtonObj == (Object)null || (Object)(object)_submenuObj == (Object)null)
				{
					TryInject(menu, "PreUpdateRetry");
				}
				bool submenuVisible = GetSubmenuVisible();
				bool kbVisible = KbVisible;
				bool isCapturingKeybind = MultiplayerMenu.IsCapturingKeybind;
				if (kbVisible)
				{
					HandleKeyboardInput(menu, isCapturingKeybind, submenuVisible);
				}
				if (submenuVisible && !kbVisible && !isCapturingKeybind)
				{
					TryHandleCancel(menu);
					if (_mouseTypingActive && _mouseTypingField != null && Time.frameCount != _mouseTypingNavFrame)
					{
						_mouseTypingNavFrame = Time.frameCount;
						bool flag = false;
						string inputString = Input.inputString;
						for (int i = 0; i < inputString.Length; i++)
						{
							char c = inputString[i];
							switch (c)
							{
							case '\b':
								if (_mouseTypingField.Value.Length > 0)
								{
									_mouseTypingField.Value = _mouseTypingField.Value.Substring(0, _mouseTypingField.Value.Length - 1);
									flag = true;
								}
								continue;
							default:
								if (c != '\n')
								{
									_mouseTypingField.Value += c;
									flag = true;
									continue;
								}
								break;
							case '\r':
								break;
							}
							_mouseTypingField.OnChanged?.Invoke(_mouseTypingField.Value);
							CloseMouseTyping(restoreSelection: false);
							flag = false;
							break;
						}
						if (Input.GetKeyDown((KeyCode)27) && _mouseTypingActive)
						{
							CloseMouseTyping();
							flag = false;
						}
						if (Input.GetMouseButtonDown(0) && _mouseTypingActive && (Object)(object)_mouseTypingField?.OwnerButton != (Object)null && !IsPointerOverGameObject(((Component)_mouseTypingField.OwnerButton).gameObject))
						{
							CloseMouseTyping(restoreSelection: false);
							flag = false;
						}
						if (flag && _mouseTypingField != null)
						{
							_mouseHasEdited = true;
							RefreshMouseTypingDisplay();
							_mouseTypingField.OnChanged?.Invoke(_mouseTypingField.Value);
						}
					}
					if (_mouseTypingActive && (Object)(object)_mouseTypingField?.DisplayText != (Object)null && Time.frameCount != _mouseCursorBlinkFrame)
					{
						_mouseCursorBlinkFrame = Time.frameCount;
						_mouseCursorTimer += Time.unscaledDeltaTime;
						if (_mouseCursorTimer >= 0.53f)
						{
							_mouseCursorTimer = 0f;
							_mouseCursorVisible = !_mouseCursorVisible;
							RefreshMouseTypingDisplay();
						}
					}
					if (_tabMenu != null && menu.rwPlayer != null)
					{
						if (menu.rwPlayer.GetButtonDown(18))
						{
							_tabMenu.SetActiveTab((_tabMenu.ActiveTab - 1 + _tabMenu.TabCount) % _tabMenu.TabCount);
						}
						else if (menu.rwPlayer.GetButtonDown(17))
						{
							_tabMenu.SetActiveTab((_tabMenu.ActiveTab + 1) % _tabMenu.TabCount);
						}
					}
				}
				if (kbVisible)
				{
					if (submenuVisible && (Object)(object)_submenuItemList != (Object)null)
					{
						MenuItemList.active = _submenuItemList;
					}
				}
				else if (submenuVisible)
				{
					if ((Object)(object)_submenuItemList != (Object)null)
					{
						MenuItemList.active = _submenuItemList;
					}
					if (_mouseTypingActive && (Object)(object)_mouseTypingField?.OwnerButton != (Object)null && (Object)(object)_submenuItemList != (Object)null)
					{
						_submenuItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit((GameObject[])(object)new GameObject[1] { ((Component)_mouseTypingField.OwnerButton).gameObject });
					}
				}
				else if ((int)menu.currentMenuScreen == 0 && (Object)(object)_mainMenuItemList != (Object)null)
				{
					MenuItemList.active = _mainMenuItemList;
				}
			}

			private void HandleKeyboardInput(Menu menu, bool isCapturingKeybind, bool submenuVisible)
			{
				EventSystem current = EventSystem.current;
				GameObject val = ((current != null) ? current.currentSelectedGameObject : null);
				if (((Object)(object)val == (Object)null || !IsKbButton(val)) && _kbCharRows != null && _kbCharRows.Length != 0)
				{
					val = ((Component)_kbCharRows[0][0]).gameObject;
					if (current != null)
					{
						current.SetSelectedGameObject(val);
					}
				}
				if (!isCapturingKeybind && Time.frameCount != _kbNavFrame)
				{
					_kbNavFrame = Time.frameCount;
					if ((Object)(object)val != (Object)null && IsKbButton(val) && menu.rwPlayer != null)
					{
						float axis = menu.rwPlayer.GetAxis(12);
						float axisPrev = menu.rwPlayer.GetAxisPrev(12);
						float axis2 = menu.rwPlayer.GetAxis(13);
						float axisPrev2 = menu.rwPlayer.GetAxisPrev(13);
						Selectable component = val.GetComponent<Selectable>();
						Selectable val2 = null;
						if (axis2 < -0.5f && axisPrev2 >= -0.5f)
						{
							val2 = ((component != null) ? component.navigation.selectOnDown : null);
						}
						else if (axis2 > 0.5f && axisPrev2 <= 0.5f)
						{
							val2 = ((component != null) ? component.navigation.selectOnUp : null);
						}
						else if (axis > 0.5f && axisPrev <= 0.5f)
						{
							val2 = ((component != null) ? component.navigation.selectOnRight : null);
						}
						else if (axis < -0.5f && axisPrev >= -0.5f)
						{
							val2 = ((component != null) ? component.navigation.selectOnLeft : null);
						}
						if ((Object)(object)val2 != (Object)null)
						{
							if (current != null)
							{
								current.SetSelectedGameObject(((Component)val2).gameObject);
							}
							val = ((Component)val2).gameObject;
						}
						if (_kbUsingOverlay && (Input.GetKeyDown((KeyCode)330) || Input.GetKeyDown((KeyCode)331)))
						{
							Button val3 = ((val != null) ? val.GetComponent<Button>() : null);
							if (val3 != null)
							{
								((UnityEvent)val3.onClick).Invoke();
							}
						}
					}
					if (menu.rwPlayer != null && (Input.GetKeyDown((KeyCode)27) || Input.GetKeyDown((KeyCode)332) || menu.rwPlayer.GetButtonDown(15)))
					{
						CloseKeyboardOverlay((Object)(object)_kbReturnButton == (Object)null && _kbOnDone != null);
					}
					if ((Object)(object)_kbActiveField?.DisplayText != (Object)null)
					{
						_kbCursorTimer += Time.unscaledDeltaTime;
						if (_kbCursorTimer >= 0.53f)
						{
							_kbCursorTimer = 0f;
							_kbCursorVisible = !_kbCursorVisible;
							KbBlinkCursor();
						}
					}
				}
				if (submenuVisible && (Object)(object)_submenuItemList != (Object)null && (Object)(object)val != (Object)null)
				{
					_submenuItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit((GameObject[])(object)new GameObject[1] { val });
				}
			}

			public void OnMenuUpdate(Menu menu)
			{
				_activeMenu = menu;
				if (!((Object)(object)menu == (Object)null))
				{
					if (Input.GetKeyDown((KeyCode)289))
					{
					}
					if (Input.GetKeyDown((KeyCode)290))
					{
						Reset();
						TryInject(menu, "Reinject_F9");
					}
					if ((Object)(object)_mainButtonObj == (Object)null || (Object)(object)_submenuObj == (Object)null)
					{
						TryInject(menu, "UpdateRetry");
					}
					UpdateVisibility(menu);
					EnsureSelection();
				}
			}

			private void TryInject(Menu menu, string reason)
			{
				if ((Object)(object)menu == (Object)null)
				{
					return;
				}
				ResolveExisting(menu);
				if (!_hasAttemptedInitialDump)
				{
					_hasAttemptedInitialDump = true;
				}
				if ((Object)(object)menu.mainMenuCanvas == (Object)null)
				{
					return;
				}
				Button val = FindTemplateButton(menu);
				if (!((Object)(object)val == (Object)null))
				{
					_mainMenuRoot = ((Component)val).transform.parent;
					if ((Object)(object)_mainMenuRoot != (Object)null)
					{
						_mainMenuCG = ((Component)_mainMenuRoot).GetComponent<CanvasGroup>() ?? ((Component)_mainMenuRoot).gameObject.AddComponent<CanvasGroup>();
						_mainMenuItemList = ((Component)_mainMenuRoot).GetComponent<MenuItemList>();
					}
					if ((Object)(object)_mainButtonObj == (Object)null)
					{
						_mainButtonObj = BuildMainButton(menu, val);
					}
					if ((Object)(object)_submenuObj == (Object)null)
					{
						_submenuObj = BuildSubmenu(menu, val);
					}
					IntegrateIntoMainItemList();
					EnsureTabContent(menu, val);
					UpdateVisibility(menu);
				}
			}

			private void EnsureTabContent(Menu menu, Button tmpl)
			{
				if (_contentBuilt || (Object)(object)_submenuObj == (Object)null)
				{
					return;
				}
				Transform obj = _submenuObj.transform.Find("CustomSettingsContentRoot");
				RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Button nativeTabSource = null;
				Menu me = Menu.me;
				if ((Object)(object)((me != null) ? me.tabs : null) != (Object)null)
				{
					Transform transform = ((Component)Menu.me.tabs).transform;
					for (int i = 0; i < transform.childCount; i++)
					{
						Transform child = transform.GetChild(i);
						Button val2 = ((child != null) ? ((Component)child).GetComponent<Button>() : null);
						if ((Object)(object)val2 != (Object)null)
						{
							nativeTabSource = val2;
							break;
						}
					}
				}
				string[] array = new string[_tabDescs.Count];
				for (int j = 0; j < _tabDescs.Count; j++)
				{
					array[j] = _tabDescs[j].name;
				}
				_tabMenu = BuildNativeTabMenu(array, val, nativeTabSource, tmpl);
				_tabMenu.ManagedItemList = _submenuItemList;
				Selectable[] array2 = (Selectable[])(object)new Selectable[_fixedButtonInstances.Count];
				for (int k = 0; k < _fixedButtonInstances.Count; k++)
				{
					array2[k] = (Selectable)(object)_fixedButtonInstances[k];
				}
				_tabMenu.SetFixedMenuItems(array2);
				Toggle toggle = FindToggleTemplate(menu);
				Slider slider = FindSliderTemplate(menu);
				TabBuilder obj2 = new TabBuilder();
				_currentInjectedMenu = this;
				for (int l = 0; l < _tabDescs.Count; l++)
				{
					ConfigureTabPage(_tabMenu, l, tmpl, toggle, slider);
					_tabDescs[l].configure?.Invoke(obj2);
				}
				_currentInjectedMenu = null;
				BuildKeyboard(menu, tmpl);
				_tabMenu.SetActiveTab(0);
				_contentBuilt = true;
			}

			private GameObject BuildMainButton(Menu menu, Button tmpl)
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: 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)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = Object.Instantiate<GameObject>(((Component)tmpl).gameObject, ((Component)tmpl).transform.parent);
				((Object)val).name = "BBSMP_MainMenuButton";
				StripLocalizationComponents(val);
				val.transform.SetSiblingIndex(((Component)tmpl).transform.GetSiblingIndex() + 1);
				RectTransform component = val.GetComponent<RectTransform>();
				RectTransform component2 = ((Component)tmpl).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
				{
					component.anchorMin = component2.anchorMin;
					component.anchorMax = component2.anchorMax;
					component.pivot = component2.pivot;
					component.sizeDelta = component2.sizeDelta;
					((Transform)component).localScale = Vector3.one;
					float num = Mathf.Max(45f, Mathf.Abs(component2.sizeDelta.y) + 10f);
					component.anchoredPosition = component2.anchoredPosition + new Vector2(0f, num);
				}
				_mainButton = val.GetComponent<Button>();
				ClearButtonEvents(_mainButton);
				Button mainButton = _mainButton;
				if (mainButton != null)
				{
					((UnityEvent)mainButton.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
					{
						SetSubmenuVisible(isVisible: true);
					}));
				}
				SetButtonLabel(val, _mainButtonLabel);
				return val;
			}

			private GameObject BuildSubmenu(Menu menu, Button tmpl)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected O, but got Unknown
				//IL_0042: 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_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Expected O, but got Unknown
				//IL_010c: 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_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0299: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("BBSMP_SubmenuCanvas");
				val.transform.SetParent(menu.mainMenuCanvas.transform, false);
				val.transform.SetAsLastSibling();
				RectTransform val2 = val.AddComponent<RectTransform>();
				val2.anchorMin = new Vector2(0f, 1f);
				val2.anchorMax = new Vector2(0f, 1f);
				val2.pivot = new Vector2(0f, 1f);
				val2.sizeDelta = new Vector2(860f, 650f);
				val2.anchoredPosition = new Vector2(10f, -10f);
				_submenuCG = val.AddComponent<CanvasGroup>();
				_submenuCG.alpha = 0f;
				_submenuCG.blocksRaycasts = false;
				_submenuCG.interactable = false;
				GameObject val3 = new GameObject("CustomSettingsContentRoot");
				val3.transform.SetParent(val.transform, false);
				RectTransform val4 = val3.AddComponent<RectTransform>();
				val4.anchorMin = new Vector2(0f, 1f);
				val4.anchorMax = new Vector2(0f, 1f);
				val4.pivot = new Vector2(0f, 1f);
				val4.sizeDelta = new Vector2(800f, 460f);
				val4.anchoredPosition = new Vector2(10f, -10f);
				RectTransform component = ((Component)tmpl).GetComponent<RectTransform>();
				float num = (((Object)(object)component != (Object)null) ? Mathf.Max(200f, component.sizeDelta.x) : 520f);
				float num2 = (((Object)(object)component != (Object)null) ? Mathf.Clamp(component.sizeDelta.y, 40f, 72f) : 52f);
				_fixedButtonInstances.Clear();
				for (int num3 = _fixedDescs.Count - 1; num3 >= 0; num3--)
				{
					(string label, UnityAction action) tuple = _fixedDescs[num3];
					string item = tuple.label;
					UnityAction item2 = tuple.action;
					GameObject val5 = Object.Instantiate<GameObject>(((Component)tmpl).gameObject, val.transform);
					((Object)val5).name = $"BBSMP_Fixed_{num3}";
					StripLocalizationComponents(val5);
					Button component2 = val5.GetComponent<Button>();
					ClearButtonEvents(component2);
					SetButtonLabel(val5, item);
					RectTransform component3 = val5.GetComponent<RectTransform>();
					component3.anchorMin = Vector2.zero;
					component3.anchorMax = Vector2.zero;
					component3.pivot = Vector2.zero;
					component3.sizeDelta = new Vector2(num, num2);
					int num4 = _fixedDescs.Count - 1 - num3;
					component3.anchoredPosition = new Vector2(10f, 10f + (float)num4 * (num2 + 10f));
					UnityAction capturedAction = item2;
					if (component2 != null)
					{
						((UnityEvent)component2.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
						{
							UnityAction obj = capturedAction;
							if (obj != null)
							{
								obj.Invoke();
							}
							SetSubmenuVisible(isVisible: false);
						}));
					}
					_fixedButtonInstances.Insert(0, component2);
				}
				_submenuItemList = val.AddComponent<MenuItemList>();
				_submenuItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit((GameObject[])(object)new GameObject[0]);
				_submenuRect = val2;
				ApplyMargin();
				return val;
			}

			private void BuildKeyboard(Menu menu, Button tmpl, bool useLowercaseFontForLetterKeys = true)
			{
				//IL_037c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0386: Expected O, but got Unknown
				//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_040e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0425: Unknown result type (might be due to invalid IL or missing references)
				//IL_0453: Unknown result type (might be due to invalid IL or missing references)
				//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0610: Unknown result type (might be due to invalid IL or missing references)
				//IL_0627: Unknown result type (might be due to invalid IL or missing references)
				//IL_063b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0659: Unknown result type (might be due to invalid IL or missing references)
				//IL_0879: Unknown result type (might be due to invalid IL or missing references)
				//IL_0890: Unknown result type (might be due to invalid IL or missing references)
				//IL_08a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_08be: Unknown result type (might be due to invalid IL or missing references)
				//IL_08cf: Unknown result type (might be due to invalid IL or missing references)
				if (_kbBuilt || (Object)(object)((menu != null) ? menu.mainMenuCanvas : null) == (Object)null || (Object)(object)tmpl == (Object)null)
				{
					return;
				}
				_kbUseLowercaseFontForKeyLabels = useLowercaseFontForLetterKeys;
				_kbLowerRows = new string[4][]
				{
					new string[11]
					{
						"1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
						"."
					},
					new string[10] { "q", "w", "e", "r", "t", "y", "u", "i", "o", "p" },
					new string[9] { "a", "s", "d", "f", "g", "h", "j", "k", "l" },
					new string[7] { "z", "x", "c", "v", "b", "n", "m" }
				};
				_kbUpperRows = new string[4][]
				{
					new string[11]
					{
						"1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
						"."
					},
					new string[10] { "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P" },
					new string[9] { "A", "S", "D", "F", "G", "H", "J", "K", "L" },
					new string[7] { "Z", "X", "C", "V", "B", "N", "M" }
				};
				int num = _kbLowerRows.Length + 1;
				float num2 = 20f + (float)num * 44f + (float)(num - 1) * 4f - 15f;
				float num3 = 780f;
				int num4 = 0;
				for (int i = 0; i < _kbLowerRows.Length; i++)
				{
					if (_kbLowerRows[i].Length > num4)
					{
						num4 = _kbLowerRows[i].Length;
					}
				}
				float num5 = (num3 - (float)(num4 - 1) * 6f) / (float)num4;
				_kbRoot = new GameObject("BBSMP_Keyboard");
				_kbRoot.transform.SetParent(menu.mainMenuCanvas.transform, false);
				_kbRoot.transform.SetAsLastSibling();
				RectTransform val = _kbRoot.AddComponent<RectTransform>();
				val.anchorMin = new Vector2(0.5f, 0f);
				val.anchorMax = new Vector2(0.5f, 0f);
				val.pivot = new Vector2(0.5f, 0f);
				val.sizeDelta = new Vector2(800f, num2);
				val.anchoredPosition = new Vector2(0f, 100f);
				Image val2 = _kbRoot.AddComponent<Image>();
				((Graphic)val2).color = new Color(0.05f, 0.11f, 0.18f, 0.97f);
				_kbCG = _kbRoot.AddComponent<CanvasGroup>();
				_kbCG.alpha = 0f;
				_kbCG.interactable = false;
				_kbCG.blocksRaycasts = false;
				_kbCharRows = new Button[_kbLowerRows.Length][];
				float num6 = -10f;
				for (int j = 0; j < _kbLowerRows.Length; j++)
				{
					int num7 = _kbLowerRows[j].Length;
					float num8 = num5;
					float num9 = (float)num7 * num8 + (float)(num7 - 1) * 6f;
					float num10 = (0f - num9) * 0.5f;
					_kbCharRows[j] = (Button[])(object)new Button[num7];
					for (int k = 0; k < num7; k++)
					{
						int capturedRow = j;
						int capturedCol = k;
						GameObject val3 = Object.Instantiate<GameObject>(((Component)tmpl).gameObject, _kbRoot.transform);
						((Object)val3).name = "BBSMP_Key_" + _kbUpperRows[j][k];
						StripLocalizationComponents(val3);
						Button component = val3.GetComponent<Button>();
						ClearButtonEvents(component);
						if ((Object)(object)component != (Object)null)
						{
							((UnityEvent)component.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
							{
								KbType(capturedRow, capturedCol);
							}));
						}
						SetButtonLabel(val3, _kbLowerRows[j][k], _kbUseLowercaseFontForKeyLabels);
						TMP_Text componentInChildren = val3.GetComponentInChildren<TMP_Text>(true);
						if ((Object)(object)componentInChildren != (Object)null)
						{
							componentInChildren.fontSize = 20f;
						}
						RectTransform component2 = val3.GetComponent<RectTransform>();
						component2.anchorMin = new Vector2(0.5f, 1f);
						component2.anchorMax = new Vector2(0.5f, 1f);
						component2.pivot = new Vector2(0f, 1f);
						component2.sizeDelta = new Vector2(num8, 44f);
						component2.anchoredPosition = new Vector2(num10 + (float)k * (num8 + 6f), num6);
						_kbCharRows[j][k] = component;
						_kbAllButtons.Add(val3);
					}
					num6 -= 48f;
				}
				float num11 = num3 - 216f - 18f;
				float[] obj = new float[4] { 72f, 0f, 72f, 72f };
				obj[1] = num11;
				float[] array = obj;
				string[] array2 = new string[4] { "Shift", "Space", "Back", "Done" };
				_kbSpecialRow = (Button[])(object)new Button[4];
				float num12 = (0f - num3) * 0.5f;
				for (int l = 0; l < 4; l++)
				{
					GameObject val4 = Object.Instantiate<GameObject>(((Component)tmpl).gameObject, _kbRoot.transform);
					((Object)val4).name = "BBSMP_Key_" + array2[l];
					StripLocalizationComponentsImmediate(val4);
					Button component3 = val4.GetComponent<Button>();
					ClearButtonEvents(component3);
					if ((Object)(object)component3 != (Object)null)
					{
						switch (l)
						{
						case 0:
							((UnityEvent)component3.onClick).AddListener(UnityAction.op_Implicit((Action)KbToggleShift));
							_kbShiftBtn = component3;
							break;
						case 1:
							((UnityEvent)component3.onClick).AddListener(UnityAction.op_Implicit((Action)KbSpace));
							break;
						case 2:
							((UnityEvent)component3.onClick).AddListener(UnityAction.op_Implicit((Action)KbBackspace));
							break;
						case 3:
							((UnityEvent)component3.onClick).AddListener(UnityAction.op_Implicit((Action)KbDone));
							break;
						}
					}
					SetButtonLabel(val4, array2[l]);
					TMP_Text componentInChildren2 = val4.GetComponentInChildren<TMP_Text>(true);
					if ((Object)(object)componentInChildren2 != (Object)null)
					{
						componentInChildren2.fontSize = 20f;
					}
					RectTransform component4 = val4.GetComponent<RectTransform>();
					component4.anchorMin = new Vector2(0.5f, 1f);
					component4.anchorMax = new Vector2(0.5f, 1f);
					component4.pivot = new Vector2(0f, 1f);
					component4.sizeDelta = new Vector2(array[l], 44f);
					component4.anchoredPosition = new Vector2(num12, num6);
					num12 += array[l] + 6f;
					_kbSpecialRow[l] = component3;
					_kbAllButtons.Add(val4);
				}
				WireKeyboardNavigation();
				ForceKeyboardFontSizes();
				MelonCoroutines.Start(EnforceKeyboardFontSizesCoroutine());
				_kbBuilt = true;
			}

			private void WireKeyboardNavigation()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Expected O, but got Unknown
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Expected O, but got Unknown
				for (int i = 0; i < _kbCharRows.Length; i++)
				{
					int num = _kbCharRows[i].Length;
					for (int j = 0; j < num; j++)
					{
						Navigation val = new Navigation
						{
							mode = (Mode)0
						};
						val.selectOnLeft = (Selectable)(object)((j > 0) ? _kbCharRows[i][j - 1] : null);
						val.selectOnRight = (Selectable)(object)((j < num - 1) ? _kbCharRows[i][j + 1] : null);
						val.selectOnUp = (Selectable)(object)((i > 0) ? _kbCharRows[i - 1][Mathf.Min(j, _kbCharRows[i - 1].Length - 1)] : null);
						if (i < _kbCharRows.Length - 1)
						{
							val.selectOnDown = (Selectable)(object)_kbCharRows[i + 1][Mathf.Min(j, _kbCharRows[i + 1].Length - 1)];
						}
						else
						{
							int num2 = Mathf.Clamp(j * _kbSpecialRow.Length / _kbCharRows[i].Length, 0, _kbSpecialRow.Length - 1);
							val.selectOnDown = (Selectable)(object)_kbSpecialRow[num2];
						}
						((Selectable)_kbCharRows[i][j]).navigation = val;
					}
				}
				int num3 = _kbCharRows.Length - 1;
				int num4 = _kbCharRows[num3].Length;
				for (int k = 0; k < _kbSpecialRow.Length; k++)
				{
					Navigation val2 = new Navigation
					{
						mode = (Mode)0
					};
					val2.selectOnLeft = (Selectable)(object)((k > 0) ? _kbSpecialRow[k - 1] : null);
					val2.selectOnRight = (Selectable)(object)((k < _kbSpecialRow.Length - 1) ? _kbSpecialRow[k + 1] : null);
					val2.selectOnDown = null;
					int num5 = Mathf.Clamp(k * num4 / _kbSpecialRow.Length, 0, num4 - 1);
					val2.selectOnUp = (Selectable)(object)_kbCharRows[num3][num5];
					((Selectable)_kbSpecialRow[k]).navigation = val2;
				}
			}

			private void KbType(int row, int col)
			{
				if (_kbActiveField != null)
				{
					string[][] array = (_kbShift ? _kbUpperRows : _kbLowerRows);
					_kbActiveField.Value += array[row][col];
					_kbHasEdited = true;
					KbRefreshDisplay();
					_kbActiveField.OnChanged?.Invoke(_kbActiveField.Value);
					if (_kbShift)
					{
						_kbShift = false;
						KbRefreshKeyLabels();
					}
				}
			}

			private void KbSpace()
			{
				if (_kbActiveField != null)
				{
					_kbActiveField.Value += " ";
					_kbHasEdited = true;
					KbRefreshDisplay();
					_kbActiveField.OnChanged?.Invoke(_kbActiveField.Value);
				}
			}

			private void KbBackspace()
			{
				if (_kbActiveField != null && _kbActiveField.Value.Length != 0)
				{
					_kbActiveField.Value = _kbActiveField.Value.Substring(0, _kbActiveField.Value.Length - 1);
					_kbHasEdited = true;
					KbRefreshDisplay();
					_kbActiveField.OnChanged?.Invoke(_kbActiveField.Value);
				}
			}

			private void KbToggleShift()
			{
				_kbShift = !_kbShift;
				KbRefreshKeyLabels();
			}

			private void KbRefreshKeyLabels()
			{
				if (_kbCharRows == null)
				{
					return;
				}
				string[][] array = (_kbShift ? _kbUpperRows : _kbLowerRows);
				for (int i = 0; i < _kbCharRows.Length; i++)
				{
					for (int j = 0; j < _kbCharRows[i].Length; j++)
					{
						SetButtonLabel(((Component)_kbCharRows[i][j]).gameObject, array[i][j], _kbUseLowercaseFontForKeyLabels);
					}
				}
				if ((Object)(object)_kbShiftBtn != (Object)null)
				{
					SetButtonLabel(((Component)_kbShiftBtn).gameObject, _kbShift ? "SHIFT" : "Shift");
					ForceKeyboardFontSize(((Component)_kbShiftBtn).gameObject);
				}
			}

			private void ForceKeyboardFontSizes()
			{
				if (_kbAllButtons.Count != 0)
				{
					for (int i = 0; i < _kbAllButtons.Count; i++)
					{
						ForceKeyboardFontSize(_kbAllButtons[i]);
					}
				}
			}

			private static void ForceKeyboardFontSize(GameObject keyObj)
			{
				if (!((Object)(object)keyObj == (Object)null))
				{
					TMP_Text componentInChildren = keyObj.GetComponentInChildren<TMP_Text>(true);
					if (!((Object)(object)componentInChildren == (Object)null))
					{
						componentInChildren.fontSize = 20f;
						componentInChildren.ForceMeshUpdate(false, false);
					}
				}
			}

			[IteratorStateMachine(typeof(<EnforceKeyboardFontSizesCoroutine>d__73))]
			private IEnumerator EnforceKeyboardFontSizesCoroutine()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <EnforceKeyboardFontSizesCoroutine>d__73(0)
				{
					<>4__this = this
				};
			}

			private void KbRefreshDisplay()
			{
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				InputFieldInfo kbActiveField = _kbActiveField;
				if (kbActiveField != null && !((Object)(object)kbActiveField.DisplayText == (Object)null))
				{
					TMP_Text displayText = kbActiveField.DisplayText;
					_kbCursorVisible = true;
					_kbCursorTimer = 0f;
					ApplyCaretText(kbActiveField, _kbCursorVisible, _kbHasEdited);
					displayText.ForceMeshUpdate(false, false);
					float num = 0f;
					RectTransform rectTransform = displayText.rectTransform;
					if ((Object)(object)rectTransform != (Object)null && (Object)(object)kbActiveField.Viewport != (Object)null)
					{
						Rect rect = kbActiveField.Viewport.rect;
						float width = ((Rect)(ref rect)).width;
						float displayWidthForRenderedText = GetDisplayWidthForRenderedText(displayText, displayText.text);
						num = ((width > 1f) ? Mathf.Max(0f, displayWidthForRenderedText - width) : 0f);
						rectTransform.offsetMin = new Vector2(0f - num, rectTransform.offsetMin.y);
						rectTransform.offsetMax = new Vector2(0f - num, rectTransform.offsetMax.y);
					}
					if ((Object)(object)kbActiveField.CursorImage != (Object)null)
					{
						((Graphic)kbActiveField.CursorImage).color = Color.clear;
					}
				}
			}

			private void KbBlinkCursor()
			{
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: 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)
				InputFieldInfo kbActiveField = _kbActiveField;
				if (!((Object)(object)kbActiveField?.DisplayText == (Object)null))
				{
					TMP_Text displayText = kbActiveField.DisplayText;
					ApplyCaretText(kbActiveField, _kbCursorVisible, _kbHasEdited);
					displayText.ForceMeshUpdate(false, false);
					RectTransform rectTransform = displayText.rectTransform;
					if ((Object)(object)rectTransform != (Object)null && (Object)(object)kbActiveField.Viewport != (Object)null)
					{
						Rect rect = kbActiveField.Viewport.rect;
						float width = ((Rect)(ref rect)).width;
						float displayWidthForRenderedText = GetDisplayWidthForRenderedText(displayText, displayText.text);
						float num = ((width > 1f) ? Mathf.Max(0f, displayWidthForRenderedText - width) : 0f);
						rectTransform.offsetMin = new Vector2(0f - num, rectTransform.offsetMin.y);
						rectTransform.offsetMax = new Vector2(0f - num, rectTransform.offsetMax.y);
					}
				}
			}

			internal void OpenKeyboard(InputFieldInfo info, Button returnButton)
			{
				OpenKeyboard(info, returnButton, null, useOverlay: false);
			}

			internal void OpenKeyboard(InputFieldInfo info, Button returnButton, Action onDone)
			{
				OpenKeyboard(info, returnButton, onDone, useOverlay: false);
			}

			internal void OpenKeyboardForChat(InputFieldInfo info, Action onDone)
			{
				OpenKeyboard(info, null, onDone, useOverlay: true);
			}

			private void OpenKeyboard(InputFieldInfo info, Button returnButton, Action onDone, bool useOverlay)
			{
				if (_kbBuilt)
				{
					_kbActiveField = info;
					_kbReturnButton = returnButton;
					_kbOnDone = onDone;
					_kbUsingOverlay = useOverlay;
					_kbShift = false;
					_kbHasEdited = false;
					_kbCursorVisible = true;
					_kbCursorTimer = 0f;
					if (useOverlay && (Object)(object)_kbRoot != (Object)null)
					{
						RectTransform val = EnsureKeyboardOverlayRoot();
						_kbRoot.transform.SetParent((Transform)(object)val, false);
						_kbRoot.transform.SetAsLastSibling();
						ShowKeyboardOverlay();
					}
					KbRefreshKeyLabels();
					KbRefreshDisplay();
					SetKeyboardVisible(visible: true);
				}
			}

			internal void CloseKeyboardForChat()
			{
				CloseKeyboard();
			}

			internal void CloseKeyboardOverlay()
			{
				CloseKeyboardOverlay(dismissChatTab: false);
			}

			internal void CloseKeyboardOverlay(bool dismissChatTab)
			{
				CloseKeyboard();
				HideKeyboardOverlay();
				if (dismissChatTab)
				{
					Core.uiManager.showChatTab = false;
				}
			}

			private void CloseKeyboard()
			{
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: 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_010d: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_kbActiveField?.DisplayText != (Object)null)
				{
					TMP_Text displayText = _kbActiveField.DisplayText;
					if (_kbActiveField.Value.Length > 0)
					{
						displayText.text = _kbActiveField.Value;
						((Graphic)displayText).color = _kbActiveField.ActiveColor;
					}
					else
					{
						displayText.text = _kbActiveField.Placeholder;
						((Graphic)displayText).color = _kbActiveField.PlaceholderColor;
					}
					displayText.ForceMeshUpdate(false, false);
					RectTransform rectTransform = displayText.rectTransform;
					if ((Object)(object)rectTransform != (Object)null)
					{
						rectTransform.offsetMin = new Vector2(0f, rectTransform.offsetMin.y);
						rectTransform.offsetMax = new Vector2(0f, rectTransform.offsetMax.y);
					}
					if ((Object)(object)_kbActiveField.CursorImage != (Object)null)
					{
						((Graphic)_kbActiveField.CursorImage).color = Color.clear;
					}
				}
				SetKeyboardVisible(visible: false);
				_tabMenu?.SetActiveTab(_tabMenu.ActiveTab);
				Button kbReturnButton = _kbReturnButton;
				_kbActiveField = null;
				_kbReturnButton = null;
				_kbOnDone = null;
				if ((Object)(object)kbReturnButton != (Object)null)
				{
					EventSystem current = EventSystem.current;
					if (current != null)
					{
						current.SetSelectedGameObject(((Component)kbReturnButton).gameObject);
					}
				}
			}

			private void KbDone()
			{
				_kbOnDone?.Invoke();
				CloseKeyboard();
			}

			internal void OnInputFieldButtonClick(InputFieldInfo info, Button btn)
			{
				if (!IsMouseTyping)
				{
					if (Input.GetMouseButtonUp(0))
					{
						OpenMouseTyping(info);
					}
					else
					{
						OpenKeyboard(info, btn);
					}
				}
			}

			internal void OpenMouseTyping(InputFieldInfo info)
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				_mouseTypingField = info;
				_mouseTypingActive = true;
				_mouseTypingNavFrame = -1;
				_mouseCursorBlinkFrame = -1;
				_mouseHasEdited = false;
				_mouseCursorTimer = 0f;
				_mouseCursorVisible = true;
				if ((Object)(object)info?.CursorImage != (Object)null)
				{
					((Graphic)info.CursorImage).color = Color.clear;
				}
				EventSystem current = EventSystem.current;
				if (current != null)
				{
					current.SetSelectedGameObject((GameObject)null);
				}
				RefreshMouseTypingDisplay();
			}

			private void CloseMouseTyping(bool restoreSelection = true)
			{
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				_mouseTypingActive = false;
				InputFieldInfo mouseTypingField = _mouseTypingField;
				_mouseTypingField = null;
				if (restoreSelection && (Object)(object)mouseTypingField?.OwnerButton != (Object)null)
				{
					EventSystem current = EventSystem.current;
					if (current != null)
					{
						current.SetSelectedGameObject(((Component)mouseTypingField.OwnerButton).gameObject);
					}
				}
				if ((Object)(object)mouseTypingField.CursorImage != (Object)null)
				{
					((Graphic)mouseTypingField.CursorImage).color = Color.clear;
				}
				if (!((Object)(object)mouseTypingField?.DisplayText == (Object)null))
				{
					TMP_Text displayText = mouseTypingField.DisplayText;
					if (mouseTypingField.Value.Length > 0)
					{
						displayText.text = mouseTypingField.Value;
						((Graphic)displayText).color = mouseTypingField.ActiveColor;
					}
					else
					{
						displayText.text = mouseTypingField.Placeholder;
						((Graphic)displayText).color = mouseTypingField.PlaceholderColor;
					}
					displayText.ForceMeshUpdate(false, false);
					RectTransform rectTransform = displayText.rectTransform;
					if ((Object)(object)rectTransform != (Object)null)
					{
						rectTransform.offsetMin = new Vector2(0f, rectTransform.offsetMin.y);
						rectTransform.offsetMax = new Vector2(0f, rectTransform.offsetMax.y);
					}
				}
			}

			private void RefreshMouseTypingDisplay()
			{
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: 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)
				InputFieldInfo mouseTypingField = _mouseTypingField;
				if (!((Object)(object)mouseTypingField?.DisplayText == (Object)null))
				{
					TMP_Text displayText = mouseTypingField.DisplayText;
					ApplyCaretText(mouseTypingField, _mouseCursorVisible, _mouseHasEdited);
					displayText.ForceMeshUpdate(false, false);
					float num = 0f;
					RectTransform rectTransform = displayText.rectTransform;
					if ((Object)(object)rectTransform != (Object)null && (Object)(object)mouseTypingField.Viewport != (Object)null)
					{
						Rect rect = mouseTypingField.Viewport.rect;
						float width = ((Rect)(ref rect)).width;
						float displayWidthForRenderedText = GetDisplayWidthForRenderedText(displayText, displayText.text);
						num = ((width > 1f) ? Mathf.Max(0f, displayWidthForRenderedText - width) : 0f);
						rectTransform.offsetMin = new Vector2(0f - num, rectTransform.offsetMin.y);
						rectTransform.offsetMax = new Vector2(0f - num, rectTransform.offsetMax.y);
					}
					if ((Object)(object)mouseTypingField.CursorImage != (Object)null)
					{
						((Graphic)mouseTypingField.CursorImage).color = Color.clear;
					}
				}
			}

			private static void ApplyCaretText(InputFieldInfo field, bool showCaret, bool hasEdited)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)field?.DisplayText == (Object)null))
				{
					bool flag = !string.IsNullOrEmpty(field.Value);
					((Graphic)field.DisplayText).color = (flag ? field.ActiveColor : field.PlaceholderColor);
					if (!flag)
					{
						field.DisplayText.text = (showCaret ? "|" : "<color=#FFFFFF00>|</color>");
					}
					else if (!hasEdited)
					{
						field.DisplayText.text = (showCaret ? (field.Value + "|") : (field.Value + "<color=#FFFFFF00>|</color>"));
					}
					else
					{
						field.DisplayText.text = (showCaret ? (field.Value + "|") : (field.Value + "<color=#FFFFFF00>|</color>"));
					}
				}
			}

			private static float GetDisplayWidthForRenderedText(TMP_Text text, string renderedText)
			{
				//IL_0034: 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)
				if ((Object)(object)text == (Object)null)
				{
					return 0f;
				}
				if (string.IsNullOrEmpty(renderedText))
				{
					return 0f;
				}
				float x = text.GetPreferredValues(renderedText + "M").x;
				float x2 = text.GetPreferredValues("M").x;
				return Mathf.Max(0f, x - x2);
			}

			private static bool IsPointerOverGameObject(GameObject target)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_003e: Expected O, but got Unknown
				EventSystem current = EventSystem.current;
				if ((Object)(object)current == (Object)null || (Object)(object)target == (Object)null)
				{
					return false;
				}
				PointerEventData val = new PointerEventData(current)
				{
					position = Vector2.op_Implicit(Input.mousePosition)
				};
				List<RaycastResult> val2 = new List<RaycastResult>();
				current.RaycastAll(val, val2);
				for (int i = 0; i < val2.Count; i++)
				{
					GameObject gameObject = val2[i].gameObject;
					if (!((Object)(object)gameObject == (Object)null) && ((Object)(object)gameObject == (Object)(object)target || gameObject.transform.IsChildOf(target.transform)))
					{
						return true;
					}
				}
				return false;
			}

			private void SetKeyboardVisible(bool visible)
			{
				if ((Object)(object)_kbCG == (Object)null)
				{
					return;
				}
				_kbCG.alpha = (visible ? 1f : 0f);
				_kbCG.interactable = visible;
				_kbCG.blocksRaycasts = visible;
				if (visible && _kbCharRows != null && _kbCharRows.Length != 0)
				{
					Button val = _kbCharRows[0][0];
					if ((Object)(object)_submenuItemList != (Object)null)
					{
						_submenuItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit((GameObject[])(object)new GameObject[1] { ((Component)val).gameObject });
					}
					EventSystem current = EventSystem.current;
					if (current != null)
					{
						current.SetSelectedGameObject(((Component)val).gameObject);
					}
					MenuItemList.active = _submenuItemList;
				}
			}

			private void IntegrateIntoMainItemList()
			{
				if ((Object)(object)_mainMenuItemList == (Object)null || (Object)(object)_mainButtonObj == (Object)null)
				{
					return;
				}
				Il2CppReferenceArray<GameObject> items = _mainMenuItemList.items;
				if (items == null || ((Il2CppArrayBase<GameObject>)(object)items).Length == 0)
				{
					return;
				}
				for (int i = 0; i < ((Il2CppArrayBase<GameObject>)(object)items).Length; i++)
				{
					if ((Object)(object)((Il2CppArrayBase<GameObject>)(object)items)[i] == (Object)(object)_mainButtonObj)
					{
						return;
					}
				}
				Menu activeMenu = _activeMenu;
				Button val = ((activeMenu != null) ? activeMenu.ContinueGameButton : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				int num = -1;
				for (int j = 0; j < ((Il2CppArrayBase<GameObject>)(object)items).Length; j++)
				{
					if ((Object)(object)((Il2CppArrayBase<GameObject>)(object)items)[j] == (Object)(object)((Component)val).gameObject)
					{
						num = j;
						break;
					}
				}
				if (num < 0)
				{
					return;
				}
				GameObject[] array = (GameObject[])(object)new GameObject[((Il2CppArrayBase<GameObject>)(object)items).Length + 1];
				int k = 0;
				int num2 = 0;
				for (; k < array.Length; k++)
				{
					if (k == num + 1)
					{
						array[k] = _mainButtonObj;
					}
					else
					{
						array[k] = ((Il2CppArrayBase<GameObject>)(object)items)[num2++];
					}
				}
				_mainMenuItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit(array);
			}

			private void UpdateVisibility(Menu menu)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Invalid comparison between Unknown and I4
				if ((Object)(object)menu == (Object)null)
				{
					return;
				}
				bool flag = (Object)(object)menu.mainMenuCanvas != (Object)null && menu.mainMenuCanvas.activeInHierarchy && (int)menu.currentMenuScreen == 0;
				if ((Object)(object)_mainButtonObj != (Object)null)
				{
					_mainButtonObj.SetActive(flag);
				}
				if (!flag)
				{
					if (GetSubmenuVisible())
					{
						SetSubmenuVisible(isVisible: false);
					}
					return;
				}
				bool submenuVisible = GetSubmenuVisible();
				if ((Object)(object)_mainMenuCG != (Object)null)
				{
					_mainMenuCG.alpha = (submenuVisible ? 0f : 1f);
					_mainMenuCG.blocksRaycasts = !submenuVisible;
					_mainMenuCG.interactable = !submenuVisible;
				}
				if ((Object)(object)menu.titleGroup != (Object)null)
				{
					menu.titleGroup.alpha = (submenuVisible ? 0f : 1f);
				}
			}

			private void SetSubmenuVisible(bool isVisible)
			{
				if ((Object)(object)_submenuCG == (Object)null)
				{
					return;
				}
				bool flag = _submenuCG.alpha > 0.5f;
				if (flag == isVisible)
				{
					return;
				}
				if (!isVisible && KbVisible)
				{
					SetKeyboardVisible(visible: false);
				}
				_submenuCG.alpha = (isVisible ? 1f : 0f);
				_submenuCG.blocksRaycasts = isVisible;
				_submenuCG.interactable = isVisible;
				for (int i = 0; i < _fixedButtonInstances.Count; i++)
				{
					if ((Object)(object)_fixedButtonInstances[i] != (Object)null)
					{
						((Selectable)_fixedButtonInstances[i]).interactable = isVisible;
					}
				}
				if ((Object)(object)_mainButton != (Object)null)
				{
					((Selectable)_mainButton).interactable = !isVisible;
				}
				if (isVisible)
				{
					ApplyMargin();
					_tabMenu?.OnShown();
					if ((Object)(object)_submenuItemList != (Object)null)
					{
						MenuItemList.active = _submenuItemList;
					}
				}
				else if ((Object)(object)_mainMenuItemList != (Object)null)
				{
					MenuItemList.active = _mainMenuItemList;
				}
				EventSystem current = EventSystem.current;
				if ((Object)(object)current != (Object)null)
				{
					if (isVisible && _fixedButtonInstances.Count > 0 && (Object)(object)_fixedButtonInstances[0] != (Object)null)
					{
						current.SetSelectedGameObject(((Component)_fixedButtonInstances[0]).gameObject);
					}
					else if (!isVisible && (Object)(object)_mainButton != (Object)null)
					{
						current.SetSelectedGameObject(((Component)_mainButton).gameObject);
					}
				}
				UpdateVisibility(_activeMenu);
			}

			private void EnsureSelection()
			{
				if (KbVisible || _mouseTypingActive)
				{
					return;
				}
				EventSystem current = EventSystem.current;
				if ((Object)(object)current == (Object)null)
				{
					return;
				}
				GameObject currentSelectedGameObject = current.currentSelectedGameObject;
				if (!((Object)(object)currentSelectedGameObject == (Object)null) && currentSelectedGameObject.activeInHierarchy)
				{
					Selectable component = currentSelectedGameObject.GetComponent<Selectable>();
					if (component == null || component.interactable)
					{
						return;
					}
				}
				if (GetSubmenuVisible())
				{
					if (_fixedButtonInstances.Count > 0 && (Object)(object)_fixedButtonInstances[0] != (Object)null)
					{
						current.SetSelectedGameObject(((Component)_fixedButtonInstances[0]).gameObject);
					}
					return;
				}
				Menu activeMenu = _activeMenu;
				if ((Object)(object)((activeMenu != null) ? activeMenu.ContinueGameButton : null) != (Object)null)
				{
					current.SetSelectedGameObject(((Component)_activeMenu.ContinueGameButton).gameObject);
				}
			}

			private void TryHandleCancel(Menu menu)
			{
				if (((menu != null) ? menu.rwPlayer : null) != null && !KbVisible && !_mouseTypingActive && (Input.GetKeyDown((KeyCode)27) || menu.rwPlayer.GetButtonDown(15)))
				{
					SetSubmenuVisible(isVisible: false);
				}
			}

			private void ApplyMargin()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_submenuRect != (Object)null)
				{
					_submenuRect.anchoredPosition = new Vector2(10f + _sideMargin, -10f - _topMargin);
				}
			}

			private bool GetSubmenuVisible()
			{
				return (Object)(object)_submenuCG != (Object)null && _submenuCG.alpha > 0.5f;
			}

			private void ResolveExisting(Menu menu)
			{
				if ((Object)(object)((menu != null) ? menu.mainMenuCanvas : null) == (Object)null)
				{
					return;
				}
				Il2CppArrayBase<Transform> componentsInChildren = menu.mainMenuCanvas.GetComponentsInChildren<Transform>(true);
				List<GameObject> list = new List<GameObject>();
				List<GameObject> list2 = new List<GameObject>();
				List<GameObject> list3 = new List<GameObject>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Transform val = componentsInChildren[i];
					if (!((Object)(object)val == (Object)null))
					{
						if (((Object)val).name == "BBSMP_MainMenuButton")
						{
							list.Add(((Component)val).gameObject);
						}
						else if (((Object)val).name == "BBSMP_SubmenuCanvas")
						{
							list2.Add(((Component)val).gameObject);
						}
						else if (((Object)val).name == "BBSMP_Keyboard")
						{
							list3.Add(((Component)val).gameObject);
						}
					}
				}
				if (list3.Count > 0)
				{
					if (_kbBuilt)
					{
						_kbRoot = list3[0];
						GameObject kbRoot = _kbRoot;
						_kbCG = ((kbRoot != null) ? kbRoot.GetComponent<CanvasGroup>() : null);
					}
					else
					{
						for (int j = 0; j < list3.Count; j++)
						{
							Object.Destroy((Object)(object)list3[j]);
						}
						_kbRoot = null;
						_kbCG = null;
					}
					for (int k = 1; k < list3.Count; k++)
					{
						Object.Destroy((Object)(object)list3[k]);
					}
				}
				if (list.Count > 0)
				{
					_mainButtonObj = list[0];
					_mainButton = _mainButtonObj.GetComponent<Button>();
					for (int l = 1; l < list.Count; l++)
					{
						Object.Destroy((Object)(object)list[l]);
					}
					_mainMenuRoot = _mainButtonObj.transform.parent;
					Transform mainMenuRoot = _mainMenuRoot;
					object obj = ((mainMenuRoot != null) ? ((Component)mainMenuRoot).GetComponent<CanvasGroup>() : null);
					if (obj == null)
					{
						Transform mainMenuRoot2 = _mainMenuRoot;
						obj = ((mainMenuRoot2 != null) ? ((Component)mainMenuRoot2).gameObject.AddComponent<CanvasGroup>() : null);
					}
					_mainMenuCG = (CanvasGroup)obj;
					Transform mainMenuRoot3 = _mainMenuRoot;
					_mainMenuItemList = ((mainMenuRoot3 != null) ? ((Component)mainMenuRoot3).GetComponent<MenuItemList>() : null);
				}
				if (list2.Count > 0)
				{
					_submenuObj = list2[0];
					_submenuCG = _submenuObj.GetComponent<CanvasGroup>();
					_submenuItemList = _submenuObj.GetComponent<MenuItemList>();
					for (int m = 1; m < list2.Count; m++)
					{
						Object.Destroy((Object)(object)list2[m]);
					}
					_fixedButtonInstances.Clear();
					for (int n = 0; n < _fixedDescs.Count; n++)
					{
						Transform val2 = _submenuObj.transform.Find($"BBSMP_Fixed_{n}");
						_fixedButtonInstances.Add((val2 != null) ? ((Component)val2).GetComponent<Button>() : null);
					}
				}
			}

			private void Reset()
			{
				if ((Object)(object)_mainButtonObj != (Object)null)
				{
					Object.Destroy((Object)(object)_mainButtonObj);
				}
				if ((Object)(object)_submenuObj != (Object)null)
				{
					Object.Destroy((Object)(object)_submenuObj);
				}
				if ((Object)(object)_kbRoot != (Object)null)
				{
					Object.Destroy((Object)(object)_kbRoot);
				}
				_mainButtonObj = null;
				_mainButton = null;
				_submenuObj = null;
				_submenuCG = null;
				_submenuItemList = null;
				_submenuRect = null;
				_mainMenuRoot = null;
				_mainMenuCG = null;
				_mainMenuItemList = null;
				_tabMenu = null;
				_contentBuilt = false;
				_fixedButtonInstances.Clear();
				_kbRoot = null;
				_kbCG = null;
				_kbCharRows = null;
				_kbSpecialRow = null;
				_kbLowerRows = null;
				_kbUpperRows = null;
				_kbAllButtons.Clear();
				_kbActiveField = null;
				_kbReturnButton = null;
				_kbBuilt = false;
				_kbShift = false;
				_kbShiftBtn = null;
				_kbNavFrame = -1;
				_kbCursorTimer = 0f;
				_kbCursorVisible = true;
			}

			private static Button FindTemplateButton(Menu menu)
			{
				if ((Object)(object)menu.ContinueGameButton != (Object)null)
				{
					return menu.ContinueGameButton;
				}
				if ((Object)(object)menu.mainMenuCanvas == (Object)null)
				{
					return null;
				}
				Il2CppArrayBase<Button> componentsInChildren = menu.mainMenuCanvas.GetComponentsInChildren<Button>(true);
				if (componentsInChildren == null || componentsInChildren.Length == 0)
				{
					return null;
				}
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if (!((Object)(object)componentsInChildren[i] == (Object)null))
					{
						TMP_Text componentInChildren = ((Component)componentsInChildren[i]).GetComponentInChildren<TMP_Text>(true);
						string text = ((componentInChildren != null) ? componentInChildren.text : null) ?? "";
						if (text.Contains("continue", StringComparison.OrdinalIgnoreCase))
						{
							return componentsInChildren[i];
						}
					}
				}
				return componentsInChildren[0];
			}

			private static Toggle FindToggleTemplate(Menu menu)
			{
				if ((Object)(object)((menu != null) ? menu.mainMenuCanvas : null) == (Object)null)
				{
					return null;
				}
				Il2CppArrayBase<Toggle> componentsInChildren = menu.mainMenuCanvas.GetComponentsInChildren<Toggle>(true);
				if (componentsInChildren == null || componentsInChildren.Length == 0)
				{
					return null;
				}
				Toggle val = componentsInChildren[0];
				if ((Object)(object)val != (Object)null)
				{
					StripLocalizationComponentsImmediate(((Component)val).gameObject);
				}
				return val;
			}

			private static Slider FindSliderTemplate(Menu menu)
			{
				if ((Object)(object)((menu != null) ? menu.mainMenuCanvas : null) == (Object)null)
				{
					return null;
				}
				Il2CppArrayBase<Slider> componentsInChildren = menu.mainMenuCanvas.GetComponentsInChildren<Slider>(true);
				return (componentsInChildren != null && componentsInChildren.Length > 0) ? componentsInChildren[0] : null;
			}

			private static void DumpHierarchy(Menu menu, string reason)
			{
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if (!((Object)(object)menu == (Object)null))
					{
						StringBuilder stringBuilder = new StringBuilder();
						stringBuilder.AppendLine("=== BBSMP Menu Hierarchy Dump ===");
						StringBuilder stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder3 = stringBuilder2;
						StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(8, 1, stringBuilder2);
						handler.AppendLiteral("Reason: ");
						handler.AppendFormatted(reason);
						stringBuilder3.AppendLine(ref handler);
						stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder4 = stringBuilder2;
						handler = new StringBuilder.AppendInterpolatedStringHandler(6, 1, stringBuilder2);
						handler.AppendLiteral("Time: ");
						handler.AppendFormatted(DateTime.Now, "O");
						stringBuilder4.AppendLine(ref handler);
						stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder5 = stringBuilder2;
						handler = new StringBuilder.AppendInterpolatedStringHandler(18, 2, stringBuilder2);
						handler.AppendLiteral("Screen: ");
						handler.AppendFormatted<MenuScreen>(menu.currentMenuScreen);
						handler.AppendLiteral("  Paused: ");
						handler.AppendFormatted(menu.paused);
						stringBuilder5.AppendLine(ref handler);
						if ((Object)(object)menu.mainMenuCanvas != (Object)null)
						{
							stringBuilder2 = stringBuilder;
							StringBuilder stringBuilder6 = stringBuilder2;
							handler = new StringBuilder.AppendInterpolatedStringHandler(9, 1, stringBuilder2);
							handler.AppendLiteral("CanvasW: ");
							handler.AppendFormatted(GetPath(menu.mainMenuCanvas.transform));
							stringBuilder6.AppendLine(ref handler);
							AppendTransform(stringBuilder, menu.mainMenuCanvas.transform, 0, 6);
						}
						string text = Path.Combine(Environment.CurrentDirectory, "UserData");
						Directory.CreateDirectory(text);
						File.WriteAllText(Path.Combine(text, "BBSMP_MenuHierarchyDump.txt"), stringBuilder.ToString());
					}
				}
				catch (Exception value)
				{
					Instance logger = Core.logger;
					if (logger != null)
					{
						logger.Error($"[MenuInject] Dump failed: {value}");
					}
				}
			}

			private static void AppendTransform(StringBuilder sb, Transform root, int depth, int maxDepth)
			{
				if ((Object)(object)root == (Object)null || depth > maxDepth)
				{
					return;
				}
				string value = new string(' ', depth * 2);
				Il2CppArrayBase<Component> components = ((Component)root).GetComponents<Component>();
				List<string> list = new List<string>();
				for (int i = 0; i < components.Length; i++)
				{
					if ((Object)(object)components[i] != (Object)null)
					{
						list.Add(((object)components[i]).GetType().Name);
					}
				}
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(5, 3, sb);
				handler.AppendFormatted(value);
				handler.AppendLiteral("- ");
				handler.AppendFormatted(((Object)root).name);
				handler.AppendLiteral(" [");
				handler.AppendFormatted(string.Join(", ", list));
				handler.AppendLiteral("]");
				sb.AppendLine(ref handler);
				for (int j = 0; j < root.childCount; j++)
				{
					AppendTransform(sb, root.GetChild(j), depth + 1, maxDepth);
				}
			}

			private static string GetPath(Transform t)
			{
				if ((Object)(object)t == (Object)null)
				{
					return "<null>";
				}
				Stack<string> stack = new Stack<string>();
				while ((Object)(object)t != (Object)null)
				{
					stack.Push(((Object)t).name);
					t = t.parent;
				}
				return string.Join("/", stack);
			}
		}

		internal static readonly List<InjectedMenu> _registeredMenus = new List<InjectedMenu>();

		private static RectTransform customRoot;

		private static Button buttonTemplate;

		private static Toggle toggleTemplate;

		private static Slider sliderTemplate;

		private const float SliderHandleSize = 112f;

		private static Sprite _inputFieldSprite;

		private static Sprite _sliderHandleSprite;

		private static Sprite _solidSprite;

		private static TMP_FontAsset _lowercaseTextFont;

		private const float KeyboardKeyFontSize = 20f;

		private static RectTransform _keyboardOverlayRoot;

		private static CanvasGroup _keyboardOverlayCanvasGroup;

		private static RuntimeTabMenu _currentTabMenu;

		private static int _currentTabPage = -1;

		private static InjectedMenu _currentInjectedMenu;

		private static float nextY;

		private const float Spacing = 10f;

		private const float DefaultHeight = 52f;

		internal static readonly Color TabUnselected = new Color(0.435f, 0.676f, 0.726f, 1f);

		internal static readonly Color TabSelected = new Color(1f, 1f, 1f, 0.78f);

		internal static readonly Color TabText = new Color(0f, 0.169f, 0.283f, 1f);

		internal static readonly Color TabHighlighted = new Color(0.519f, 0.804f, 0.865f, 1f);

		internal static InjectedMenu CurrentMenu => _currentInjectedMenu;

		internal static InjectedMenu GetKeyboardMenu()
		{
			if (_registeredMenus.Count > 0)
			{
				return _registeredMenus[0];
			}
			return null;
		}

		private static RectTransform EnsureKeyboardOverlayRoot()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_keyboardOverlayRoot != (Object)null)
			{
				return _keyboardOverlayRoot;
			}
			Il2CppReferenceArray<Type> val = new Il2CppReferenceArray<Type>(5L);
			((Il2CppArrayBase<Type>)(object)val)[0] = Il2CppType.Of<RectTransform>();
			((Il2CppArrayBase<Type>)(object)val)[1] = Il2CppType.Of<Canvas>();
			((Il2CppArrayBase<Type>)(object)val)[2] = Il2CppType.Of<CanvasScaler>();
			((Il2CppArrayBase<Type>)(object)val)[3] = Il2CppType.Of<GraphicRaycaster>();
			((Il2CppArrayBase<Type>)(object)val)[4] = Il2CppType.Of<CanvasGroup>();
			GameObject val2 = new GameObject("BBSMP_ChatKeyboardOverlay", val);
			Object.DontDestroyOnLoad((Object)(object)val2);
			Canvas component = val2.GetComponent<Canvas>();
			component.renderMode = (RenderMode)0;
			component.overrideSorting = true;
			component.sortingOrder = 5000;
			_keyboardOverlayCanvasGroup = val2.GetComponent<CanvasGroup>();
			_keyboardOverlayCanvasGroup.alpha = 1f;
			_keyboardOverlayCanvasGroup.blocksRaycasts = true;
			_keyboardOverlayCanvasGroup.interactable = true;
			_keyboardOverlayRoot = val2.GetComponent<RectTransform>();
			_keyboardOverlayRoot.anchorMin = Vector2.zero;
			_keyboardOverlayRoot.anchorMax = Vector2.one;
			_keyboardOverlayRoot.offsetMin = Vector2.zero;
			_keyboardOverlayRoot.offsetMax = Vector2.zero;
			return _keyboardOverlayRoot;
		}

		internal static void HideKeyboardOverlay()
		{
			if ((Object)(object)_keyboardOverlayCanvasGroup != (Object)null)
			{
				_keyboardOverlayCanvasGroup.alpha = 0f;
				_keyboardOverlayCanvasGroup.blocksRaycasts = false;
				_keyboardOverlayCanvasGroup.interactable = false;
			}
		}

		internal static void ShowKeyboardOverlay()
		{
			RectTransform val = EnsureKeyboardOverlayRoot();
			if ((Object)(object)val != (Object)null)
			{
				CanvasGroup keyboardOverlayCanvasGroup = _keyboardOverlayCanvasGroup;
				if ((Object)(object)keyboardOverlayCanvasGroup != (Object)null)
				{
					keyboardOverlayCanvasGroup.alpha = 1f;
					keyboardOverlayCanvasGroup.blocksRaycasts = true;
					keyboardOverlayCanvasGroup.interactable = true;
				}
			}
		}

		private static TMP_FontAsset GetOrCreateLowercaseTextFont()
		{
			if ((Object)(object)_lowercaseTextFont != (Object)null)
			{
				return _lowercaseTextFont;
			}
			StyleManager.Fonts.Prepare();
			if ((Object)(object)StyleManager.Fonts.Arial == (Object)null)
			{
				return null;
			}
			_lowercaseTextFont = TMP_FontAsset.CreateFontAsset(StyleManager.Fonts.Arial);
			return _lowercaseTextFont;
		}

		private static void ApplyLowercaseTextFont(TMP_Text text)
		{
			if (!((Object)(object)text == (Object)null))
			{
				TMP_FontAsset orCreateLowercaseTextFont = GetOrCreateLowercaseTextFont();
				if ((Object)(object)orCreateLowercaseTextFont != (Object)null)
				{
					text.font = orCreateLowercaseTextFont;
				}
			}
		}

		private static Sprite GetOrCreateSliderHandleSprite()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_sliderHandleSprite != (Object)null)
			{
				return _sliderHandleSprite;
			}
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false);
			((Texture)val).filterMode = (FilterMode)1;
			Color32[] array = (Color32[])(object)new Color32[4096];
			float num = 31.5f;
			float num2 = 31.5f;
			float num3 = 26f;
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					float num4 = (float)j - num;
					float num5 = (float)i - num2;
					float num6 = Mathf.Sqrt(num4 * num4 + num5 * num5);
					byte b = (byte)(Mathf.Clamp01(num3 + 0.5f - num6) * 255f);
					array[i * 64 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b);
				}
			}
			val.SetPixels32(Il2CppStructArray<Color32>.op_Implicit(array));
			val.Apply(false, false);
			_sliderHandleSprite = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0);
			return _sliderHandleSprite;
		}

		private static Sprite GetOrCreateInputFieldSprite()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_inputFieldSprite != (Object)null)
			{
				return _inputFieldSprite;
			}
			Texture2D val = new Texture2D(128, 64, (TextureFormat)4, false);
			((Texture)val).filterMode = (FilterMode)1;
			float num = 18f;
			float num2 = 109f;
			float num3 = 18f;
			float num4 = 45f;
			Color32[] array = (Color32[])(object)new Color32[8192];
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 128; j++)
				{
					float num5 = (((float)j < num) ? (num - (float)j) : (((float)j > num2) ? ((float)j - num2) : 0f));
					float num6 = (((float)i < num3) ? (num3 - (float)i) : (((float)i > num4) ? ((float)i - num4) : 0f));
					float num7 = Mathf.Sqrt(num5 * num5 + num6 * num6);
					byte b = (byte)(Mathf.Clamp01(18.5f - num7) * 255f);
					array[i * 128 + j] = new Color32(byt