using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net.Http;
using System.Reflection;
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 System.Threading;
using System.Threading.Tasks;
using HarmonyLib;
using Il2Cpp;
using Il2CppEpic.OnlineServices;
using Il2CppEpic.OnlineServices.Connect;
using Il2CppEpic.OnlineServices.P2P;
using Il2CppEpic.OnlineServices.Platform;
using Il2CppEpic.OnlineServices.Sessions;
using Il2CppGameGUI.Options;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppKeepsake;
using Il2CppKeepsake.Common.Unity;
using Il2CppKeepsake.Data;
using Il2CppKeepsake.Framework.Networking.Data;
using Il2CppKeepsake.Framework.Networking.Logic;
using Il2CppKeepsake.HyperSpace.GameMode.Logic;
using Il2CppKeepsake.HyperSpace.NewInputSystem;
using Il2CppKeepsake.HyperSpace.Online.Data;
using Il2CppKeepsake.HyperSpace.Online.Epic.Util;
using Il2CppKeepsake.HyperSpace.Online.Epic.Util.Transport;
using Il2CppKeepsake.HyperSpace.Online.Lobby.Data;
using Il2CppKeepsake.HyperSpace.Online.Lobby.Logic;
using Il2CppKeepsake.HyperSpace.Online.Steam;
using Il2CppKeepsake.HyperSpace.Online.Util;
using Il2CppKeepsake.HyperSpace.System.LoadingScreen.Presentation;
using Il2CppKeepsake.Modal;
using Il2CppKeepsake.NetworkedTimer;
using Il2CppKeepsake.PlayerGroupBar;
using Il2CppKeepsake.PlayerStatusBar;
using Il2CppSteamworks;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Collections.ObjectModel;
using Il2CppSystem.Threading;
using Il2CppTMPro;
using Il2CppUniRx;
using MelonLoader;
using MelonLoader.NativeUtils;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using NAudio.CoreAudioApi;
using NAudio.Wave;
using NAudio.Wave.SampleProviders;
using Unity.Netcode;
using Unity.Networking.Transport;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.UI;
using V2T;
using Whisper.net;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(V2TMod), "V2T", "4.1.2", "Pasharacc", null)]
[assembly: MelonGame("Keepsake Games", "Jump Space")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("V2T")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("4.1.2.0")]
[assembly: AssemblyInformationalVersion("4.1.2")]
[assembly: AssemblyProduct("V2T")]
[assembly: AssemblyTitle("V2T")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.1.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 V2T
{
	internal static class BrowserUi
	{
		[HarmonyPatch(typeof(GUI_ServerBrowser), "Open")]
		private static class HookOpen
		{
			private static void Postfix(GUI_ServerBrowser __instance)
			{
				_browser = __instance;
			}
		}

		[HarmonyPatch(typeof(GUI_ServerBrowser), "Handle_Pending")]
		private static class HookPending
		{
			private static void Postfix(GUI_ServerBrowser __instance, bool pending)
			{
				_browser = __instance;
				_pending = pending;
				if (!pending)
				{
					_nextSnapshot = 0f;
				}
				LiveResults(pending);
			}
		}

		private delegate void Act();

		private struct Cols
		{
			public float Lobby;

			public float Players;

			public float Mission;

			public float Jumps;

			public float Ship;

			public float Region;

			public float End;
		}

		private struct ListItem
		{
			public LobbyInfo Lobby;

			public string Header;

			public int Count;

			public Color Colour;

			public Ghost Gone;

			public float Size;

			public float Fade;
		}

		internal enum FieldLook
		{
			Talking,
			Live,
			Listening,
			Transcribing,
			Translating,
			Sent,
			NoAudio,
			Warning
		}

		private struct CrewCard
		{
			public string Id;

			public string Name;

			public string Station;

			public int Level;

			public bool You;

			public bool Host;

			public bool HasReady;

			public bool Ready;

			public bool Downed;

			public bool Reviving;

			public bool Defeated;

			public bool NotSeated;

			public bool InJumpSeat;

			public bool HasBleed;

			public float BleedLeft;

			public float BleedMax;

			public float BleedAt;

			public float ReviveStart;

			public float ReviveTime;

			public float Health;

			public float MaxHealth;

			public float Shield;

			public float MaxShield;
		}

		private readonly struct Glass
		{
			public readonly int Id;

			public readonly Color Top;

			public readonly Color Mid;

			public readonly Color Bottom;

			public readonly Color Lit;

			public readonly float LitA;

			public Glass(int id, Color top, Color mid, Color bottom, Color lit, float litA)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: 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_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Id = id;
				Top = top;
				Mid = mid;
				Bottom = bottom;
				Lit = lit;
				LitA = litA;
			}
		}

		private struct WalletChip
		{
			public string Text;

			public string Id;

			public bool Ingot;

			public Color Colour;

			public Color IconTint;

			public Texture2D Icon;
		}

		private struct HostView
		{
			public HostMode Mode;

			public string Name;

			public string Password;

			public bool Auto;

			public int Region;
		}

		internal enum LayoutItem
		{
			None,
			Chat,
			Crew,
			Own,
			Comms,
			Wallet
		}

		private sealed class JoinAttempt
		{
			public LobbyInfo Lobby;

			public string Title = "Joining";

			public IntPtr AskReq;

			public JoinWatch Watch;

			public bool Cancelled;

			public bool SaidIt;

			public string Status = "";

			public string LoggedStatus = "";

			public float EndedAt = -1f;
		}

		private sealed class Seen
		{
			public LobbyInfo Last;

			public int FriendMask;

			public float NewAt = -100f;

			public float SeatsAt = -100f;

			public float MaxAt = -100f;

			public float JumpsAt = -100f;

			public float MissionAt = -100f;

			public float ShipAt = -100f;

			public float NameAt = -100f;

			public float HostAt = -100f;

			public float LockAt = -100f;

			public float TagAt = -100f;

			public float LevelAt = -100f;

			public float RegionAt = -100f;

			public float FriendAt = -100f;

			public int SeatsFrom;

			public int JumpsFrom;

			public int LitFrom;

			public int FriendsNew;

			public Color MissionFrom;
		}

		private sealed class Ghost
		{
			public LobbyInfo L;

			public float At;

			public int Segment;

			public int Index;
		}

		[HarmonyPatch(typeof(GUI_MainMenu), "OnEnable")]
		private static class HookMenuEnable
		{
			private static void Postfix(GUI_MainMenu __instance)
			{
				_menuInst = __instance;
			}
		}

		[HarmonyPatch(typeof(GUI_MainMenu), "Show")]
		private static class HookMenuShow
		{
			private static void Postfix(GUI_MainMenu __instance)
			{
				_menuInst = __instance;
			}
		}

		private static bool _escWarned;

		private static bool _escLogged;

		private static bool _hostingPublic;

		private static float _hostingReadAt = -10f;

		private static bool _escGuest;

		private static bool _escHost;

		private static string _gapNote = "";

		private static float? _gapCache;

		private static float _gapNext;

		private static bool _filtersLoaded;

		private static bool _threatDrag;

		private static bool _dragHigh;

		private static bool _regionsOpen;

		private static Rect _threatTrack;

		private static Rect _threatLabel;

		private static Rect _regionsButton;

		private static Rect _regionsMenu;

		private static float _cellStep;

		private static readonly List<(Rect R, int Kind, int Index, string Code)> _menuHits = new List<(Rect, int, int, string)>();

		private static readonly Dictionary<string, string> _regionNames = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<int, Color> _threatSeen = new Dictionary<int, Color>();

		private const int HitRegion = 0;

		private const int HitContinent = 1;

		private const int HitAll = 2;

		private const int HitNone = 3;

		private const int HitGoodPing = 4;

		private static GUI_ServerBrowser _browser;

		private static bool _pending;

		private static bool _wasOpen;

		private static bool _logged;

		private static bool _warned;

		private static bool _sampled;

		private static readonly BrowserFilter Filter = new BrowserFilter();

		private static SortKey _sort = SortKey.Players;

		private static bool _desc = true;

		private static List<LobbyInfo> _all = new List<LobbyInfo>();

		private static readonly List<LobbyInfo> _friends = new List<LobbyInfo>();

		private static readonly List<LobbyInfo> _public = new List<LobbyInfo>();

		private static readonly List<LobbyInfo> _locked = new List<LobbyInfo>();

		private static int _longestRun;

		private static int _dupesLoggedAt = -1;

		private static float _nextSnapshot;

		private static float _scroll;

		private static float _joinAt = -10f;

		private static bool _searchFocus;

		private static int _drawFailures;

		private static bool _broken;

		private static float _drawnAt = -10f;

		private static bool _typing;

		private static bool _unsubscribed;

		private static CanvasGroup _group;

		private static bool _groupAdded;

		private static bool _hiding;

		private static GraphicRaycaster _raycaster;

		private static bool _raycasterWasOn;

		private static readonly Dictionary<string, string> ShipByGuid = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, string> MissionByGuid = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private static bool _ownLogged;

		private static bool _ownWarned;

		private static readonly Color Green = new Color(0.25f, 1f, 0.4f);

		private static readonly Color Ink = new Color(0.95f, 0.96f, 0.98f);

		private static readonly Color Grey = new Color(0.49f, 0.53f, 0.58f);

		private static readonly Color Empty = new Color(0.17f, 0.2f, 0.22f);

		private static readonly Color FriendBlue = new Color(0.4f, 0.75f, 0.96f);

		private static readonly Color RecentViolet = new Color(0.71f, 0.61f, 1f);

		private static readonly Color LockGold = new Color(0.79f, 0.64f, 0.15f);

		private static readonly Color DartGreen = new Color(0.25f, 1f, 0.4f);

		private static readonly Color CatamaranBlue = new Color(0.22f, 0.74f, 0.97f);

		private static readonly Color HammerheadRed = new Color(1f, 0.42f, 0.26f);

		private static readonly Color[] Tier = (Color[])(object)new Color[4]
		{
			new Color(0.29f, 0.87f, 0.5f),
			new Color(1f, 0.82f, 0.25f),
			new Color(1f, 0.54f, 0.24f),
			new Color(1f, 0.3f, 0.3f)
		};

		private static readonly Color[] ThreatScale = (Color[])(object)new Color[10]
		{
			new Color(0.29f, 0.87f, 0.5f),
			new Color(0.64f, 0.9f, 0.21f),
			new Color(1f, 0.82f, 0.25f),
			new Color(1f, 0.69f, 0.18f),
			new Color(1f, 0.54f, 0.24f),
			new Color(1f, 0.3f, 0.3f),
			new Color(0.88f, 0.14f, 0.37f),
			new Color(0.76f, 0.09f, 0.36f),
			new Color(0.61f, 0.15f, 0.69f),
			new Color(0.48f, 0.12f, 0.64f)
		};

		private static readonly Color[] ShipPalette = (Color[])(object)new Color[6]
		{
			new Color(0.22f, 0.74f, 0.97f),
			new Color(0.91f, 0.47f, 0.98f),
			new Color(0.98f, 0.8f, 0.08f),
			new Color(0.18f, 0.83f, 0.75f),
			new Color(0.98f, 0.57f, 0.24f),
			new Color(0.65f, 0.55f, 0.98f)
		};

		private static float _s = 1f;

		private static GUIStyle _label;

		private static GUIStyle _invisible;

		private static int _labelSize;

		private static Rect _searchRect;

		private static float _storeOpenedAt = -10f;

		private static int _listVersion;

		private static int _measuredVersion = -1;

		private static float _measuredS;

		private static float _missionTextW;

		private static float _shipTextW;

		private static float _regionTextW;

		private static int _mostSeats;

		private static readonly List<ListItem> _items = new List<ListItem>();

		private const string YourLobby = "Your Lobby";

		private static readonly Color YourYellow = new Color(1f, 0.8f, 0.12f);

		private static readonly Dictionary<float[][], Vector2> _glyphMin = new Dictionary<float[][], Vector2>();

		private static readonly Color MissionBubble = new Color(0.075f, 0.09f, 0.1f);

		private static GUI_Modal _modalView;

		private static CanvasGroup _modalGroup;

		private static bool _modalHidden;

		private static bool _warnedDialog;

		private static float _dialogAt = -10f;

		private static float _nextFocus;

		private static float _shownAt;

		private static IntPtr _shownReq;

		private static IntPtr _pressedReq;

		private static IntPtr _queuedReq;

		private static ModalButton _queuedButton;

		private static bool _queuedJoin;

		private static string _queuedLabel;

		private static string _loggedDialog;

		private static GUIStyle _wrap;

		private static bool _mono;

		private static float _dim = 1f;

		private static readonly Dictionary<int, GUIStyle> _fills = new Dictionary<int, GUIStyle>();

		private static readonly Dictionary<int, GUIStyle> _lines = new Dictionary<int, GUIStyle>();

		private static readonly Dictionary<int, GUIStyle> _lines2 = new Dictionary<int, GUIStyle>();

		private static Texture2D _logo;

		private static bool _logoFailed;

		private static readonly float[][] ShipGlyph = new float[1][] { new float[12]
		{
			0f, 0.5f, 0.33f, 0.08f, 0.72f, 0.08f, 1f, 0.5f, 0.72f, 0.92f,
			0.33f, 0.92f
		} };

		private static readonly float[][] DartGlyph = new float[1][] { new float[70]
		{
			0.387f, 0.181f, 0.413f, 0.184f, 0.528f, 0.257f, 0.535f, 0.301f, 0.596f, 0.325f,
			0.617f, 0.372f, 0.662f, 0.385f, 0.678f, 0.445f, 0.704f, 0.469f, 0.704f, 0.531f,
			0.678f, 0.555f, 0.662f, 0.615f, 0.617f, 0.628f, 0.596f, 0.675f, 0.535f, 0.699f,
			0.528f, 0.743f, 0.396f, 0.819f, 0.375f, 0.816f, 0.362f, 0.795f, 0.343f, 0.727f,
			0.352f, 0.709f, 0.369f, 0.704f, 0.326f, 0.667f, 0.3f, 0.597f, 0.296f, 0.552f,
			0.301f, 0.51f, 0.342f, 0.505f, 0.34f, 0.492f, 0.298f, 0.484f, 0.298f, 0.411f,
			0.326f, 0.333f, 0.369f, 0.296f, 0.352f, 0.291f, 0.343f, 0.27f, 0.362f, 0.205f
		} };

		private static readonly float[][] CatamaranGlyph = new float[1][] { new float[94]
		{
			0.331f, 0.092f, 0.421f, 0.117f, 0.387f, 0.142f, 0.421f, 0.204f, 0.464f, 0.215f,
			0.452f, 0.218f, 0.461f, 0.254f, 0.548f, 0.269f, 0.579f, 0.258f, 0.584f, 0.28f,
			0.722f, 0.301f, 0.767f, 0.323f, 0.791f, 0.377f, 0.787f, 0.413f, 0.702f, 0.41f,
			0.7f, 0.442f, 0.683f, 0.467f, 0.683f, 0.533f, 0.7f, 0.558f, 0.702f, 0.59f,
			0.787f, 0.587f, 0.791f, 0.623f, 0.784f, 0.648f, 0.746f, 0.691f, 0.584f, 0.72f,
			0.579f, 0.742f, 0.548f, 0.731f, 0.461f, 0.746f, 0.452f, 0.782f, 0.466f, 0.782f,
			0.421f, 0.796f, 0.387f, 0.858f, 0.421f, 0.883f, 0.331f, 0.908f, 0.271f, 0.858f,
			0.266f, 0.764f, 0.238f, 0.742f, 0.233f, 0.713f, 0.221f, 0.706f, 0.209f, 0.623f,
			0.218f, 0.504f, 0.209f, 0.377f, 0.221f, 0.294f, 0.233f, 0.287f, 0.238f, 0.258f,
			0.266f, 0.236f, 0.271f, 0.142f
		} };

		private static readonly float[][] HammerheadGlyph = new float[1][] { new float[154]
		{
			0.198f, 0.065f, 0.229f, 0.065f, 0.246f, 0.101f, 0.295f, 0.153f, 0.305f, 0.153f,
			0.315f, 0.133f, 0.391f, 0.138f, 0.429f, 0.179f, 0.464f, 0.179f, 0.467f, 0.215f,
			0.512f, 0.231f, 0.547f, 0.231f, 0.567f, 0.205f, 0.598f, 0.2f, 0.622f, 0.158f,
			0.709f, 0.179f, 0.761f, 0.272f, 0.757f, 0.329f, 0.764f, 0.34f, 0.802f, 0.334f,
			0.957f, 0.381f, 0.968f, 0.396f, 0.964f, 0.417f, 0.985f, 0.422f, 0.988f, 0.443f,
			0.968f, 0.459f, 0.968f, 0.484f, 0.943f, 0.49f, 0.94f, 0.505f, 0.968f, 0.516f,
			0.968f, 0.541f, 0.985f, 0.547f, 0.988f, 0.572f, 0.968f, 0.578f, 0.968f, 0.604f,
			0.947f, 0.629f, 0.802f, 0.666f, 0.764f, 0.66f, 0.757f, 0.671f, 0.761f, 0.728f,
			0.709f, 0.821f, 0.622f, 0.842f, 0.598f, 0.8f, 0.567f, 0.795f, 0.547f, 0.769f,
			0.512f, 0.769f, 0.467f, 0.785f, 0.464f, 0.821f, 0.429f, 0.821f, 0.391f, 0.862f,
			0.315f, 0.868f, 0.305f, 0.847f, 0.295f, 0.847f, 0.246f, 0.899f, 0.229f, 0.935f,
			0.198f, 0.935f, 0.188f, 0.909f, 0.177f, 0.909f, 0.146f, 0.8f, 0.126f, 0.79f,
			0.081f, 0.712f, 0.081f, 0.609f, 0.043f, 0.557f, 0.039f, 0.531f, 0.012f, 0.526f,
			0.022f, 0.521f, 0.015f, 0.505f, 0.022f, 0.479f, 0.012f, 0.474f, 0.039f, 0.469f,
			0.043f, 0.443f, 0.081f, 0.391f, 0.081f, 0.288f, 0.126f, 0.21f, 0.146f, 0.2f,
			0.177f, 0.091f, 0.188f, 0.091f
		} };

		private static readonly HashSet<float[][]> WideIcons = new HashSet<float[][]> { DartGlyph, CatamaranGlyph, HammerheadGlyph };

		private static readonly float[][] Chevron = new float[1][] { new float[12]
		{
			0f, 0f, 0.55f, 0f, 1f, 0.5f, 0.55f, 1f, 0f, 1f,
			0.45f, 0.5f
		} };

		private static readonly float[][] TriDown = new float[1][] { new float[6] { 0f, 0.15f, 1f, 0.15f, 0.5f, 0.9f } };

		private static readonly float[][] TriUp = new float[1][] { new float[6] { 0f, 0.85f, 1f, 0.85f, 0.5f, 0.1f } };

		private static readonly float[][] Padlock = new float[2][]
		{
			new float[8] { 0.12f, 0.45f, 0.88f, 0.45f, 0.88f, 1f, 0.12f, 1f },
			null
		};

		private static readonly float[][] Clock = new float[2][];

		private static readonly float[][] Person = new float[3][];

		private static readonly Dictionary<float[][], Texture2D> _icons = new Dictionary<float[][], Texture2D>();

		private static Texture2D _glowRamp;

		private static float _typingDrawnAt = -10f;

		private static readonly Color HudRed = new Color(1f, 0.28f, 0.22f);

		private static readonly Color MeterOff = new Color(0.15f, 0.19f, 0.18f);

		private static readonly Color BarOff = new Color(0.11f, 0.23f, 0.15f);

		private static readonly float[][] IcMic = new float[1][];

		private static readonly float[][] IcMicOff = new float[1][];

		private static readonly float[][] IcSpk = new float[1][];

		private static readonly float[][] IcSpkOff = new float[1][];

		private static readonly float[][] IcChat = new float[1][];

		private static readonly float[][] IcChatOff = new float[1][];

		private static readonly float[] ChatTail = new float[6] { 0.26f, 0.66f, 0.46f, 0.66f, 0.22f, 0.9f };

		private static readonly float[][] IcCrown = new float[1][] { new float[14]
		{
			0.1f, 0.8f, 0.9f, 0.8f, 0.96f, 0.28f, 0.7f, 0.5f, 0.5f, 0.16f,
			0.3f, 0.5f, 0.04f, 0.28f
		} };

		private static readonly float[][] IcPersonPlus = new float[1][];

		private static readonly float[][] IcCheck = new float[1][];

		private static readonly float[][] IcPhonesOff = new float[1][];

		private static readonly float[][] IcSkull = new float[1][];

		private static readonly float[][] IcKeyboard = new float[1][];

		private static readonly float[][] IcGlobe = new float[1][];

		private static bool _cpLangOpen;

		private static bool _cpWarned;

		private static bool _cpLogged;

		private static bool _cpOff;

		private static int _cpFailures;

		private static Rect _cpLangRect;

		private static Rect _cpDropRect;

		private static readonly Color CpSub = new Color(0.55f, 0.59f, 0.64f);

		private static bool _cpListening;

		private static float _cpListenAt;

		private static readonly HashSet<int> _cpHeldAtStart = new HashSet<int>();

		private static bool _cpFits = true;

		private static bool _cpBesideLogged;

		private static bool _cpFitLogged;

		private static readonly Color GameBlue = new Color(0.49f, 0.83f, 0.99f);

		private static bool _balDrag;

		private static int _cpListenFor;

		private static readonly List<CrewCard> _cards = new List<CrewCard>();

		private static GUI_LobbyHandler _lobby;

		private static GUI_PlayerGroupBar_Controller _bar;

		private static float _lobbySearchAt;

		private static float _barSearchAt;

		private static float _cardsTickAt;

		private static float _cardsDrawnAt = -10f;

		private static bool _cardsWanted;

		private static bool _inviteWanted;

		private static bool _mission;

		private static bool _anchorKnown;

		private static bool _crewHidden;

		private static bool _cardsWarned;

		private static Rect _cardsAnchor;

		private static GameObject _standInA;

		private static GameObject _standInB;

		private static GameObject _hiddenA;

		private static GameObject _hiddenB;

		private static CanvasGroup _groupA;

		private static CanvasGroup _groupB;

		private static float _alphaA = 1f;

		private static float _alphaB = 1f;

		private static string _cardsLogged = "";

		private static string _anchorLogged = "";

		private static readonly Dictionary<string, float> _firstSeen = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private static GUI_PlayerStatusBar_Health _ownHealth;

		private static GUI_PlayerStatusBar_LocationText _ownLoc;

		private static GUI_PlayerStatusBar_Name _ownName;

		private static GameObject _ownBox;

		private static float _ownSearchAt;

		private static bool _ownWanted;

		private static bool _ownRectKnown;

		private static CrewCard _ownCard;

		private static Rect _ownRect;

		private static string _missionKey = "";

		private static string _ownCardLogged = "";

		private static bool _crewTopKnown;

		private static float _crewTop;

		private static readonly List<(CanvasGroup G, CanvasGroup Above)> _keepShown = new List<(CanvasGroup, CanvasGroup)>();

		private const float DetectSeconds = 20f;

		private static readonly Color CardInk = new Color(0.04f, 0.055f, 0.067f);

		private static readonly Color InviteGrey = new Color(0.17f, 0.2f, 0.22f);

		private static readonly Color KeyYellow = new Color(1f, 0.88f, 0.3f);

		private static readonly Color CrownGold = new Color(1f, 0.8f, 0.12f);

		private static readonly Color HealthGreen = new Color(0.29f, 0.87f, 0.5f);

		private static readonly Color HealthAmber = new Color(1f, 0.72f, 0.15f);

		private static readonly Color ShieldBlue = new Color(0.22f, 0.74f, 0.97f);

		private static readonly Color BarGrey = new Color(0.23f, 0.26f, 0.28f);

		private static readonly Color StationInk = new Color(0.86f, 0.9f, 0.93f);

		private static readonly Dictionary<string, bool> _readyWas = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, float> _readyAt = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private const float ReadyFillTime = 0.45f;

		private const float ReadySwooshTime = 0.4f;

		private const float ReadyPopTime = 0.3f;

		private const float ReadyPopAt = 0.77f;

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

		private static GUI_Toggler _toggler;

		private static bool _seat;

		private static string _seatLogged = "";

		private static readonly Dictionary<string, Color> _gameColours = new Dictionary<string, Color>(StringComparer.OrdinalIgnoreCase);

		private static float _gameColoursAt;

		private static string _gameColoursLogged = "";

		private static bool _jumpCharging;

		private static float _jumpHoldUntil;

		private static string _jumpLogged = "";

		private static readonly Dictionary<string, float> _bleedMax = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<string> _bleedLogged = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static bool _bleedWarned;

		private static readonly Dictionary<string, float> _reviveStart = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, float> _reviveHold = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private static readonly Color DownRed = new Color(1f, 0.16f, 0.12f);

		private static readonly Dictionary<string, (float Phase, float At)> _phases = new Dictionary<string, (float, float)>(StringComparer.Ordinal);

		private static Rect _crewTopRect;

		private static Rect _hangarStats;

		private static bool _hangarStatsKnown;

		private static bool _hangarCrewFootKnown;

		private static float _hangarCrewFoot;

		private static readonly Color OwnGreen = new Color(0.2f, 0.78f, 0.36f);

		private const float CardBodyAlpha = 0.42f;

		private static readonly Dictionary<int, GUIStyle> _cardRings = new Dictionary<int, GUIStyle>();

		private static readonly Dictionary<int, Texture2D> _fillets = new Dictionary<int, Texture2D>();

		private const float StationWeight = 0.4f;

		private static Texture2D _swooshTex;

		private static readonly Dictionary<string, float> _noV2tAt = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private static readonly Glass GlassGreen = new Glass(1, Hex(4047479), Hex(2792026), Hex(2062919), Hex(13172700), 0.55f);

		private static readonly Glass GlassAmber = new Glass(2, Hex(15773756), Hex(13208094), Hex(10841620), Hex(16773320), 0.55f);

		private static readonly Glass GlassRed = new Glass(3, Hex(15751242), Hex(13056816), Hex(10496546), Hex(16766925), 0.5f);

		private static readonly Glass GlassBlue = new Glass(4, Hex(5219310), Hex(3375308), Hex(2384550), Hex(13822975), 0.6f);

		private static readonly Glass GlassV2T = new Glass(6, Hex(5435514), Hex(3394652), Hex(2401865), Hex(14745576), 0.55f);

		private static readonly Glass GlassTrack = new Glass(5, Hex(461581), Hex(1054491), Hex(1252128), Color.black, 0f);

		private static readonly Dictionary<int, GUIStyle> _glass = new Dictionary<int, GUIStyle>();

		private static string _volDragKey;

		private static bool _meKnown;

		private static bool _mePrompt;

		private static bool _meReady;

		private static bool _meHasReady;

		private static bool _meMissionPicked;

		private static string _meKey = "";

		private static float _meKeySearchAt = -10f;

		private static bool _meKeyLogged;

		private static bool _mePickedLogged;

		private static bool _meReadyWarned;

		private static float _meReadySince = -1f;

		private static bool _meCardReady;

		private static bool _meCardReadyKnown;

		private static float _meReadyPendingAt = -1f;

		private static float _meLastReadyAt = -10f;

		private static float _mePromptFlipAt = -10f;

		private static float _mePromptFlipPrev = -20f;

		private static int _meLevel;

		private static string _meRank = "";

		private static string _meXpText = "";

		private static string _meReadyText = "";

		private static float _meXpFrac;

		private static float _meDrawnAt = -10f;

		private static GameObject _meGo;

		private static readonly List<WalletChip> _chips = new List<WalletChip>();

		private static GUI_PlayerWallet _wallet;

		private static float _walletSearchAt;

		private static Rect _walletRect;

		private static readonly Dictionary<string, Texture2D> _chipIcons = new Dictionary<string, Texture2D>();

		private static string _homeSaved;

		private static readonly Regex Tags = new Regex("<[^>]*>", RegexOptions.Compiled);

		private static bool _meWarned;

		private static bool _walletWarned;

		private static string _meLogged;

		private static string _walletLogged;

		private static CanvasGroup _groupMe;

		private static CanvasGroup _groupWallet;

		private static float _alphaMe;

		private static float _alphaWallet;

		private static bool _meHidden;

		private static readonly Color ReadyAmber = new Color(1f, 0.72f, 0.15f);

		private static float _readyFlash = 1f;

		private const float PopTime = 0.4f;

		private const float PingEvery = 1.6f;

		private const float PingTime = 0.9f;

		private const float BounceTime = 0.3f;

		private static bool _readyWasUp;

		private static float _readyShownAt;

		private static HostView _host;

		private static float _hostReadAt = -10f;

		private static float _hostActAt = -10f;

		private static bool _hostLogged;

		private static bool _hostWarned;

		private static bool _hostActWarned;

		private static string[] _regionWire;

		private static string _appliedSig;

		private static int _draftMin = -1;

		private static int _draftMax = -1;

		private static int _draftFriends = -1;

		private const int ListTries = 3;

		private static bool _listChecking;

		private static bool _listSearching;

		private static bool _listSawPending;

		private static int _listTry;

		private static float _listStartedAt = -1f;

		private static float _listRetryAt = -1f;

		private static float _listDoneAt = -1f;

		private static float _autoCheckAt = -1f;

		private static int _listResult;

		private static int _listCount;

		private static string _listSession;

		private static readonly Color FieldLabel = new Color(0.25f, 1f, 0.4f, 0.75f);

		private static readonly Color Muted = new Color(0.62f, 0.69f, 0.64f);

		private static readonly Color ChipInk = new Color(0.81f, 0.84f, 0.86f);

		private static readonly Color PuckGrey = new Color(0.72f, 0.75f, 0.78f);

		private const int FocusNone = 0;

		private const int FocusName = 1;

		private const int FocusPassword = 2;

		private static int _hostFocus;

		private static string _hostEdit = "";

		private static Rect _nameBox;

		private static Rect _passBox;

		private static bool _warnedWrite;

		private static HostMode _appliedMode = (HostMode)(-1);

		private static bool _levelDrag;

		private static bool _levelDragHigh;

		private static int _levelLo = -1;

		private static int _levelHi = -1;

		private static readonly Color ToggleOff = new Color(0.047f, 0.059f, 0.067f);

		private static readonly Color ToggleOffLine = new Color(0.23f, 0.255f, 0.28f);

		private const float RegionHeadH = 26f;

		private const float RegionPuckH = 28f;

		private const float RegionPuckGap = 5f;

		private const float RegionBoxPad = 8f;

		private const int RegionsPerRow = 2;

		private static bool _layoutEdit;

		private static LayoutItem _lDrag;

		private static int _lCorner;

		private static Vector2 _lFrom;

		private static Rect _lRectFrom;

		private static float _lScaleFrom;

		private static Rect _lResetAll;

		private static Rect _lDone;

		private static Rect _lBar;

		private static readonly HashSet<LayoutItem> _lSel = new HashSet<LayoutItem>();

		private static readonly Dictionary<LayoutItem, Rect> _lGroupFrom = new Dictionary<LayoutItem, Rect>();

		private static bool _marquee;

		private static Vector2 _mFrom;

		private static Vector2 _mTo;

		private static readonly HashSet<LayoutItem> _mBase = new HashSet<LayoutItem>();

		private static readonly Dictionary<LayoutItem, Rect> _lLabelRects = new Dictionary<LayoutItem, Rect>();

		private static LayoutItem _pendingToggle;

		private static Vector2 _pendingFrom;

		private static Rect _pendingRect;

		private static bool _pendingMove;

		private static Rect _lTextTrack;

		private static Rect _lTextHit;

		private static float _notchSince = -1f;

		private static readonly Dictionary<LayoutItem, Rect> _lResetRects = new Dictionary<LayoutItem, Rect>();

		private static Rect _ownBlockRect;

		private const int FauxMin = 2;

		private const int FauxMax = 11;

		private static int _fauxPlayers = 4;

		private static bool _fauxDrag;

		private static Rect _fauxTrack;

		private static Rect _fauxHit;

		private static readonly (string Name, int Level, Color Colour, string Station, float Health, float Shield)[] Faux = new(string, int, Color, string, float, float)[10]
		{
			(ChatFeed.PreviewName(0), 12, ChatFeed.PreviewPalette[0], "Cargo bay", 100f, 50f),
			(ChatFeed.PreviewName(1), 7, ChatFeed.PreviewPalette[1], "Bridge", 72f, 20f),
			(ChatFeed.PreviewName(2), 15, ChatFeed.PreviewPalette[2], "Engine room", 45f, 0f),
			(ChatFeed.PreviewName(3), 4, ChatFeed.PreviewPalette[3], "Turrets", 100f, 35f),
			(ChatFeed.PreviewName(4), 9, ChatFeed.PreviewPalette[4], "Core room", 28f, 0f),
			(ChatFeed.PreviewName(5), 11, ChatFeed.PreviewPalette[5], "In space", 90f, 50f),
			(ChatFeed.PreviewName(6), 3, ChatFeed.PreviewPalette[6], "Airlock", 60f, 10f),
			(ChatFeed.PreviewName(7), 14, ChatFeed.PreviewPalette[7], "Hangar bay", 100f, 50f),
			(ChatFeed.PreviewName(8), 6, ChatFeed.PreviewPalette[8], "Medbay", 85f, 25f),
			(ChatFeed.PreviewName(9), 10, ChatFeed.PreviewPalette[9], "Armory", 55f, 40f)
		};

		private static readonly LayoutItem[] AllItems = new LayoutItem[5]
		{
			LayoutItem.Chat,
			LayoutItem.Crew,
			LayoutItem.Own,
			LayoutItem.Comms,
			LayoutItem.Wallet
		};

		private static bool _sizeDrag;

		private static float _sizeTouchedAt = -10f;

		private static CanvasGroup _pmGroup;

		private static float _pmAlpha;

		private static bool _pmRaycasts;

		private static bool _pmInteractable;

		private static bool _pmHidden;

		private const float FadeOut = 0.35f;

		private static readonly Color FailAmber = new Color(1f, 0.66f, 0.2f);

		private static JoinAttempt _join;

		private static LobbyInfo _asked;

		private static IntPtr _askedReq;

		private static float _askedAt = -1000f;

		private static LoadingScreenPresentationBehaviour _loadingView;

		private static float _nextLoadingLook;

		private static TMP_Text _hiddenText;

		private static CanvasGroup _hiddenCancel;

		private static bool _joinWarned;

		private static float _cardH = -1f;

		private static float _cardAt = -10f;

		private static IntPtr _loggedFail;

		private const float ChangePing = 1.45f;

		private const float WashTime = 2.25f;

		private const float SeatIn = 0.28f;

		private const float RedIn = 0.43f;

		private const float RedOut = 1.18f;

		private const float MissionIn = 0.45f;

		private const float BlockStep = 0.095f;

		private const float BlockIn = 0.225f;

		private const float BlockOut = 0.7f;

		private const float MissionWindow = 1.6500001f;

		private const float NewOpen = 0.4f;

		private const float NewGlow = 3.1f;

		private const float GoneRedIn = 0.225f;

		private const float GoneFadeAt = 1.25f;

		private const float GoneCloseAt = 2.05f;

		private const float GoneEnd = 2.4f;

		private static readonly Color GoneRed = new Color(1f, 0.3f, 0.3f);

		private static readonly Dictionary<string, Seen> _seen = new Dictionary<string, Seen>(StringComparer.Ordinal);

		private static readonly List<Ghost> _ghosts = new List<Ghost>();

		private static readonly List<Ghost> _segGhosts = new List<Ghost>();

		private static bool _changesPrimed;

		private static bool _ghostRow;

		private static int _changeLogs;

		private const int ChevSteps = 9;

		private const float ChevPad = 2f;

		private const float ChevRes = 3f;

		private static readonly Texture2D[] _chevRings = (Texture2D[])(object)new Texture2D[9];

		private const float LiveEvery = 5f;

		private const float GlowDown = 0.8f;

		private static float _liveEvery = 5f;

		private static float _liveAskedAt = -100f;

		private static float _lastResultsAt = -100f;

		private static float _glowDownAt = -100f;

		private static float _pendingSince = -1f;

		private static bool _liveAsked;

		private static bool _resortNext = true;

		private static bool _resortPending;

		private static bool _everLoaded;

		private static bool _liveWarned;

		private static readonly Dictionary<string, GUI_ServerListEntry> RowById = new Dictionary<string, GUI_ServerListEntry>(StringComparer.Ordinal);

		private static readonly List<string> OrderFriends = new List<string>();

		private static readonly List<string> OrderPublic = new List<string>();

		private static readonly List<string> OrderLocked = new List<string>();

		private static bool _itemsWarned;

		private static LobbyInfo _joinWait;

		private static float _joinWaitAt;

		private const float LiveBarW = 5f;

		private const float LiveBarH = 14f;

		private const float LiveBarGap = 4f;

		private static bool _menuArmed = true;

		private static bool _menuWarned;

		private static bool _prologueLogged;

		private static float _menuSeenAt = -1f;

		private static float _nextMenuCheck;

		private static bool _hangarNext;

		private static float _hangarNextAt = -100f;

		private static float _leaveAt = -1f;

		private static IntPtr _leaveReq;

		private static bool _leaveGuest;

		private static GUI_MainMenu _menuInst;

		private static string _menuWaitLogged;

		private static float _cardShownAt = -1f;

		private static readonly Color TileAmber = new Color(1f, 0.72f, 0.15f);

		private static readonly Color TileCream = new Color(1f, 0.89f, 0.64f);

		private const float SheenEvery = 5f;

		private const float SheenIdle = 0.62f;

		private static readonly float[][] DownloadGlyph = new float[2][]
		{
			new float[14]
			{
				0.417f, 0.125f, 0.583f, 0.125f, 0.583f, 0.458f, 0.75f, 0.458f, 0.5f, 0.75f,
				0.25f, 0.458f, 0.417f, 0.458f
			},
			new float[16]
			{
				0.125f, 0.667f, 0.25f, 0.667f, 0.25f, 0.792f, 0.75f, 0.792f, 0.75f, 0.667f,
				0.875f, 0.667f, 0.875f, 0.917f, 0.125f, 0.917f
			}
		};

		private static Texture2D _sheen;

		private static Rect _tileRect;

		private static bool _tileHover;

		private static bool _tileLogged;

		private static float _updateOpenedAt = -10f;

		private static int _sheenW;

		private static int _sheenH;

		private static float[] _sheenMask;

		private static Color32[] _sheenPx;

		private static GUI_PauseMenu EscMenu
		{
			get
			{
				try
				{
					GUI_PauseMenu pauseMenu = gameGUI.PauseMenu;
					return ((Object)(object)pauseMenu != (Object)null && pauseMenu.IsOpen) ? pauseMenu : null;
				}
				catch
				{
					return null;
				}
			}
		}

		private static bool HostingPublic
		{
			get
			{
				ReadEscSeat();
				return _hostingPublic;
			}
		}

		private static bool OnSomeoneElsesShip
		{
			get
			{
				ReadEscSeat();
				return _escGuest;
			}
		}

		private static bool InOwnSession
		{
			get
			{
				ReadEscSeat();
				return _escHost;
			}
		}

		public static bool Typing
		{
			get
			{
				if (!_typing)
				{
					return _cpListening;
				}
				return true;
			}
		}

		private static bool Open
		{
			get
			{
				try
				{
					return (Object)(object)_browser != (Object)null && _browser.IsOpen;
				}
				catch
				{
					return false;
				}
			}
		}

		private static bool OnJoinTab
		{
			get
			{
				try
				{
					GUI_ServerBrowserTab joinLobbyTab = _browser.m_JoinLobbyTab;
					if ((Object)(object)joinLobbyTab == (Object)null)
					{
						return false;
					}
					GUI_ServerBrowserTab currentlySelectedTab = _browser.CurrentlySelectedTab;
					if ((Object)(object)currentlySelectedTab != (Object)null)
					{
						return ((Il2CppObjectBase)currentlySelectedTab).Pointer == ((Il2CppObjectBase)joinLobbyTab).Pointer;
					}
					return (Object)(object)((Component)joinLobbyTab).gameObject != (Object)null && ((Component)joinLobbyTab).gameObject.activeInHierarchy;
				}
				catch
				{
					return false;
				}
			}
		}

		private static bool ModalUp
		{
			get
			{
				try
				{
					return ModalManager.ModalVisible;
				}
				catch
				{
					return false;
				}
			}
		}

		private static bool Active
		{
			get
			{
				if (Prefs.LobbyBrowser.Value && !_broken && Open)
				{
					return OnJoinTab;
				}
				return false;
			}
		}

		private static bool Drawing => Time.unscaledTime - _drawnAt < 0.5f;

		private static float MissionBodyWidth => Mathf.Round(Mathf.Max(100f * _s, _missionTextW + 14f * _s + 2f));

		private static float MissionPuckWidth => Mathf.Round(28f * _s) + MissionBodyWidth;

		private static float ShipPuckWidth => Mathf.Round(Mathf.Max(96f * _s, _shipTextW + 20f * _s + 1f));

		private static float PlayersCellWidth => Width("16/16", Body) + 8f * _s + (float)_mostSeats * 10f * _s;

		private static float JumpsCellWidth => 96f * _s + 16.5f * _s;

		private static float RegionCellWidth => 24f * _s + 6f * _s + _regionTextW + 2f;

		private static ModalRequest CurrentRequest
		{
			get
			{
				try
				{
					return ModalManager.ModalVisible ? ModalManager.CurrentModal : null;
				}
				catch
				{
					return null;
				}
			}
		}

		private static int Body => Mathf.RoundToInt(16f * _s);

		private static int Small => Mathf.RoundToInt(13f * _s);

		private static int Big => Mathf.RoundToInt(20f * _s);

		internal static bool EscOpen
		{
			get
			{
				if ((Object)(object)EscMenu != (Object)null)
				{
					return !ModalUp;
				}
				return false;
			}
		}

		private static int CpTiny => Mathf.RoundToInt(11f * _s);

		private static float CpWidth => Mathf.Round(360f * _s);

		private static float CpGap => Mathf.Round(16f * _s);

		private static bool CpBeside
		{
			get
			{
				if (Prefs.BrowserControlPanel != null && Prefs.BrowserControlPanel.Value && !_cpOff)
				{
					return _cpFits;
				}
				return false;
			}
		}

		internal static bool ListeningForKey => _cpListening;

		internal static bool CrewCardsShown
		{
			get
			{
				if (_cardsWanted && CardsMode)
				{
					return Prefs.ShowHud.Value;
				}
				return false;
			}
		}

		private static bool CardsMode
		{
			get
			{
				if (!Prefs.CrewCards.Value)
				{
					if (EscOpen)
					{
						return !_layoutEdit;
					}
					return false;
				}
				return true;
			}
		}

		internal static bool GameHudHidden { get; private set; }

		internal static Rect CrewTopRect => _crewTopRect;

		private static bool MeReady
		{
			get
			{
				if (!_meCardReadyKnown)
				{
					if (_meHasReady)
					{
						return _meReady;
					}
					return false;
				}
				return _meCardReady;
			}
		}

		private static bool MeCardUp
		{
			get
			{
				if (!_mission && _meKnown)
				{
					return Prefs.HangarCard.Value;
				}
				return false;
			}
		}

		private static bool ReadyBlockUp
		{
			get
			{
				if (_meKnown && _meMissionPicked)
				{
					return !MeReady;
				}
				return false;
			}
		}

		private static string ReadyKeyLabel
		{
			get
			{
				if (!string.IsNullOrEmpty(_meKey))
				{
					return _meKey;
				}
				return "B";
			}
		}

		private static bool OnHostTab
		{
			get
			{
				try
				{
					GUI_ServerBrowserTab currentlySelectedTab = _browser.CurrentlySelectedTab;
					if ((Object)(object)currentlySelectedTab == (Object)null)
					{
						return false;
					}
					GUI_ServerBrowserTab hostLobbyTab = _browser.m_HostLobbyTab;
					GUI_ServerBrowserTab updateLobbyTab = _browser.m_UpdateLobbyTab;
					return ((Object)(object)hostLobbyTab != (Object)null && ((Il2CppObjectBase)currentlySelectedTab).Pointer == ((Il2CppObjectBase)hostLobbyTab).Pointer) || ((Object)(object)updateLobbyTab != (Object)null && ((Il2CppObjectBase)currentlySelectedTab).Pointer == ((Il2CppObjectBase)updateLobbyTab).Pointer);
				}
				catch
				{
					return false;
				}
			}
		}

		private static bool HostActive
		{
			get
			{
				if (Prefs.LobbyBrowser.Value && !_broken && Open)
				{
					return OnHostTab;
				}
				return false;
			}
		}

		private static int CurLevelMin
		{
			get
			{
				if (_draftMin < 0)
				{
					return Prefs.HostLevelMin.Value;
				}
				return _draftMin;
			}
		}

		private static int CurLevelMax
		{
			get
			{
				if (_draftMax < 0)
				{
					return Prefs.HostLevelMax.Value;
				}
				return _draftMax;
			}
		}

		private static bool CurFriends
		{
			get
			{
				if (_draftFriends < 0)
				{
					return Prefs.HostFriendsWelcome.Value;
				}
				return _draftFriends == 1;
			}
		}

		internal static bool LayoutEditing => _layoutEdit;

		internal static bool HudClickable
		{
			get
			{
				if (EscOpen)
				{
					return !_layoutEdit;
				}
				return false;
			}
		}

		private static float GridStep => Math.Max(24f, Mathf.Round((float)Screen.height / 24f));

		internal static bool ChatPreviewing
		{
			get
			{
				if (!_layoutEdit)
				{
					if (Hud.InSession && EscOpen)
					{
						if (!_sizeDrag)
						{
							return Time.unscaledTime - _sizeTouchedAt < 3f;
						}
						return true;
					}
					return false;
				}
				return true;
			}
		}

		internal static bool ChatBoxCustom
		{
			get
			{
				if (Prefs.ChatBoxW != null && Prefs.ChatBoxW.Value > 0.02f && Prefs.ChatBoxH.Value > 0.02f && Prefs.ChatBoxX.Value >= 0f)
				{
					return Prefs.ChatBoxY.Value >= 0f;
				}
				return false;
			}
		}

		internal static Rect ChatBoxPixels
		{
			get
			{
				//IL_00ad: 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)
				if (!ChatBoxCustom)
				{
					return ChatBoxStandard();
				}
				float num = Mathf.Clamp01(Prefs.ChatBoxW.Value) * (float)Screen.width;
				float num2 = Mathf.Clamp01(Prefs.ChatBoxH.Value) * (float)Screen.height;
				float num3 = Mathf.Clamp(Prefs.ChatBoxX.Value * (float)Screen.width, 0f, Math.Max(0f, (float)Screen.width - num));
				float num4 = Mathf.Clamp(Prefs.ChatBoxY.Value * (float)Screen.height, 0f, Math.Max(0f, (float)Screen.height - num2));
				return new Rect(Mathf.Round(num3), Mathf.Round(num4), Mathf.Round(num), Mathf.Round(num2));
			}
		}

		private static bool LivePaused
		{
			get
			{
				if (!ModalUp && _join == null && _joinWait == null)
				{
					return !OnJoinTab;
				}
				return true;
			}
		}

		private static bool UpdateShown
		{
			get
			{
				if (UpdateCheck.Result == UpdateCheck.State.Newer)
				{
					return !string.IsNullOrEmpty(UpdateCheck.Latest);
				}
				return false;
			}
		}

		private static void DrawBrowseButton()
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: 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_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: 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_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			GUI_PauseMenu escMenu = EscMenu;
			if ((Object)(object)escMenu == (Object)null || ModalUp)
			{
				return;
			}
			Event current = Event.current;
			int depth = GUI.depth;
			try
			{
				_s = Mathf.Clamp((float)Screen.height / 1080f, 0.7f, 2.2f);
				_mono = false;
				_dim = 1f;
				Styles();
				GUI.depth = -2000;
				string text = (HostingPublic ? "Manage Session" : "Host Game");
				float num = Mathf.Round(40f * _s);
				float num2 = Mathf.Round(12f * _s);
				float num3 = Mathf.Round(Width("Browse lobbies", Body, bold: true) + 44f * _s);
				float num4 = Mathf.Round(Width(text, Body, bold: true) + 44f * _s);
				if (Time.unscaledTime >= _gapNext)
				{
					_gapCache = MenuGap(escMenu);
					_gapNext = Time.unscaledTime + 0.5f;
				}
				float? gapCache = _gapCache;
				float num5 = (gapCache.HasValue ? gapCache.Value : ((float)Screen.height * 0.588f));
				float num6 = ((float)Screen.width - (num3 + num2 + num4)) / 2f;
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(Mathf.Round(num6), Mathf.Round(num5 - num / 2f), num3, num);
				bool flag = ((Rect)(ref val)).Contains(current.mousePosition);
				Round(val, Color.black, 0.88f, 10f);
				Round(val, Green, flag ? 0.2f : 0.1f, 10f);
				RoundLine2(val, Green, flag ? 0.9f : 0.55f, 10f);
				float num7 = ((Rect)(ref val)).x + (num3 - Width("Browse lobbies", Body, bold: true)) / 2f;
				TextAt(num7 + 1f, ((Rect)(ref val)).center.y - 0.6f * _s, "Browse lobbies", Body, Green, 0.55f, bold: true);
				TextAt(num7, ((Rect)(ref val)).center.y - 0.6f * _s, "Browse lobbies", Body, Green, 1f, bold: true);
				if (GUI.Button(val, GUIContent.none, _invisible))
				{
					BrowseFromMenu(escMenu);
				}
				Rect val2 = default(Rect);
				((Rect)(ref val2))..ctor(((Rect)(ref val)).xMax + num2, ((Rect)(ref val)).y, num4, num);
				float num8 = ((Rect)(ref val2)).x + (num4 - Width(text, Body, bold: true)) / 2f;
				if (OnSomeoneElsesShip)
				{
					Round(val2, ToggleOff, 1f, 10f);
					RoundLine(val2, ToggleOffLine, 1f, 10f);
					TextAt(num8 + 1f, ((Rect)(ref val2)).center.y - 0.6f * _s, text, Body, Grey, 0.55f, bold: true);
					TextAt(num8, ((Rect)(ref val2)).center.y - 0.6f * _s, text, Body, Grey, 1f, bold: true);
				}
				else
				{
					bool flag2 = ((Rect)(ref val2)).Contains(current.mousePosition);
					Round(val2, Color.black, 0.88f, 10f);
					Round(val2, Green, flag2 ? 0.2f : 0.1f, 10f);
					RoundLine2(val2, Green, flag2 ? 0.9f : 0.55f, 10f);
					TextAt(num8 + 1f, ((Rect)(ref val2)).center.y - 0.6f * _s, text, Body, Green, 0.55f, bold: true);
					TextAt(num8, ((Rect)(ref val2)).center.y - 0.6f * _s, text, Body, Green, 1f, bold: true);
					if (GUI.Button(val2, GUIContent.none, _invisible))
					{
						HostFromMenu(escMenu);
					}
				}
				if (!_escLogged)
				{
					_escLogged = true;
					MelonLogger.Msg($"[browser] Esc menu: \"Browse lobbies\" at {val}, \"{text}\" beside it ({(gapCache.HasValue ? "in the measured gap" : "at the fallback height")}; {_gapNote})");
				}
			}
			catch (Exception ex)
			{
				if (!_escWarned)
				{
					_escWarned = true;
					MelonLogger.Warning("[browser] could not draw Browse lobbies: " + ex.Message);
				}
			}
			finally
			{
				GUI.depth = depth;
			}
		}

		private static void HostFromMenu(GUI_PauseMenu pm)
		{
			try
			{
				GUI_ServerBrowser serverBrowser = pm.m_ServerBrowser;
				if ((Object)(object)serverBrowser == (Object)null)
				{
					MelonLogger.Warning("[browser] Host Game: the Esc menu has no lobby screen");
					return;
				}
				pm.OpenServerBrowser();
				_browser = serverBrowser;
				MelonLogger.Msg($"[browser] {(HostingPublic ? "Manage Session" : "Host Game")} from the Esc menu: V2T's host popup: {OnHostTab}");
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[browser] Host Game failed: " + ex.Message);
			}
		}

		private static void ReadEscSeat()
		{
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime - _hostingReadAt < 0.25f)
			{
				return;
			}
			_hostingReadAt = unscaledTime;
			_hostingPublic = false;
			_escGuest = false;
			_escHost = false;
			try
			{
				JoinSeat joinSeat = ChatBridge.Seat();
				TextChatManager manager = ChatBridge.Manager;
				bool? obj;
				if (manager == null)
				{
					obj = null;
				}
				else
				{
					NetworkSessionData networkSessionData = ((NetworkedObject_Base)manager).m_NetworkSessionData;
					obj = ((networkSessionData == null) ? ((bool?)null) : ((ReactiveProperty<bool>)(object)networkSessionData.m_IsSessionPublic)?.Value);
				}
				bool? flag = obj;
				bool valueOrDefault = flag == true;
				_escGuest = joinSeat == JoinSeat.Guest;
				_escHost = joinSeat == JoinSeat.Host;
				_hostingPublic = joinSeat == JoinSeat.Host && BrowserModel.HostModeOf(mainMenu: false, joinSeat, valueOrDefault) == HostMode.Public;
			}
			catch
			{
			}
		}

		private static float? MenuGap(GUI_PauseMenu pm)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Il2CppArrayBase<Selectable> componentsInChildren = ((Component)pm).gameObject.GetComponentsInChildren<Selectable>(false);
				if (componentsInChildren == null || componentsInChildren.Length < 2)
				{
					_gapNote = "no buttons found";
					return null;
				}
				List<(float, float)> list = new List<(float, float)>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Selectable val = componentsInChildren[i];
					if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy)
					{
						continue;
					}
					Rect? val2 = ScreenRect(((Component)val).GetComponent<RectTransform>(), ((Component)val).gameObject);
					if (!val2.HasValue)
					{
						continue;
					}
					Rect value = val2.Value;
					if (((Rect)(ref value)).height > 4f)
					{
						value = val2.Value;
						if (((Rect)(ref value)).height < (float)Screen.height * 0.2f)
						{
							value = val2.Value;
							float yMin = ((Rect)(ref value)).yMin;
							value = val2.Value;
							list.Add((yMin, ((Rect)(ref value)).yMax));
						}
					}
				}
				list.Sort(((float Top, float Bottom) p, (float Top, float Bottom) q) => p.Top.CompareTo(q.Top));
				float num = 0f;
				float value2 = 0f;
				float num2 = float.MinValue;
				foreach (var item in list)
				{
					if (num2 > float.MinValue && item.Item1 - num2 > num)
					{
						float num3 = (num2 + item.Item1) / 2f;
						if (num3 > (float)Screen.height * 0.3f && num3 < (float)Screen.height * 0.8f)
						{
							num = item.Item1 - num2;
							value2 = num3;
						}
					}
					num2 = Math.Max(num2, item.Item2);
				}
				_gapNote = $"{list.Count} buttons, widest gap {num:F0} px";
				return (num > 20f) ? new float?(value2) : ((float?)null);
			}
			catch (Exception ex)
			{
				_gapNote = "measuring failed: " + ex.Message;
				return null;
			}
		}

		private static Rect? ScreenRect(RectTransform rt, GameObject go)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_0081: 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_0071: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rt == (Object)null)
			{
				return null;
			}
			Canvas componentInParent = go.GetComponentInParent<Canvas>();
			Il2CppStructArray<Vector3> val = new Il2CppStructArray<Vector3>(4L);
			rt.GetWorldCorners(val);
			Camera val2 = (((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0) ? componentInParent.worldCamera : null);
			float num = float.MaxValue;
			float num2 = float.MinValue;
			float num3 = float.MaxValue;
			float num4 = float.MinValue;
			for (int i = 0; i < 4; i++)
			{
				Vector3 val3 = (((Object)(object)val2 != (Object)null) ? Vector2.op_Implicit(RectTransformUtility.WorldToScreenPoint(val2, ((Il2CppArrayBase<Vector3>)(object)val)[i])) : ((Il2CppArrayBase<Vector3>)(object)val)[i]);
				num = Math.Min(num, val3.x);
				num2 = Math.Max(num2, val3.x);
				num3 = Math.Min(num3, val3.y);
				num4 = Math.Max(num4, val3.y);
			}
			return new Rect(num, (float)Screen.height - num4, num2 - num, num4 - num3);
		}

		private static Rect? MenuPanelRect(GUI_PauseMenu pm)
		{
			//IL_006a: 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_00bb: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject menuParent = pm.m_MenuParent;
				if ((Object)(object)menuParent == (Object)null || !menuParent.activeInHierarchy)
				{
					return null;
				}
				RectTransform component = menuParent.GetComponent<RectTransform>();
				if ((Object)(object)component == (Object)null)
				{
					return null;
				}
				Canvas componentInParent = menuParent.GetComponentInParent<Canvas>();
				Il2CppStructArray<Vector3> val = new Il2CppStructArray<Vector3>(4L);
				component.GetWorldCorners(val);
				Camera val2 = (((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0) ? componentInParent.worldCamera : null);
				float num = float.MaxValue;
				float num2 = float.MinValue;
				float num3 = float.MaxValue;
				float num4 = float.MinValue;
				for (int i = 0; i < 4; i++)
				{
					Vector3 val3 = (((Object)(object)val2 != (Object)null) ? Vector2.op_Implicit(RectTransformUtility.WorldToScreenPoint(val2, ((Il2CppArrayBase<Vector3>)(object)val)[i])) : ((Il2CppArrayBase<Vector3>)(object)val)[i]);
					num = Math.Min(num, val3.x);
					num2 = Math.Max(num2, val3.x);
					num3 = Math.Min(num3, val3.y);
					num4 = Math.Max(num4, val3.y);
				}
				if (num2 - num < 20f || num4 - num3 < 20f)
				{
					return null;
				}
				return new Rect(num, (float)Screen.height - num4, num2 - num, num4 - num3);
			}
			catch
			{
				return null;
			}
		}

		private static void BrowseFromMenu(GUI_PauseMenu pm)
		{
			try
			{
				GUI_ServerBrowser serverBrowser = pm.m_ServerBrowser;
				if ((Object)(object)serverBrowser == (Object)null)
				{
					MelonLogger.Warning("[browser] Browse lobbies: the Esc menu has no lobby screen");
					return;
				}
				pm.OpenServerBrowser();
				_browser = serverBrowser;
				if (!ShowListTab(serverBrowser, out var wasShown))
				{
					MelonLogger.Warning("[browser] Browse lobbies: the lobby screen has no list tab");
					return;
				}
				MelonLogger.Msg($"[browser] Browse lobbies from the Esc menu: list tab {(wasShown ? "was there" : "was hidden, shown")}, now on the list: {OnJoinTab}");
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[browser] Browse lobbies failed: " + ex.Message);
			}
		}

		private static void LoadFilters()
		{
			if (_filtersLoaded)
			{
				return;
			}
			_filtersLoaded = true;
			try
			{
				int val = Math.Max(0, Math.Min(10, Prefs.BrowserThreatMin.Value));
				int val2 = Math.Max(0, Math.Min(10, Prefs.BrowserThreatMax.Value));
				Filter.ThreatMin = Math.Min(val, val2);
				Filter.ThreatMax = Math.Max(val, val2);
				Filter.HiddenRegions.Clear();
				foreach (string item in BrowserModel.ParseHidden(Prefs.BrowserHiddenRegions.Value))
				{
					Filter.HiddenRegions.Add(item);
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[browser] could not read the saved filters: " + ex.Message);
			}
		}

		private static void SaveFilters()
		{
			try
			{
				Prefs.BrowserThreatMin.Value = Filter.ThreatMin;
				Prefs.BrowserThreatMax.Value = Filter.ThreatMax;
				Prefs.BrowserHiddenRegions.Value = BrowserModel.HiddenText(Filter.HiddenRegions);
				MelonPreferences.Save();
			}
			catch
			{
			}
		}

		private static string RegionLabel(string code)
		{
			if (!_regionNames.TryGetValue(code, out var value) || string.IsNullOrWhiteSpace(value))
			{
				return BrowserModel.RegionName(code);
			}
			return value;
		}

		private static Color LevelColour(int v)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (v <= 0)
			{
				return Green;
			}
			if (!_threatSeen.TryGetValue(v, out var value))
			{
				return ThreatScale[Mathf.Clamp(v - 1, 0, ThreatScale.Length - 1)];
			}
			return value;
		}

		private static void NoteRowLooks(LobbyInfo l)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(l.RegionCode) && !string.IsNullOrWhiteSpace(l.RegionText) && !string.Equals(l.RegionText, l.RegionCode, StringComparison.OrdinalIgnoreCase))
			{
				_regionNames[l.RegionCode] = l.RegionText;
			}
			if (l.ThreatR >= 0f && l.Threat > 0)
			{
				_threatSeen[l.Threat] = new Color(l.ThreatR, l.ThreatG, l.ThreatB);
			}
		}

		private static float DrawThreatRange(float right, float y, float h, Event e)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Invalid comparison between Unknown and I4
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Invalid comparison between Unknown and I4
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			int num = 10;
			float num2 = Mathf.Round(12f * _s);
			float num3 = Mathf.Round(14f * _s);
			float num4 = Mathf.Max(1f, Mathf.Round(2f * _s));
			float num5 = (float)(num + 1) * num2 + (float)num * num4;
			float num6 = Width("Threat", Small);
			Width("10–10", Small, bold: true);
			float num7 = 10f * _s;
			float num8 = 9f * _s;
			float num9 = ThreatRangeWidth();
			Rect r = default(Rect);
			((Rect)(ref r))..ctor(Mathf.Round(right - num9), y, num9, h);
			Vector2 mousePosition = e.mousePosition;
			RoundLine(r, Green, Filter.ThreatAll ? 0.35f : 0.9f, 7f);
			float num10 = ((Rect)(ref r)).x + num7;
			_threatLabel = new Rect(num10 - 4f * _s, y, num6 + 8f * _s, h);
			bool flag = !Filter.ThreatAll && ((Rect)(ref _threatLabel)).Contains(mousePosition);
			Text(new Rect(num10, y, num6 + 2f, h), "Threat", Small, (Color)(flag ? Ink : new Color(0.62f, 0.69f, 0.64f)), 1f, bold: false, (TextAnchor)3);
			float num11 = num10 + num6 + num8;
			float num12 = Mathf.Round(y + (h - num3) / 2f);
			_threatTrack = new Rect(num11 - num4, y, num5 + 2f * num4, h);
			_cellStep = num2 + num4;
			Rect r2 = default(Rect);
			for (int i = 0; i <= num; i++)
			{
				((Rect)(ref r2))..ctor(Mathf.Round(num11 + (float)i * (num2 + num4)), num12, num2, num3);
				bool flag2 = i >= Filter.ThreatMin && i <= Filter.ThreatMax;
				Round(r2, flag2 ? LevelColour(i) : Empty, 1f, 2f);
				if (!Filter.ThreatAll && (i == Filter.ThreatMin || i == Filter.ThreatMax))
				{
					float num13 = Mathf.Round(2f * _s);
					RoundLine2(new Rect(((Rect)(ref r2)).x - num13, ((Rect)(ref r2)).y - num13, ((Rect)(ref r2)).width + num13 * 2f, ((Rect)(ref r2)).height + num13 * 2f), Ink, 1f, 3f);
				}
			}
			string text = (Filter.ThreatAll ? "Any" : ((Filter.ThreatMin == Filter.ThreatMax) ? Filter.ThreatMin.ToString() : $"{Filter.ThreatMin}–{Filter.ThreatMax}"));
			TextAt(num11 + num5 + num8, y + h / 2f, text, Small, Filter.ThreatAll ? Grey : Ink, 1f, bold: true);
			if ((int)e.type == 0 && e.button == 0)
			{
				if (((Rect)(ref _threatTrack)).Contains(mousePosition))
				{
					int v = CellAt(mousePosition.x, num11);
					_dragHigh = BrowserModel.GrabsHigh(Filter.ThreatMin, Filter.ThreatMax, v);
					BrowserModel.MoveEnd(Filter, _dragHigh, v);
					_threatDrag = true;
					_scroll = 0f;
					Arrange();
					e.Use();
				}
				else if (flag)
				{
					Filter.ThreatMin = 0;
					Filter.ThreatMax = num;
					_scroll = 0f;
					Arrange();
					SaveFilters();
					e.Use();
				}
			}
			else if ((int)e.type == 3 && _threatDrag)
			{
				int v2 = CellAt(mousePosition.x, num11);
				int num14 = (_dragHigh ? Filter.ThreatMax : Filter.ThreatMin);
				BrowserModel.MoveEnd(Filter, _dragHigh, v2);
				if ((_dragHigh ? Filter.ThreatMax : Filter.ThreatMin) != num14)
				{
					Arrange();
				}
				e.Use();
			}
			else if ((int)e.type == 1 && _threatDrag)
			{
				_threatDrag = false;
				SaveFilters();
				e.Use();
			}
			return ((Rect)(ref r)).x;
		}

		private static float ThreatRangeWidth()
		{
			int num = 10;
			float num2 = Mathf.Round(12f * _s);
			float num3 = Mathf.Max(1f, Mathf.Round(2f * _s));
			float num4 = (float)(num + 1) * num2 + (float)num * num3;
			float num5 = Width("Threat", Small);
			float num6 = Width("10–10", Small, bold: true);
			float num7 = 10f * _s;
			float num8 = 9f * _s;
			return Mathf.Round(num7 + num5 + num8 + num4 + num8 + num6 + num7);
		}

		private static int CellAt(float mx, float trackX)
		{
			return Mathf.Clamp(Mathf.FloorToInt((mx - trackX) / Mathf.Max(1f, _cellStep)), 0, 10);
		}

		private static float DrawRegionsButton(float right, float y, float h, Event e)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_0102: 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_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: 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_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			int count = BrowserModel.MenuRegions().Count;
			int count2 = Filter.HiddenRegions.Count;
			string text = ((count2 == 0) ? "Regions: All" : $"Regions: {count - count2} of {count}");
			float num = 8f * _s;
			float num2 = Mathf.Round(Width(text, Small) + 22f * _s + num + 6f * _s);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(Mathf.Round(right - num2), y, num2, h);
			_regionsButton = val;
			bool flag = _regionsOpen || count2 > 0;
			bool flag2 = ((Rect)(ref val)).Contains(e.mousePosition);
			if (flag)
			{
				Round(val, Green, _regionsOpen ? 0.22f : 0.14f, 7f);
			}
			else if (flag2)
			{
				Round(val, Green, 0.07f, 7f);
			}
			RoundLine(val, Green, flag ? 1f : 0.35f, 7f);
			Color c = (Color)(flag ? Green : new Color(0.62f, 0.69f, 0.64f));
			Text(new Rect(((Rect)(ref val)).x + 11f * _s, y, num2, h), text, Small, c, 1f, bold: false, (TextAnchor)3);
			Icon(new Rect(((Rect)(ref val)).xMax - 11f * _s - num, y + (h - num) / 2f, num, num), _regionsOpen ? TriUp : TriDown, c, 1f);
			if ((int)e.type == 0 && e.button == 0 && flag2)
			{
				_regionsOpen = !_regionsOpen;
				e.Use();
			}
			return ((Rect)(ref val)).x;
		}

		private static void MenuInput(Event e)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (!_regionsOpen)
			{
				return;
			}
			if ((int)e.type == 4 && (int)e.keyCode == 27)
			{
				_regionsOpen = false;
				e.Use();
			}
			else if ((int)e.type == 6 && ((Rect)(ref _regionsMenu)).Contains(e.mousePosition))
			{
				e.Use();
			}
			else
			{
				if ((int)e.type != 0)
				{
					return;
				}
				Vector2 mousePosition = e.mousePosition;
				if (((Rect)(ref _regionsButton)).Contains(mousePosition))
				{
					return;
				}
				if (((Rect)(ref _regionsMenu)).Contains(mousePosition))
				{
					foreach (var menuHit in _menuHits)
					{
						var (val, _, _, _) = menuHit;
						if (((Rect)(ref val)).Contains(mousePosition))
						{
							ApplyMenu(menuHit.Kind, menuHit.Index, menuHit.Code);
							break;
						}
					}
					e.Use();
				}
				else
				{
					_regionsOpen = false;
					e.Use();
				}
			}
		}

		private static void ApplyMenu(int kind, int index, string code)
		{
			switch (kind)
			{
			case 0:
				if (!Filter.HiddenRegions.Remove(code))
				{
					Filter.HiddenRegions.Add(code);
				}
				break;
			case 1:
				BrowserModel.ToggleContinent(Filter, BrowserModel.Continents[index].Codes);
				break;
			case 2:
				Filter.HiddenRegions.Clear();
				break;
			case 3:
				foreach (string item in BrowserModel.MenuRegions())
				{
					Filter.HiddenRegions.Add(item);
				}
				break;
			case 4:
				BrowserModel.KeepGoodPing(Filter, RegionPing.Get);
				break;
			}
			_scroll = 0f;
			Arrange();
			SaveFilters();
		}

		private static void DrawRegionsMenu(Rect panel)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0915: Unknown result type (might be due to invalid IL or missing references)
			//IL_0926: Unknown result type (might be due to invalid IL or missing references)
			//IL_0937: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_058e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_065b: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_072d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0726: Unknown result type (might be due to invalid IL or missing references)
			//IL_075f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Unknown result type (might be due to invalid IL or missing references)
			//IL_0764: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07de: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0849: Unknown result type (might be due to invalid IL or missing references)
			//IL_085f: Unknown result type (might be due to invalid IL or missing references)
			_menuHits.Clear();
			if (!_regionsOpen)
			{
				_regionsMenu = default(Rect);
				return;
			}
			(string, string[])[] continents = BrowserModel.Continents;
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			foreach (LobbyInfo item4 in _all)
			{
				if (!string.IsNullOrEmpty(item4.RegionCode))
				{
					dictionary[item4.RegionCode] = ((!dictionary.TryGetValue(item4.RegionCode, out var value)) ? 1 : (value + 1));
				}
			}
			float num = Mathf.Round(26f * _s);
			float num2 = Mathf.Round(14f * _s);
			float num3 = 8f * _s;
			float num4 = 0f;
			(string, string[])[] array = continents;
			for (int i = 0; i < array.Length; i++)
			{
				(string, string[]) tuple = array[i];
				num4 = Mathf.Max(num4, Width(tuple.Item1, Small, bold: true) - 30f * _s);
				string[] item = tuple.Item2;
				foreach (string code in item)
				{
					num4 = Mathf.Max(num4, Width(RegionLabel(code), Small));
				}
			}
			float num5 = 16f * _s + 6f * _s;
			float num6 = Width("99", Small);
			float num7 = 10f * _s;
			float num8 = Mathf.Round(num7 + num + num3 + num4 + num3 + num5 + num3 + num6 + num7);
			float num9 = Mathf.Round(26f * _s);
			float num10 = Mathf.Round(30f * _s);
			float num11 = 16f * _s;
			float num12 = 12f * _s;
			float num13 = 14f * _s;
			int num14 = 3;
			int num15 = (continents.Length + num14 - 1) / num14;
			float[] array2 = new float[num15];
			for (int k = 0; k < continents.Length; k++)
			{
				array2[k / num14] = Mathf.Max(array2[k / num14], num10 + (float)continents[k].Item2.Length * num9 + 6f * _s);
			}
			float num16 = Mathf.Round(24f * _s);
			float num17 = num13 * 2f + (float)num14 * num8 + (float)(num14 - 1) * num11;
			float num18 = num13 * 2f + num16;
			float[] array3 = array2;
			foreach (float num19 in array3)
			{
				num18 += num19 + num12;
			}
			float num20 = Mathf.Clamp(((Rect)(ref _regionsButton)).xMax - num17, ((Rect)(ref panel)).x + 8f * _s, ((Rect)(ref panel)).xMax - num17 - 8f * _s);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(Mathf.Round(num20), Mathf.Round(((Rect)(ref _regionsButton)).yMax + 6f * _s), Mathf.Round(num17), Mathf.Round(num18));
			_regionsMenu = val;
			Fill(new Rect(((Rect)(ref val)).x + 4f * _s, ((Rect)(ref val)).y + 8f * _s, ((Rect)(ref val)).width, ((Rect)(ref val)).height), Color.black, 0.35f);
			Round(val, new Color(0.02f, 0.04f, 0.05f), 0.99f, 14f);
			RoundLine(val, Green, 0.6f, 14f);
			Vector2 mousePosition = Event.current.mousePosition;
			float num21 = ((Rect)(ref val)).y + num13;
			Rect r = default(Rect);
			Rect val2 = default(Rect);
			Rect item3 = default(Rect);
			for (int l = 0; l < num15; l++)
			{
				for (int m = 0; m < num14; m++)
				{
					int num22 = l * num14 + m;
					if (num22 >= continents.Length)
					{
						break;
					}
					(string, string[]) tuple2 = continents[num22];
					((Rect)(ref r))..ctor(((Rect)(ref val)).x + num13 + (float)m * (num8 + num11), num21, num8, array2[l]);
					Round(r, Color.white, 0.035f, 10f);
					int num23 = 0;
					string[] item = tuple2.Item2;
					foreach (string item2 in item)
					{
						if (!Filter.HiddenRegions.Contains(item2))
						{
							num23++;
						}
					}
					((Rect)(ref val2))..ctor(((Rect)(ref r)).x, ((Rect)(ref r)).y, ((Rect)(ref r)).width, num10);
					if (((Rect)(ref val2)).Contains(mousePosition))
					{
						Round(val2, Green, 0.06f, 10f);
					}
					float num24 = ((Rect)(ref val2)).y + num10 / 2f;
					Switch(new Rect(((Rect)(ref r)).x + num7, Mathf.Round(num24 - num2 / 2f), num, num2), num23 == tuple2.Item2.Length, num23 > 0 && num23 < tuple2.Item2.Length);
					TextAt(((Rect)(ref r)).x + num7 + num + num3, num24, tuple2.Item1, Small, Green, 1f, bold: true);
					string text = $"{num23}/{tuple2.Item2.Length}";
					TextAt(((Rect)(ref r)).xMax - num7 - Width(text, Small), num24, text, Small, Grey, 1f);
					Fill(new Rect(((Rect)(ref r)).x + num7, ((Rect)(ref val2)).yMax - 1f, ((Rect)(ref r)).width - num7 * 2f, Mathf.Max(1f, _s)), Green, 0.18f);
					_menuHits.Add((val2, 1, num22, null));
					for (int n = 0; n < tuple2.Item2.Length; n++)
					{
						string text2 = tuple2.Item2[n];
						bool flag = !Filter.HiddenRegions.Contains(text2);
						((Rect)(ref item3))..ctor(((Rect)(ref r)).x, ((Rect)(ref val2)).yMax + 3f * _s + (float)n * num9, ((Rect)(ref r)).width, num9);
						if (((Rect)(ref item3)).Contains(mousePosition))
						{
							Round(new Rect(((Rect)(ref item3)).x + 4f * _s, ((Rect)(ref item3)).y + 1f, ((Rect)(ref item3)).width - 8f * _s, ((Rect)(ref item3)).height - 2f), Green, 0.06f, 6f);
						}
						float num25 = ((Rect)(ref item3)).y + num9 / 2f;
						Switch(new Rect(((Rect)(ref r)).x + num7, Mathf.Round(num25 - num2 / 2f), num, num2), flag, some: false);
						float num26 = ((Rect)(ref r)).x + num7 + num + num3;
						TextAt(num26, num25, Fit(RegionLabel(text2), Small, bold: false, num4), Small, flag ? Ink : Grey, 1f);
						int num27 = BrowserModel.PingTier(RegionPing.Get(text2));
						Color val3 = ((num27 < 0) ? Grey : Tier[num27]);
						int num28 = ((num27 >= 0) ? (4 - num27) : 0);
						float num29 = num26 + num4 + num3;
						float num30 = num25 + 7f * _s;
						for (int num31 = 0; num31 < 4; num31++)
						{
							float num32 = (5f + (float)num31 * 3f) * _s;
							Fill(new Rect(num29 + (float)num31 * 6f * _s, num30 - num32, 4f * _s, num32), (num31 < num28) ? val3 : Empty, flag ? 1f : 0.45f);
						}
						int value2;
						int num33 = (dictionary.TryGetValue(text2, out value2) ? value2 : 0);
						string text3 = ((num33 > 0) ? num33.ToString() : "–");
						TextAt(((Rect)(ref r)).xMax - num7 - Width(text3, Small), num25, text3, Small, Grey, 1f);
						_menuHits.Add((item3, 0, num22, text2));
					}
				}
				num21 += array2[l] + num12;
			}
			float y = num21;
			float x = ((Rect)(ref val)).x + num13;
			float h = num16;
			Fill(new Rect(((Rect)(ref val)).x + num13, num21 - num12 / 2f, ((Rect)(ref val)).width - num13 * 2f, Mathf.Max(1f, _s)), Green, 0.15f);
			MenuButton(MenuButton(MenuButton(x, y, h, "All", 2, mousePosition), y, h, "None", 3, mousePosition), y, h, "Good ping only", 4, mousePosition);
		}

		private static float MenuButton(float x, float y, float h, string label, int kind, Vector2 mouse)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Round(Width(label, Small) + 20f * _s);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(x, y, num, h);
			bool flag = ((Rect)(ref val)).Contains(mouse);
			if (flag)
			{
				Round(val, Green, 0.1f, 7f);
			}
			RoundLine(val, Green, flag ? 0.8f : 0.3f, 7f);
			Text(val, label, Small, (Color)(flag ? Green : new Color(0.62f, 0.69f, 0.64f)), 1f, bold: false, (TextAnchor)4);
			_menuHits.Add((val, kind, -1, null));
			return x + num + 8f * _s;
		}

		private static void Switch(Rect r, bool on, bool some)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			float radius = ((Rect)(ref r)).height / 2f / _s;
			Round(r, (on || some) ? Green : Empty, on ? 0.35f : (some ? 0.18f : 1f), radius);
			float num = ((Rect)(ref r)).height - 4f * _s;
			Round(new Rect(on ? (((Rect)(ref r)).xMax - 2f * _s - num) : (some ? (((Rect)(ref r)).center.x - num / 2f) : (((Rect)(ref r)).x + 2f * _s)), ((Rect)(ref r)).y + 2f * _s, num, num), (Color)(on ? Green : (some ? new Color(0.25f, 1f, 0.4f, 0.7f) : Grey)), 1f, num / 2f / _s);
		}

		public static void Tick()
		{
			JoinTick();
			MenuTick();
			if (!Open)
			{
				if (_wasOpen)
				{
					_wasOpen = false;
					_typing = false;
					_unsubscribed = false;
					_searchFocus = false;
					_regionsOpen = false;
					_threatDrag = false;
					_hostFocus = 0;
				}
				return;
			}
			if (!_wasOpen)
			{
				_wasOpen = true;
				_scroll = 0f;
				_nextSnapshot = 0f;
				if (Prefs.LobbyBrowser.Value)
				{
					RegionPing.Start();
					FriendLobbies.Refresh();
				}
				if (!_logged)
				{
					_logged = true;
					LogLayout();
				}
				LoadFilters();
				_appliedSig = null;
				DropAccessDraft();
				LiveOpened();
			}
			if (!Prefs.LobbyBrowser.Value)
			{
				return;
			}
			HostTick();
			RegionPing.Tick();
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime >= _nextSnapshot)
			{
				_nextSnapshot = unscaledTime + 0.3f;
				Snapshot();
			}
			LiveTick(unscaledTime);
			JoinWaitTick(unscaledTime);
			bool flag = (Active && _searchFocus) || (HostActive && _hostFocus != 0);
			if (flag && !_unsubscribed)
			{
				try
				{
					_browser.UnsubscribeToInputEvents();
					_unsubscribed = true;
				}
				catch
				{
				}
			}
			else if (!flag && _unsubscribed)
			{
				try
				{
					_browser.SubscribeToInputEvents();
				}
				catch
				{
				}
				_unsubscribed = false;
			}
			_typing = flag;
		}

		public static void LateTick()
		{
			bool flag = (Active || HostActive) && (Drawing || ModalUp);
			try
			{
				if (flag)
				{
					Hide();
				}
				else if (_hiding)
				{
					Unhide();
				}
				DialogLateTick();
			}
			catch (Exception ex)
			{
				if (!_warned)
				{
					_warned = true;
					MelonLogger.Warning("[browser] could not hide the game's lobby list: " + ex.Message);
				}
			}
		}

		private static void Hide()
		{
			GameObject gameObject = ((Component)_browser).gameObject;
			if ((Object)(object)_group == (Object)null || (Object)(object)((Component)_group).gameObject == (Object)null || ((Il2CppObjectBase)((Component)_group).gameObject).Pointer != ((Il2CppObjectBase)gameObject).Pointer)
			{
				_group = gameObject.GetComponent<CanvasGroup>();
				_groupAdded = (Object)(object)_group == (Object)null;
				if (_groupAdded)
				{
					_group = gameObject.AddComponent<CanvasGroup>();
				}
				Canvas componentInParent = gameObject.GetComponentInParent<Canvas>();
				Canvas val = (((Object)(object)componentInParent != (Object)null) ? componentInParent.rootCanvas : null);
				_raycaster = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<GraphicRaycaster>() : null);
				if ((Object)(object)_raycaster != (Object)null)
				{
					_raycasterWasOn = ((Behaviour)_raycaster).enabled;
				}
			}
			_group.alpha = 0f;
			_group.interactable = false;
			_group.blocksRaycasts = false;
			if ((Object)(object)_raycaster != (Object)null)
			{
				((Behaviour)_raycaster).enabled = false;
			}
			_hiding = true;
		}

		private static void Unhide()
		{
			_hiding = false;
			if ((Object)(object)_group != (Object)null)
			{
				_group.alpha = 1f;
				_group.interactable = true;
				_group.blocksRaycasts = true;
			}
			if ((Object)(object)_raycaster != (Object)null)
			{
				((Behaviour)_raycaster).enabled = _raycasterWasOn;
			}
		}

		private static void Snapshot()
		{
			List<LobbyInfo> list = new List<LobbyInfo>();
			bool flag = false;
			try
			{
				List<GUI_ServerListEntry> entryList = _browser.m_EntryList;
				IReadOnlyList<GUI_ServerListEntry> val = ((entryList != null) ? ((Il2CppObjectBase)entryList).TryCast<IReadOnlyList<GUI_ServerListEntry>>() : null);
				int num = ((entryList != null) ? ((Il2CppObjectBase)entryList).TryCast<IReadOnlyCollection<GUI_ServerListEntry>>() : null)?.Count ?? 0;
				string localKey = VoicePeers.LocalKey;
				DateTime utcNow = DateTime.UtcNow;
				List<LobbyInfo> list2 = new List<LobbyInfo>();
				RowById.Clear();
				for (int i = 0; i < num; i++)
				{
					GUI_ServerListEntry val2 = val[i];
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					LobbyInfo lobbyInfo = Read(val2, localKey, utcNow);
					if (lobbyInfo != null)
					{
						list2.Add(lobbyInfo);
						NoteRowLooks(lobbyInfo);
						if (!string.IsNullOrEmpty(lobbyInfo.Id))
						{
							RowById[lobbyInfo.Id] = val2;
						}
					}
				}
				flag = ReadItems(list, localKey, utcNow);
				if (!flag)
				{
					list.AddRange(list2);
					AddOwn(list, localKey, utcNow);
				}
			}
			catch (Exception ex)
			{
				if (!_warned)
				{
					_warned = true;
					MelonLogger.Warning("[browser] could not read the lobby list: " + ex.Message);
				}
			}
			if (list.Count == 0 && _pending && _all.Count > 0)
			{
				return;
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			List<LobbyInfo> list3 = new List<LobbyInfo>(list.Count);
			foreach (LobbyInfo item in list)
			{
				if (string.IsNullOrEmpty(item.Id))
				{
					list3.Add(item);
					continue;
				}
				if (dictionary.TryGetValue(item.Id, out var value))
				{
					list3[value] = item;
					continue;
				}
				dictionary[item.Id] = list3.Count;
				list3.Add(item);
			}
			if (list3.Count != list.Count && list3.Count != _dupesLoggedAt)
			{
				_dupesLoggedAt = list3.Count;
				MelonLogger.Msg($"[browser] the game's list holds {list.Count - list3.Count} lobbies twice - shown once");
			}
			list = list3;
			NoteChanges(list, flag);
			_all = list;
			_listVersion++;
			if (!_sampled && list.Count > 0)
			{
				_sampled = true;
				LogSample();
			}
			_longestRun = 0;
			foreach (LobbyInfo item2 in list)
			{
				_longestRun = Math.Max(_longestRun, item2.Jumps);
			}
			Arrange(Prefs.BrowserLive.Value && !_resortNext);
			_resortNext = false;
		}

		private static void AddOwn(List<LobbyInfo> list, string me, DateTime nowUtc)
		{
			try
			{
				OnlineSessionListData data = _browser.m_Data;
				ReactiveCollection<IOnlineSession> val = ((data != null) ? data.m_Items : null);
				if (val == null)
				{
					return;
				}
				string text = null;
				try
				{
					NetworkSessionData networkSessionData = _browser.m_NetworkSessionData;
					text = ((networkSessionData == null) ? null : ((ReactiveProperty<string>)(object)networkSessionData.m_SessionId)?.Value);
				}
				catch
				{
				}
				int count = ((Collection<IOnlineSession>)(object)val).Count;
				for (int i = 0; i < count; i++)
				{
					IOnlineSession obj2 = ((Collection<IOnlineSession>)(object)val)[i];
					EpicSession val2 = ((obj2 != null) ? ((Il2CppObjectBase)obj2).TryCast<EpicSession>() : null);
					if (val2 == null)
					{
						continue;
					}
					string id = val2.Id ?? "";
					string a = val2.OwnerId ?? "";
					if (((!string.IsNullOrEmpty(text) && string.Equals(id, text, StringComparison.OrdinalIgnoreCase)) || (!string.IsNullOrEmpty(me) && string.Equals(a, me, StringComparison.OrdinalIgnoreCase))) && !list.Exists((LobbyInfo x) => string.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase)))
					{
						LobbyInfo lobbyInfo = FromSession(val2);
						lobbyInfo.Full = lobbyInfo.MaxPlayers > 0 && lobbyInfo.Players >= lobbyInfo.MaxPlayers;
						lobbyInfo.RegionText = RegionLabel(lobbyInfo.RegionCode);
						string currentSpaceShipAssetGuid = val2.CurrentSpaceShipAssetGuid;
						string missionDataAssetGUID = val2.MissionDataAssetGUID;
						if (!string.IsNullOrEmpty(currentSpaceShipAssetGuid) && ShipByGuid.TryGetValue(currentSpaceShipAssetGuid, out var value))
						{
							lobbyInfo.Ship = value;
						}
						if (!string.IsNullOrEmpty(missionDataAssetGUID) && MissionByGuid.TryGetValue(missionDataAssetGUID, out var value2))
						{
							lobbyInfo.MissionRaw = value2;
						}
						lobbyInfo.Mission = BrowserModel.MissionName(lobbyInfo.MissionRaw, lobbyInfo.Threat);
						Finish(lobbyInfo, me, nowUtc);
						list.Add(lobbyInfo);
						if (!_ownLogged)
						{
							_ownLogged = true;
							MelonLogger.Msg("[browser] your own lobby added to the list (the game leaves it out): \"" + lobbyInfo.Name + "\"" + (string.IsNullOrEmpty(lobbyInfo.Ship) ? ", ship not seen on another lobby yet" : ""));
						}
					}
				}
			}
			catch (Exception ex)
			{
				if (!_ownWarned)
				{
					_ownWarned = true;
					MelonLogger.Warning("[browser] could not add your own lobby: " + ex.Message);
				}
			}
		}

		private static LobbyInfo FromSession(EpicSession s)
		{
			string text = s.Name ?? "";
			return new LobbyInfo
			{
				Id = (s.Id ?? ""),
				V2T = text.Contains("\u200b\u2060\u200b"),
				Name = text.Replace("\u200b\u2060\u200b", "").Trim(),
				Host = (s.OwnerName ?? ""),
				HostId = (s.OwnerId ?? ""),
				RegionCode = (s.Region ?? ""),
				Players = s.CurrentMemberCount,
				MaxPlayers = s.MaxMemberCount,
				Jumps = s.NumberOfJumps,
				Threat = s.ChallengeRating,
				Password = s.IsPasswordProtected
			};
		}

		private static LobbyInfo Read(GUI_ServerListEntry row, string me, DateTime nowUtc)
		{
			//IL_0109: 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)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: 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_0129: 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_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			IOnlineSession sessionListItem = row.m_SessionListItem;
			EpicSession val = ((sessionListItem != null) ? ((Il2CppObjectBase)sessionListItem).TryCast<EpicSession>() : null);
			if (val == null)
			{
				return null;
			}
			LobbyInfo lobbyInfo = FromSession(val);
			lobbyInfo.Row = row;
			try
			{
				lobbyInfo.Full = row.IsFull;
			}
			catch
			{
				lobbyInfo.Full = lobbyInfo.MaxPlayers > 0 && lobbyInfo.Players >= lobbyInfo.MaxPlayers;
			}
			try
			{
				TMP_Text regionName = row.m_RegionName;
				lobbyInfo.RegionText = StripTags((regionName != null) ? regionName.text : null);
			}
			catch
			{
			}
			if (string.IsNullOrWhiteSpace(lobbyInfo.RegionText))
			{
				lobbyInfo.RegionText = lobbyInfo.RegionCode;
			}
			try
			{
				TMP_Text shipTypeName = row.m_ShipTypeName;
				lobbyInfo.Ship = StripTags((shipTypeName != null) ? shipTypeName.text : null);
			}
			catch
			{
			}
			try
			{
				TMP_Text serverStatus = row.m_ServerStatus;
				lobbyInfo.MissionRaw = StripTags((serverStatus != null) ? serverStatus.text : null);
			}
			catch
			{
			}
			lobbyInfo.Mission = BrowserModel.MissionName(lobbyInfo.MissionRaw, lobbyInfo.Threat);
			try
			{
				Material challengeRatingIconMaterial = row.m_ChallengeRatingIconMaterial;
				if ((Object)(object)challengeRatingIconMaterial != (Object)null)
				{
					Color color = challengeRatingIconMaterial.GetColor(GUI_ServerListEntry.ThreatColorID);
					if (color.a > 0.05f && color.r + color.g + color.b > 0.2f)
					{
						lobbyInfo.ThreatR = color.r;
						lobbyInfo.ThreatG = color.g;
						lobbyInfo.ThreatB = color.b;
					}
				}
			}
			catch
			{
			}
			try
			{
				string currentSpaceShipAssetGuid = val.CurrentSpaceShipAssetGuid;
				string missionDataAssetGUID = val.MissionDataAssetGUID;
				if (!string.IsNullOrEmpty(currentSpaceShipAssetGuid) && !string.IsNullOrEmpty(lobbyInfo.Ship))
				{
					ShipByGuid[currentSpaceShipAssetGuid] = lobbyInfo.Ship;
				}
				if (!string.IsNullOrEmpty(missionDataAssetGUID) && !string.IsNullOrEmpty(lobbyInfo.MissionRaw))
				{
					MissionByGuid[missionDataAssetGUID] = lobbyInfo.MissionRaw;
				}
			}
			catch
			{
			}
			Finish(lobbyInfo, me, nowUtc);
			return lobbyInfo;
		}

		private static void Finish(LobbyInfo l, string me, DateTime nowUtc)
		{
			if (l.V2T && CrewShare.LevelsFor(l.Id, l.HostId, out var min, out var max))
			{
				l.LevelMin = min;
				l.LevelMax = max;
				l.Name = BrowserModel.StripLevelTag(l.Name).TrimEnd();
			}
			l.Mine = !string.IsNullOrEmpty(me) && string.Equals(l.HostId, me, StringComparison.OrdinalIgnoreCase);
			l.OutOfLevel = !l.Mine && l.LevelMin > 0 && !BrowserModel.FitsLobby(Prefs.MyLevel.Value, l.LevelMin, l.LevelMax);
			l.FriendName = (l.Mine ? null : FriendLobbies.FriendFor(l.HostId));
			if (!l.Mine && RecentPlayers.TryGet(l.HostId, out var seenUtc, out var _) && BrowserModel.IsRecent(seenUtc, nowUtc))
			{
				l.PlayedWith = seenUtc;
			}
			l.PingMs = RegionPing.Get(l.RegionCode);
			l.Crew = CrewShare.For(l.Id, l.HostId);
			if (l.Crew == null)
			{
				return;
			}
			for (int i = 1; i < l.Crew.Count; i++)
			{
				if (FriendLobbies.FriendForTail(l.Crew[i].IdTail) != null)
				{
					l.FriendInside = true;
					break;
				}
			}
		}

		private static string StripTags(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(s.Length);
			bool flag = false;
			foreach (char c in s)
			{
				if (c == '<')
				{
					flag = true;
				}
				else if (c == '>' && flag)
				{
					flag = false;
				}
				else if (!flag)
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString().Trim();
		}

		private static void Join(LobbyInfo l)
		{
			if (l == null || l.Mine)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (!(unscaledTime - _joinAt < 1.5f))
			{
				_joinAt = unscaledTime;
				GUI_ServerListEntry val = FindRow(l.Id);
				if ((Object)(object)val == (Object)null)
				{
					_joinWait = l;
					_joinWaitAt = unscaledTime;
					MelonLogger.Msg("[browser] \"" + l.Name + "\": its row is being rebuilt - joining as soon as it is back");
				}
				else
				{
					JoinRow(l, val);
				}
			}
		}

		private static void JoinRow(LobbyInfo l, GUI_ServerListEntry row)
		{
			try
			{
				MelonLogger.Msg($"[browser] joining \"{l.Name}\" (host {l.Host}, {l.RegionCode}, {l.Players}/{l.MaxPlayers})");
				_asked = l;
				_askedAt = Time.unscaledTime;
				_askedReq = IntPtr.Zero;
				row.Join();
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[browser] could not join: " + ex.Message);
			}
		}

		private static void SortBy(SortKey key)
		{
			if (_sort == key)
			{
				_desc = !_desc;
			}
			else
			{
				_sort = key;
				_desc = BrowserModel.DefaultDescending(key);
			}
			_scroll = 0f;
			Arrange();
		}

		public static void Draw()
		{
			if (_join != null)
			{
				DrawJoin();
			}
			else
			{
				if (DrawLeaveDialog())
				{
					return;
				}
				if (Prefs.LobbyBrowser.Value && !_broken && !Open && !_layoutEdit)
				{
					DrawBrowseButton();
				}
				if (!Open)
				{
					DrawControlPanel();
				}
				if (Open)
				{
					try
					{
						DrawScreens();
					}
					finally
					{
						DrawModeSwitch();
					}
				}
			}
		}

		private static void DrawScreens()
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Invalid comparison betwee