using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FMODUnity;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using SBGL.UnifiedMod.Core;
using SBGL.UnifiedMod.Features;
using SBGL.UnifiedMod.Features.CompetitivePluginCheck;
using SBGL.UnifiedMod.Patches;
using SBGL.UnifiedMod.Utils;
using SBGLLiveLeaderboard;
using SBGLeagueAutomation;
using Steamworks;
using Steamworks.Data;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("GameAssembly")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SBGL.UnifiedMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: AssemblyInformationalVersion("0.0.1+c3f052b0dea59e1a22071a28f40a279b9dc1c3e3")]
[assembly: AssemblyProduct("Super Battle Golf League Unified Mod")]
[assembly: AssemblyTitle("SBGL.UnifiedMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SBGLeagueAutomation
{
	public class SBGLPlugin : MonoBehaviour
	{
		[HarmonyPatch]
		private static class CourseManager_RpcInformEndingCourse_Patch
		{
			private static MethodBase TargetMethod()
			{
				Type type = AccessTools.TypeByName("CourseManager");
				if (type == null)
				{
					return null;
				}
				return AccessTools.Method(type, "UserCode_RpcInformEndingCourse", (Type[])null, (Type[])null);
			}

			private static void Postfix()
			{
				try
				{
					SBGLPlugin sBGLPlugin = Object.FindAnyObjectByType<SBGLPlugin>((FindObjectsInactive)1);
					if ((Object)(object)sBGLPlugin != (Object)null)
					{
						sBGLPlugin.OnCourseRpcInformEndingCourse();
					}
				}
				catch (Exception arg)
				{
					Debug.Log((object)$"[SBGL.Matchmaking] CourseManager.RpcInformEndingCourse postfix error: {arg}");
				}
			}
		}

		public class PlayerProfile
		{
			public string id;

			public string display_name;

			public string region;

			public string state_province;

			public float current_mmr;
		}

		public class MatchmakingSession
		{
			public string id;

			public string lobby_name;

			public string lobby_password;

			public string host_player_id;

			public string status;

			public string match_id;

			public string lobby_id;

			public string host_steam_id;

			public string steam_lobby_link;

			public List<string> player_ids;

			public List<string> accepted_player_ids;

			public string match_type;

			public string selected_course;

			public int season;
		}

		public class MatchStats
		{
			public string matchmaking_session_id;

			public string match_id;

			public string player_id;

			public string player_name;

			public string match_date;

			public int duration_seconds;

			public bool is_host;

			public string status;

			public string course_name;

			public string match_type;

			public int season;
		}

		private class CachedLeaderboardPlayer
		{
			public string Name;

			public int BaseScore;

			public string RawStrokes;

			public string MMR;

			public int ProjectedDelta;
		}

		public struct PlayerData
		{
			public string name;

			public string mmr;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass132_0
		{
			public string playerId;

			public string resolvedDisplayName;

			public int casualMatchesPlayed;

			public bool updated;

			public SBGLPlugin <>4__this;

			internal void <IncrementCasualMatchesPlayedForActivePlayers>b__2(string id)
			{
				playerId = id;
			}

			internal void <IncrementCasualMatchesPlayedForActivePlayers>b__3(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				if (val != null)
				{
					resolvedDisplayName = ((string)val["display_name"]) ?? resolvedDisplayName;
					int.TryParse(((object)val["casual_matches_played"])?.ToString() ?? "0", out casualMatchesPlayed);
				}
			}

			internal void <IncrementCasualMatchesPlayedForActivePlayers>b__4(string res)
			{
				if (<>4__this.ParseApiSingleObject(res) != null)
				{
					updated = true;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass148_0
		{
			public bool readSucceeded;

			public string existingScreenshotUrl;

			public bool uploadSucceeded;

			public SBGLPlugin <>4__this;

			internal void <UploadCapturedMatchScreenshotIfNeeded>b__0(string res)
			{
				readSucceeded = true;
				JObject val = <>4__this.ParseApiSingleObject(res);
				existingScreenshotUrl = (string)((val != null) ? val["screenshot_url"] : null);
			}

			internal void <UploadCapturedMatchScreenshotIfNeeded>b__1(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				uploadSucceeded = val != null;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass148_1
		{
			public string uploadedFileUrl;

			internal void <UploadCapturedMatchScreenshotIfNeeded>b__2(string url)
			{
				uploadedFileUrl = url;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass165_0
		{
			public string existingMatchId;

			internal void <WaitForExistingMatchBeforeFallback>b__0(string id)
			{
				existingMatchId = id;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass167_0
		{
			public SBGLPlugin <>4__this;

			public string resolvedId;

			internal void <ResolveExistingMatchEntryId>b__0(string res)
			{
				JObject val = <>4__this.ParseApiObjectList(res).FirstOrDefault();
				if (val != null)
				{
					resolvedId = (string)val["id"];
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass169_0
		{
			public SBGLPlugin <>4__this;

			public string sourceTag;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass169_1
		{
			public string existingEntryId;

			public string createdEntryId;

			public <>c__DisplayClass169_0 CS$<>8__locals1;

			internal void <EnsureMatchEntryForPlayer>b__0(string id)
			{
				existingEntryId = id;
			}

			internal void <EnsureMatchEntryForPlayer>b__1(string res)
			{
				try
				{
					JObject val = CS$<>8__locals1.<>4__this.ParseApiSingleObject(res);
					if (val != null)
					{
						createdEntryId = (string)val["id"];
					}
				}
				catch (Exception ex)
				{
					CS$<>8__locals1.<>4__this.Log("<color=yellow>[" + CS$<>8__locals1.sourceTag + "] Could not parse MatchEntry response: " + ex.Message + "</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass182_0
		{
			public SBGLPlugin <>4__this;

			public string existingId;

			internal void <MatchmakingLoop>b__0(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				if (val != null)
				{
					<>4__this._currentQueueId = existingId;
					<>4__this._webStatus = "QUEUED";
					<>4__this.Log("<color=green>[Queue] ✓ Updated existing entry " + existingId + " with has_mod:true.</color>");
				}
				else
				{
					<>4__this.Log("<color=red>[Queue] Failed to update existing entry " + existingId + ".</color>");
				}
			}

			internal void <MatchmakingLoop>b__1(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				<>4__this._currentQueueId = ((string)((val != null) ? val["id"] : null)) ?? <>4__this._currentQueueId;
				<>4__this._webStatus = "QUEUED";
				<>4__this.Log("<color=green>[Queue] ✓ Created new entry " + <>4__this._currentQueueId + " with has_mod:true.</color>");
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass183_0
		{
			public SBGLPlugin <>4__this;

			public bool leaveSuccess;

			internal void <LeaveQueue>b__0(string res)
			{
				if (<>4__this.ParseApiSingleObject(res) != null)
				{
					<>4__this.ResetPluginState();
					<>4__this.Log("✓ Left Queue.");
					leaveSuccess = true;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass195_0
		{
			public string existingMatchId;

			internal void <CreateMatchAndEntriesInternal>b__0(string id)
			{
				existingMatchId = id;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass195_1
		{
			public string apiMatchId;

			internal void <CreateMatchAndEntriesInternal>b__1(string id)
			{
				apiMatchId = id;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass195_2
		{
			public string fallbackFoundId;

			internal void <CreateMatchAndEntriesInternal>b__2(string id)
			{
				fallbackFoundId = id;
			}

			internal void <CreateMatchAndEntriesInternal>b__3(string id)
			{
				fallbackFoundId = id;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass195_3
		{
			public string finalCheckId;

			public SBGLPlugin <>4__this;

			internal void <CreateMatchAndEntriesInternal>b__4(string res)
			{
				JObject obj = <>4__this.SelectNewestReusableMatch(<>4__this.ParseApiObjectList(res));
				finalCheckId = (string)((obj != null) ? obj["id"] : null);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass195_4
		{
			public string newMatchId;

			internal void <CreateMatchAndEntriesInternal>b__5(string id)
			{
				newMatchId = id;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass195_5
		{
			public string linkMatchId;

			public SBGLPlugin <>4__this;

			internal void <CreateMatchAndEntriesInternal>b__6(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				if (val != null)
				{
					<>4__this._currentSession.match_id = linkMatchId;
					<>4__this.Log("<color=green>[Match Creation] ✓ MatchmakingSession " + <>4__this._currentSession.id + " linked to match: " + linkMatchId + "</color>");
				}
				else
				{
					<>4__this.Log("<color=yellow>[Match Creation] Could not confirm MatchmakingSession update</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass195_6
		{
			public string playerId;

			public SBGLPlugin <>4__this;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass195_7
		{
			public string playerName;

			public string preMatchMmr;

			public string entryId;

			public <>c__DisplayClass195_6 CS$<>8__locals1;

			internal void <CreateMatchAndEntriesInternal>b__7(string res)
			{
				try
				{
					JObject val = CS$<>8__locals1.<>4__this.ParseApiSingleObject(res);
					if (val != null)
					{
						playerName = (string)val["display_name"];
						if (string.IsNullOrEmpty(playerName))
						{
							CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Player " + CS$<>8__locals1.playerId + " has no display_name, using ID</color>");
							playerName = CS$<>8__locals1.playerId;
						}
						object obj = val["current_mmr"];
						if (obj != null)
						{
							preMatchMmr = obj.ToString();
						}
						CS$<>8__locals1.<>4__this.Log("<color=cyan>[Match Creation] Fetched player: " + playerName + " (MMR: " + preMatchMmr + ")</color>");
					}
					else
					{
						CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Failed to fetch Player " + CS$<>8__locals1.playerId + " - response null</color>");
						playerName = CS$<>8__locals1.playerId;
					}
				}
				catch (Exception ex)
				{
					CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Error fetching Player " + CS$<>8__locals1.playerId + ": " + ex.Message + "</color>");
					playerName = CS$<>8__locals1.playerId;
				}
			}

			internal void <CreateMatchAndEntriesInternal>b__8(string id)
			{
				entryId = id;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass197_0
		{
			public bool shouldUpload;

			internal void <MonitorAndUpdateScores>b__3(bool ok)
			{
				shouldUpload = ok;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass197_1
		{
			public string playerId;

			public string entryId;

			public SBGLPlugin <>4__this;

			internal void <MonitorAndUpdateScores>b__4(string id)
			{
				playerId = id;
			}

			internal void <MonitorAndUpdateScores>b__6(string id)
			{
				entryId = id;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass197_2
		{
			public string preMatchMmr;

			public <>c__DisplayClass197_1 CS$<>8__locals1;

			internal void <MonitorAndUpdateScores>b__5(string res)
			{
				JObject val = CS$<>8__locals1.<>4__this.ParseApiSingleObject(res);
				object obj = ((val != null) ? val["current_mmr"] : null);
				if (obj != null)
				{
					preMatchMmr = obj.ToString();
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass198_0
		{
			public SBGLPlugin <>4__this;

			public string playerName;

			internal void <UpdateMatchEntry>b__0(string res)
			{
				try
				{
					JObject val = <>4__this.ParseApiSingleObject(res);
					if (val != null)
					{
						<>4__this.Log("<color=green>[Score Update] ✓ MatchEntry updated for " + playerName + "</color>");
					}
				}
				catch (Exception ex)
				{
					<>4__this.Log("<color=yellow>[Score Update] Could not update MatchEntry: " + ex.Message + "</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass202_0
		{
			public SBGLPlugin <>4__this;

			public string resolvedId;

			public string normalizedName;

			public Func<JObject, bool> <>9__3;

			internal void <ResolvePlayerIdByNameFromApi>b__0(string res)
			{
				JObject val = <>4__this.ParseApiObjectList(res)?.FirstOrDefault();
				if (val != null)
				{
					resolvedId = (string)val["id"];
				}
			}

			internal void <ResolvePlayerIdByNameFromApi>b__1(string res)
			{
				JObject val = <>4__this.ParseApiObjectList(res)?.FirstOrDefault();
				if (val != null)
				{
					resolvedId = (string)val["id"];
				}
			}

			internal void <ResolvePlayerIdByNameFromApi>b__2(string res)
			{
				List<JObject> list = <>4__this.ParseApiObjectList(res);
				if (list != null && list.Count != 0)
				{
					JObject val = ((IEnumerable<JObject>)list).FirstOrDefault((Func<JObject, bool>)((JObject r) => string.Equals((string)((r != null) ? r["display_name"] : null), normalizedName, StringComparison.OrdinalIgnoreCase) || string.Equals((string)((r != null) ? r["ign"] : null), normalizedName, StringComparison.OrdinalIgnoreCase)));
					JObject val2 = val ?? list.FirstOrDefault();
					if (val2 != null)
					{
						resolvedId = (string)val2["id"];
					}
				}
			}

			internal bool <ResolvePlayerIdByNameFromApi>b__3(JObject r)
			{
				return string.Equals((string)((r != null) ? r["display_name"] : null), normalizedName, StringComparison.OrdinalIgnoreCase) || string.Equals((string)((r != null) ? r["ign"] : null), normalizedName, StringComparison.OrdinalIgnoreCase);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass203_0
		{
			public SBGLPlugin <>4__this;

			public int actualPlayerCount;

			public string source;

			internal void <UpdateMatchPlayerCountIfNeeded>b__0(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				if (val != null)
				{
					<>4__this._lastUploadedPlayerCount = actualPlayerCount;
					<>4__this.Log($"<color=green>[Match Count] ✓ Updated match player_count to {actualPlayerCount} ({source})</color>");
				}
				else
				{
					<>4__this.Log($"<color=yellow>[Match Count] Could not confirm player_count update to {actualPlayerCount} ({source})</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass210_0
		{
			public SBGLPlugin <>4__this;

			public HashSet<string> knownNames;

			public Action<string> <>9__3;

			internal void <EnrichPlayerIdsFromLeaderboard>b__3(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				string text = (string)((val != null) ? val["display_name"] : null);
				if (!string.IsNullOrWhiteSpace(text))
				{
					knownNames.Add(text);
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass210_1
		{
			public string playerIdFromName;

			internal void <EnrichPlayerIdsFromLeaderboard>b__4(string id)
			{
				playerIdFromName = id;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass211_0
		{
			public SBGLPlugin <>4__this;

			public Dictionary<string, float> finalPreMmrByName;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass211_1
		{
			public CachedLeaderboardPlayer p;

			public <>c__DisplayClass211_0 CS$<>8__locals1;

			internal void <FinalizeMatchStats>b__3(string res)
			{
				JObject val = CS$<>8__locals1.<>4__this.ParseApiSingleObject(res);
				object obj = ((val != null) ? val["current_mmr"] : null);
				if (obj != null && float.TryParse(obj.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					CS$<>8__locals1.finalPreMmrByName[p.Name] = result;
					CS$<>8__locals1.<>4__this.Log($"<color=cyan>[Match Finalize] MMR for {p.Name} resolved from API: {result}</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass211_2
		{
			public string playerId;

			public string entryId;

			public <>c__DisplayClass211_0 CS$<>8__locals2;

			internal void <FinalizeMatchStats>b__6(string id)
			{
				playerId = id;
			}

			internal void <FinalizeMatchStats>b__5(string id)
			{
				entryId = id;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass211_3
		{
			public string preMatchMmr;

			public <>c__DisplayClass211_2 CS$<>8__locals3;

			internal void <FinalizeMatchStats>b__4(string res)
			{
				JObject val = CS$<>8__locals3.CS$<>8__locals2.<>4__this.ParseApiSingleObject(res);
				object obj = ((val != null) ? val["current_mmr"] : null);
				if (obj != null)
				{
					preMatchMmr = obj.ToString();
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass212_0
		{
			public SBGLPlugin <>4__this;

			public string playerName;

			public string preMatchMmr;

			public string entryId;

			internal void <CreatePlaceholderMatchEntryForMissingSessionPlayer>b__0(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				if (val != null)
				{
					playerName = (string)val["display_name"];
					object obj = val["current_mmr"];
					if (obj != null)
					{
						preMatchMmr = obj.ToString();
					}
				}
			}

			internal void <CreatePlaceholderMatchEntryForMissingSessionPlayer>b__1(string id)
			{
				entryId = id;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass213_0
		{
			public string matchId;

			public SBGLPlugin <>4__this;

			internal void <SubmitMatchStats>b__0(string id)
			{
				matchId = id;
			}

			internal void <SubmitMatchStats>b__1(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				if (val != null)
				{
					<>4__this._currentSession.match_id = matchId;
					<>4__this.Log("<color=green>[Match Stats] ✓ MatchmakingSession " + <>4__this._currentSession.id + " linked to match: " + matchId + "</color>");
				}
				else
				{
					<>4__this.Log("<color=yellow>[Match Stats] Could not confirm MatchmakingSession update</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass216_0
		{
			public SBGLPlugin <>4__this;

			public Action<string> onMatchIdReceived;

			internal void <SubmitMatchEntry>b__0(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				if (val != null)
				{
					string text = ((string)val["id"]) ?? "unknown";
					<>4__this._lastUploadedPlayerCount = Mathf.Max(0, <>4__this._matchExpectedPlayerCount);
					<>4__this.Log("<color=green>[Match Stats] ✓ Match entry created (ID: " + text + ")</color>");
					<>4__this.ShowUploadNotification("Upload success: match ID " + text + ".", "success");
					onMatchIdReceived?.Invoke(text);
				}
				else
				{
					<>4__this.Log("<color=yellow>[Match Stats] Response received but could not parse ID</color>");
					<>4__this.ShowUploadNotification("Upload failed: invalid API response.", "failure");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass217_0
		{
			public SBGLPlugin <>4__this;

			public string playerDisplayName;

			public string playerId;

			public Func<string, bool> <>9__2;

			internal void <SubmitMatchEntryForPlayer>b__0(string res)
			{
				try
				{
					JObject val = <>4__this.ParseApiSingleObject(res);
					if (val != null)
					{
						playerDisplayName = (string)val["display_name"];
						<>4__this.Log("<color=cyan>[Match Stats] Opponent display name (API): " + playerDisplayName + "</color>");
					}
				}
				catch (Exception ex)
				{
					<>4__this.Log("<color=yellow>[Match Stats] Error parsing opponent profile: " + ex.Message + "</color>");
				}
			}

			internal bool <SubmitMatchEntryForPlayer>b__2(string k)
			{
				return string.Equals(k?.Trim(), playerDisplayName?.Trim(), StringComparison.OrdinalIgnoreCase);
			}

			internal void <SubmitMatchEntryForPlayer>b__1(string res)
			{
				JObject val = <>4__this.ParseApiSingleObject(res);
				if (val != null)
				{
					string text = ((string)val["id"]) ?? "unknown";
					<>4__this.Log("<color=green>[Match Stats] ✓ MatchEntry created (ID: " + text + ") for player " + (playerDisplayName ?? playerId) + "</color>");
				}
				else
				{
					<>4__this.Log("<color=yellow>[Match Stats] Could not parse MatchEntry response for player " + (playerDisplayName ?? playerId) + "</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <AcceptMatch>d__186 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private List<string> <acceptedIds>5__1;

			private string <acceptedIdsList>5__2;

			private string <acceptJson>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<acceptedIds>5__1 = null;
				<acceptedIdsList>5__2 = null;
				<acceptJson>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this._currentSession == null)
					{
						return false;
					}
					<>4__this._hasAccepted = true;
					<>4__this.Log("<color=cyan>[Accept] Refreshing session data before accepting...</color>");
					<>2__current = <>4__this.PollSessionStatus();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<acceptedIds>5__1 = new List<string>();
					if (<>4__this._currentSession.accepted_player_ids != null)
					{
						<acceptedIds>5__1.AddRange(<>4__this._currentSession.accepted_player_ids);
					}
					if (!<acceptedIds>5__1.Contains(<>4__this._userProfile.id))
					{
						<acceptedIds>5__1.Add(<>4__this._userProfile.id);
					}
					<acceptedIdsList>5__2 = string.Join("\",\"", <acceptedIds>5__1);
					<acceptJson>5__3 = "{\"accepted_player_ids\":[\"" + <acceptedIdsList>5__2 + "\"]}";
					<>4__this.Log("<color=cyan>[Accept] Current player accepting: " + <>4__this._userProfile.id + "</color>");
					<>4__this.Log($"<color=cyan>[Accept] Total accepted players: {<acceptedIds>5__1.Count}</color>");
					<>4__this.Log("<color=cyan>[Accept] JSON payload: " + <acceptJson>5__3 + "</color>");
					<>4__this._currentSession.accepted_player_ids = new List<string>(<acceptedIds>5__1);
					<>2__current = <>4__this.CallAPI("/MatchmakingSession/" + <>4__this._currentSession.id, "PUT", <acceptJson>5__3, delegate
					{
						<>4__this.Log("<color=green>✓ Match Accepted. Waiting for all players to accept before transitioning to ready...</color>");
					});
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <AutoJoinMatch>d__187 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				if (<>4__this._currentSession == null || string.IsNullOrEmpty(<>4__this._currentSession.steam_lobby_link))
				{
					return false;
				}
				<>4__this._autoJoinAttempts++;
				<>4__this._lastAutoJoinAttemptAt = DateTime.Now;
				<>4__this._lastAutoJoinSteamLink = <>4__this._currentSession.steam_lobby_link;
				<>4__this._hasAccepted = true;
				<>4__this.Log("Attempting automatic join with link: " + <>4__this._currentSession.steam_lobby_link);
				<>4__this.JoinBySteamLink(<>4__this._currentSession.steam_lobby_link, <>4__this._currentSession.lobby_password);
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <BackgroundSyncLoop>d__179 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private int <retryCount>5__1;

			private bool <isInMenuScene>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
				Scene activeScene;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<retryCount>5__1 = 0;
					goto IL_04f6;
				case 1:
					<>1__state = -1;
					if (<>4__this._userProfile != null)
					{
						<retryCount>5__1 = 0;
					}
					else
					{
						<retryCount>5__1++;
						if (<retryCount>5__1 == 1)
						{
							<>4__this.Log($"<color=yellow>Waiting for player profile resolution... (Attempt {<retryCount>5__1}/{10})</color>");
						}
						if (<retryCount>5__1 % 3 == 0)
						{
							<>4__this.Log($"<color=yellow>Still waiting for player profile... (Attempt {<retryCount>5__1}/{10})</color>");
						}
						if (<retryCount>5__1 >= 10)
						{
							<>4__this.Log("<color=orange>Player profile resolution timed out. Background sync will stop until the next reload.</color>");
							return false;
						}
					}
					goto IL_01a0;
				case 2:
					<>1__state = -1;
					goto IL_01ef;
				case 3:
					<>1__state = -1;
					goto IL_0266;
				case 4:
					<>1__state = -1;
					goto IL_02af;
				case 5:
					<>1__state = -1;
					goto IL_0326;
				case 6:
					<>1__state = -1;
					goto IL_0379;
				case 7:
					<>1__state = -1;
					goto IL_0440;
				case 8:
					<>1__state = -1;
					break;
				case 9:
					{
						<>1__state = -1;
						goto IL_04f6;
					}
					IL_01a0:
					if (<>4__this._userProfile == null)
					{
						break;
					}
					if (!<>4__this._activeSeasonFetched)
					{
						<>2__current = <>4__this.FetchActiveSeasonId();
						<>1__state = 2;
						return true;
					}
					goto IL_01ef;
					IL_0326:
					if (<>4__this._currentSession != null && <>4__this._currentSession.status == "pending_accept")
					{
						<>2__current = <>4__this.PollSessionStatus();
						<>1__state = 6;
						return true;
					}
					goto IL_0379;
					IL_01ef:
					activeScene = SceneManager.GetActiveScene();
					<isInMenuScene>5__2 = ((Scene)(ref activeScene)).name.ToLower().Contains("menu");
					if (!<>4__this._isQueueing && <>4__this._currentSession == null && !<>4__this._isInGameplay)
					{
						<>2__current = <>4__this.CheckExistingQueueEntry();
						<>1__state = 3;
						return true;
					}
					goto IL_0266;
					IL_02af:
					if (<>4__this._isInitializing)
					{
						<>4__this._isInitializing = false;
						<>4__this.Log("Initialization Complete: Queue Unlocked.");
					}
					if (<>4__this._isQueueing && <>4__this._currentSession == null)
					{
						<>2__current = <>4__this.CheckForMatch();
						<>1__state = 5;
						return true;
					}
					goto IL_0326;
					IL_0379:
					if (<>4__this._isHost && <>4__this._hostLobbyStarted && <>4__this._currentSession != null && !<>4__this._hostCancelSent)
					{
						if (NetworkServer.active)
						{
							<>4__this._hostServerWasActive = true;
						}
						else if (<>4__this._hostServerWasActive && <>4__this._currentSession.status != "completed")
						{
							<>4__this.Log("Host lobby appears closed. Marking MatchmakingSession as completed...");
							<>2__current = <>4__this.CancelSessionAsHost("host_left_lobby");
							<>1__state = 7;
							return true;
						}
					}
					goto IL_0440;
					IL_0440:
					if (<>4__this._currentSession != null && !<>4__this._isHost && <>4__this._currentSession.status == "ready" && !string.IsNullOrEmpty(<>4__this._currentSession.steam_lobby_link) && !<>4__this._hasAccepted)
					{
						<>4__this.Log("Auto-joining match as non-host...");
						<>2__current = <>4__this.AutoJoinMatch();
						<>1__state = 8;
						return true;
					}
					break;
					IL_04f6:
					<>4__this._syncTickCount++;
					if (<>4__this._userProfile == null)
					{
						<>2__current = <>4__this.EnsureUserProfileResolved("Sync");
						<>1__state = 1;
						return true;
					}
					goto IL_01a0;
					IL_0266:
					if (<isInMenuScene>5__2 && !IsRankedTriggered && !<>4__this._isInGameplay)
					{
						<>2__current = <>4__this.RefreshPlayerList();
						<>1__state = 4;
						return true;
					}
					goto IL_02af;
				}
				<>2__current = _syncLoopDelay;
				<>1__state = 9;
				return true;
			}

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

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

		[CompilerGenerated]
		private sealed class <CallAPI>d__223 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string endpoint;

			public string method;

			public string json;

			public Action<string> onSuccess;

			public SBGLPlugin <>4__this;

			private string <fullUrl>5__1;

			private UnityWebRequest <req>5__2;

			private string <errorMsg>5__3;

			private int <length>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<fullUrl>5__1 = null;
				<req>5__2 = null;
				<errorMsg>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Expected O, but got Unknown
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Expected O, but got Unknown
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Expected O, but got Unknown
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Invalid comparison between Unknown and I4
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<fullUrl>5__1 = <>4__this.GetBaseApiUrl() + endpoint;
						<>4__this.Log("<color=cyan>[API] " + method + " " + endpoint + "</color>");
						<>4__this.Log("<color=cyan>[API] Full URL: " + <fullUrl>5__1 + "</color>");
						<req>5__2 = new UnityWebRequest(<fullUrl>5__1, method);
						<>1__state = -3;
						if (!string.IsNullOrEmpty(json))
						{
							<req>5__2.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(json));
						}
						<req>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<>4__this.ApplyApiHeaders(<req>5__2);
						<>2__current = <req>5__2.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__2.result == 1)
						{
							<>4__this.Log("<color=green>[API] " + method + " " + endpoint + " - Success</color>");
							onSuccess?.Invoke(<req>5__2.downloadHandler.text);
						}
						else
						{
							<errorMsg>5__3 = $"[API] {method} {endpoint} failed: {<req>5__2.result}";
							if (!string.IsNullOrEmpty(<req>5__2.error))
							{
								<errorMsg>5__3 = <errorMsg>5__3 + " - " + <req>5__2.error;
							}
							if (<req>5__2.responseCode > 0)
							{
								<errorMsg>5__3 += $" (HTTP {<req>5__2.responseCode})";
							}
							DownloadHandler downloadHandler = <req>5__2.downloadHandler;
							if (!string.IsNullOrEmpty((downloadHandler != null) ? downloadHandler.text : null))
							{
								<length>5__4 = Math.Min(200, <req>5__2.downloadHandler.text.Length);
								<errorMsg>5__3 = <errorMsg>5__3 + " - Response: " + <req>5__2.downloadHandler.text.Substring(0, <length>5__4);
							}
							<>4__this.Log("<color=red>" + <errorMsg>5__3 + "</color>");
							<errorMsg>5__3 = null;
						}
						<>m__Finally1();
						<req>5__2 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__2 != null)
				{
					((IDisposable)<req>5__2).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <CancelSessionAsHost>d__192 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string reason;

			public SBGLPlugin <>4__this;

			private string <sessionId>5__1;

			private string <json>5__2;

			private UnityWebRequest <req>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<sessionId>5__1 = null;
				<json>5__2 = null;
				<req>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Invalid comparison between Unknown and I4
				//IL_0213: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Expected O, but got Unknown
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Expected O, but got Unknown
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (<>4__this._hostCancelSent)
						{
							return false;
						}
						if (!<>4__this._isHost || <>4__this._currentSession == null || string.IsNullOrEmpty(<>4__this._currentSession.id))
						{
							return false;
						}
						if (<>4__this._currentSession.id == "DEBUG")
						{
							return false;
						}
						<>4__this._hostCancelSent = true;
						<sessionId>5__1 = <>4__this._currentSession.id;
						<json>5__2 = "{\"status\":\"completed\"}";
						<req>5__3 = new UnityWebRequest(<>4__this.GetBaseApiUrl() + "/MatchmakingSession/" + <sessionId>5__1, "PUT");
						<>1__state = -3;
						<req>5__3.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(<json>5__2));
						<req>5__3.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<>4__this.ApplyApiHeaders(<req>5__3);
						<>2__current = <req>5__3.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__3.result == 1)
						{
							if (<>4__this._currentSession != null && <>4__this._currentSession.id == <sessionId>5__1)
							{
								<>4__this._currentSession.status = "completed";
							}
							<>4__this.Log("Host leave update sent (" + reason + "): session marked completed.");
						}
						else
						{
							<>4__this._hostCancelSent = false;
							<>4__this.Log($"<color=red>Host cancel failed ({reason}): {<req>5__3.result} {<req>5__3.error}</color>");
						}
						<>m__Finally1();
						<req>5__3 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__3 != null)
				{
					((IDisposable)<req>5__3).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <CaptureAndStorePerHoleScreenshot>d__141 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string source;

			public SBGLPlugin <>4__this;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>1__state = -3;
						<>2__current = <>4__this.CaptureMatchScreenshotForReview(source + " (per-hole immediate)");
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						<>m__Finally1();
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				<>4__this._matchScreenshotSignalCoroutine = null;
			}

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

		[CompilerGenerated]
		private sealed class <CaptureAndUploadScreenshotFromForcedScoreboard>d__142 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string source;

			public SBGLPlugin <>4__this;

			private float <waited>5__1;

			private float <snapshotTimeout>5__2;

			private bool <gotFinalSnapshot>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 3u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Expected O, but got Unknown
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<>1__state = -3;
						<>2__current = (object)new WaitForSeconds(2f);
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -3;
						<waited>5__1 = 0f;
						<snapshotTimeout>5__2 = 6f;
						<gotFinalSnapshot>5__3 = false;
						goto IL_011f;
					case 2:
						<>1__state = -3;
						<waited>5__1 += 0.25f;
						goto IL_011f;
					case 3:
						<>1__state = -3;
						<>2__current = <>4__this.UploadCapturedMatchScreenshotIfNeeded(source);
						<>1__state = 4;
						result = true;
						break;
					case 4:
						{
							<>1__state = -3;
							<>m__Finally1();
							result = false;
							break;
						}
						IL_011f:
						if (<waited>5__1 < <snapshotTimeout>5__2)
						{
							if (!<>4__this._matchEndedReceived)
							{
								try
								{
									if (<>4__this.TryCaptureFinalLeaderboardSnapshot(source + " (screenshot-wait)"))
									{
										<gotFinalSnapshot>5__3 = true;
										goto IL_0136;
									}
								}
								catch
								{
								}
								<>2__current = (object)new WaitForSeconds(0.25f);
								<>1__state = 2;
								result = true;
								break;
							}
							<gotFinalSnapshot>5__3 = true;
						}
						goto IL_0136;
						IL_0136:
						if (!<gotFinalSnapshot>5__3)
						{
							<>4__this.Log($"<color=yellow>[Match Screenshot] Final leaderboard snapshot not available within {<snapshotTimeout>5__2}s - skipping forced-scoreboard capture ({source})</color>");
							result = false;
							<>m__Finally1();
						}
						else
						{
							<>2__current = <>4__this.CaptureMatchScreenshotForReview(source);
							<>1__state = 3;
							result = true;
						}
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				<>4__this._matchScreenshotSignalCoroutine = null;
			}

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

		[CompilerGenerated]
		private sealed class <CaptureMatchScreenshotForReview>d__147 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string source;

			public SBGLPlugin <>4__this;

			private float <waitedSeconds>5__1;

			private int <screenWidth>5__2;

			private int <screenHeight>5__3;

			private Texture2D <capturedTexture>5__4;

			private Texture2D <encodedTexture>5__5;

			private byte[] <imageBytes>5__6;

			private Exception <ex>5__7;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<capturedTexture>5__4 = null;
				<encodedTexture>5__5 = null;
				<imageBytes>5__6 = null;
				<ex>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Expected O, but got Unknown
				//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this._matchScreenshotUploadCompleted || <>4__this._matchScreenshotUploadInProgress)
					{
						return false;
					}
					if (<>4__this._pendingMatchScreenshotBytes != null && <>4__this._pendingMatchScreenshotBytes.Length != 0)
					{
						<>4__this.Log("<color=cyan>[Match Screenshot] Replacing previous pending screenshot with a newer capture (" + source + ")</color>");
					}
					<waitedSeconds>5__1 = 0f;
					goto IL_00db;
				case 1:
					<>1__state = -1;
					<waitedSeconds>5__1 += Mathf.Max(Time.unscaledDeltaTime, 0.016f);
					goto IL_00db;
				case 2:
					{
						<>1__state = -1;
						<screenWidth>5__2 = Screen.width;
						<screenHeight>5__3 = Screen.height;
						if (<screenWidth>5__2 <= 0 || <screenHeight>5__3 <= 0)
						{
							<>4__this.Log("<color=yellow>[Match Screenshot] Screen dimensions were invalid - skipping capture</color>");
							return false;
						}
						<capturedTexture>5__4 = null;
						<encodedTexture>5__5 = null;
						try
						{
							<capturedTexture>5__4 = new Texture2D(<screenWidth>5__2, <screenHeight>5__3, (TextureFormat)3, false);
							<capturedTexture>5__4.ReadPixels(new Rect(0f, 0f, (float)<screenWidth>5__2, (float)<screenHeight>5__3), 0, 0, false);
							<capturedTexture>5__4.Apply(false, false);
							<encodedTexture>5__5 = <>4__this.ResizeTextureToFit(<capturedTexture>5__4, 1920, 1080);
							<imageBytes>5__6 = <>4__this.EncodeScreenshotBytes(<encodedTexture>5__5);
							if (<imageBytes>5__6 == null || <imageBytes>5__6.Length == 0)
							{
								<>4__this.Log("<color=yellow>[Match Screenshot] JPEG encoding returned no data - skipping capture</color>");
								return false;
							}
							<>4__this._pendingMatchScreenshotBytes = <imageBytes>5__6;
							<>4__this._pendingMatchScreenshotFileName = <>4__this.BuildMatchScreenshotFileName();
							<>4__this._pendingUploadedScreenshotUrl = null;
							<>4__this.Log($"<color=green>[Match Screenshot] ✓ Captured final scoreboard screenshot from {source} ({((Texture)<encodedTexture>5__5).width}x{((Texture)<encodedTexture>5__5).height}, {(float)<imageBytes>5__6.Length / 1024f:0.#} KB)</color>");
							<imageBytes>5__6 = null;
						}
						catch (Exception ex)
						{
							<ex>5__7 = ex;
							<>4__this.Log("<color=yellow>[Match Screenshot] Could not capture screenshot from " + source + ": " + <ex>5__7.Message + "</color>");
						}
						finally
						{
							if ((Object)(object)<encodedTexture>5__5 != (Object)null && <encodedTexture>5__5 != <capturedTexture>5__4)
							{
								Object.Destroy((Object)(object)<encodedTexture>5__5);
							}
							if ((Object)(object)<capturedTexture>5__4 != (Object)null)
							{
								Object.Destroy((Object)(object)<capturedTexture>5__4);
							}
						}
						return false;
					}
					IL_00db:
					if (!CourseManager.ForceDisplayScoreboard && <waitedSeconds>5__1 < 4f)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					if (!CourseManager.ForceDisplayScoreboard)
					{
						<>4__this.Log("<color=yellow>[Match Screenshot] Forced scoreboard was not visible in time for " + source + " - skipping capture for now</color>");
						return false;
					}
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <CheckAndSubmitMatchStats>d__160 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private string <query>5__1;

			private string <fullUrl>5__2;

			private UnityWebRequest <req>5__3;

			private List<JObject> <existingMatches>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<query>5__1 = null;
				<fullUrl>5__2 = null;
				<req>5__3 = null;
				<existingMatches>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Invalid comparison between Unknown and I4
				//IL_024a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						if (<>4__this._userProfile == null || <>4__this._currentSession == null)
						{
							<>4__this.Log("<color=red>[Match Stats] Failed: Missing profile or session</color>");
							result = false;
							break;
						}
						<>4__this.Log("<color=cyan>[Match Stats] Waiting for leaderboard to populate...</color>");
						<>2__current = (object)new WaitForSeconds(1.5f);
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -1;
						<query>5__1 = "{\"matchmaking_session_id\":\"" + <>4__this._currentSession.id + "\"}";
						<fullUrl>5__2 = <>4__this.GetBaseApiUrl() + "/Match?q=" + UnityWebRequest.EscapeURL(<query>5__1);
						<>4__this.Log("<color=cyan>[Match Stats] Checking for existing match entry...</color>");
						<>4__this.Log("<color=cyan>[Match Stats] Query URL: " + <fullUrl>5__2.Substring(0, Math.Min(150, <fullUrl>5__2.Length)) + "...</color>");
						<req>5__3 = UnityWebRequest.Get(<fullUrl>5__2);
						<>1__state = -3;
						<>4__this.ApplyApiHeaders(<req>5__3);
						<>2__current = <req>5__3.SendWebRequest();
						<>1__state = 2;
						result = true;
						break;
					case 2:
						<>1__state = -3;
						if ((int)<req>5__3.result == 1)
						{
							<existingMatches>5__4 = <>4__this.ParseApiObjectList(<req>5__3.downloadHandler.text);
							if (<existingMatches>5__4.Count > 0)
							{
								<>4__this.Log($"<color=orange>[Match Stats] Match already exists for this session (found {<existingMatches>5__4.Count} entries)</color>");
								<>4__this._matchStatsSubmitted = true;
								result = false;
								<>m__Finally1();
								break;
							}
							<>4__this.Log("<color=cyan>[Match Stats] No existing match found - proceeding with submission</color>");
							<existingMatches>5__4 = null;
						}
						else
						{
							<>4__this.Log($"<color=yellow>[Match Stats] Could not query existing matches: {<req>5__3.result} - proceeding anyway</color>");
						}
						<>m__Finally1();
						<req>5__3 = null;
						<>2__current = <>4__this.SubmitMatchStats();
						<>1__state = 3;
						result = true;
						break;
					case 3:
						<>1__state = -1;
						result = false;
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__3 != null)
				{
					((IDisposable)<req>5__3).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <CheckExistingQueueEntry>d__181 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private string <checkQuery>5__1;

			private string <checkUrl>5__2;

			private UnityWebRequest <req>5__3;

			private List<JObject> <existing>5__4;

			private string <patchJson>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<checkQuery>5__1 = null;
				<checkUrl>5__2 = null;
				<req>5__3 = null;
				<existing>5__4 = null;
				<patchJson>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<checkQuery>5__1 = "{\"player_id\":\"" + <>4__this._userProfile.id + "\",\"status\":\"queued\"}";
						<checkUrl>5__2 = <>4__this.GetBaseApiUrl() + "/MatchmakingQueue?q=" + UnityWebRequest.EscapeURL(<checkQuery>5__1);
						<req>5__3 = UnityWebRequest.Get(<checkUrl>5__2);
						<>1__state = -3;
						<>4__this.ApplyApiHeaders(<req>5__3);
						<>2__current = <req>5__3.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__3.result != 1)
						{
							break;
						}
						<existing>5__4 = <>4__this.ParseApiObjectList(<req>5__3.downloadHandler.text);
						if (<existing>5__4 != null && <existing>5__4.Count > 0)
						{
							<>4__this._currentQueueId = (string)<existing>5__4[0]["id"];
							<>4__this._isQueueing = true;
							<>4__this._webStatus = "QUEUED";
							<>4__this._queueStartTime = DateTime.Now;
							<>4__this.Log("<color=yellow>[Queue] Detected existing queue entry " + <>4__this._currentQueueId + " from website — rejoining.</color>");
							<patchJson>5__5 = "{\"has_mod\":true,\"created_by\":\"SBGL_UnifiedMod\",\"match_type\":\"" + <>4__this.GetQueueMatchTypePayload() + "\"}";
							<>2__current = <>4__this.CallAPI("/MatchmakingQueue/" + <>4__this._currentQueueId, "PUT", <patchJson>5__5, delegate(string res)
							{
								if (<>4__this.ParseApiSingleObject(res) != null)
								{
									<>4__this.Log("<color=green>[Queue] ✓ Patched has_mod:true onto existing entry " + <>4__this._currentQueueId + ".</color>");
								}
							});
							<>1__state = 2;
							return true;
						}
						goto IL_0226;
					case 2:
						{
							<>1__state = -3;
							<patchJson>5__5 = null;
							goto IL_0226;
						}
						IL_0226:
						<existing>5__4 = null;
						break;
					}
					<>m__Finally1();
					<req>5__3 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__3 != null)
				{
					((IDisposable)<req>5__3).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <CheckForMatch>d__184 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private string <query>5__1;

			private string <fullUrl>5__2;

			private UnityWebRequest <req>5__3;

			private List<JObject> <sessions>5__4;

			private JObject <activeSession>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<query>5__1 = null;
				<fullUrl>5__2 = null;
				<req>5__3 = null;
				<sessions>5__4 = null;
				<activeSession>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Invalid comparison between Unknown and I4
				//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<query>5__1 = "{\"$or\":[{\"host_player_id\":\"" + <>4__this._userProfile.id + "\"},{\"player_ids\":{\"$in\":[\"" + <>4__this._userProfile.id + "\"]}}],\"status\":\"pending_accept\"}";
						<fullUrl>5__2 = <>4__this.GetBaseApiUrl() + "/MatchmakingSession?q=" + UnityWebRequest.EscapeURL(<query>5__1);
						<>4__this.Log("<color=cyan>[Sync] GET /MatchmakingSession (checking for pending matches)</color>");
						<>4__this.Log("<color=cyan>[Sync] Full URL: " + <fullUrl>5__2.Substring(0, Math.Min(150, <fullUrl>5__2.Length)) + "...</color>");
						<req>5__3 = UnityWebRequest.Get(<fullUrl>5__2);
						<>1__state = -3;
						<>4__this.ApplyApiHeaders(<req>5__3);
						<>2__current = <req>5__3.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__3.result == 1)
						{
							<sessions>5__4 = <>4__this.ParseApiObjectList(<req>5__3.downloadHandler.text);
							<activeSession>5__5 = ((IEnumerable<JObject>)<sessions>5__4).FirstOrDefault((Func<JObject, bool>)((JObject session) => !string.IsNullOrEmpty((string)session["lobby_name"])));
							if (<activeSession>5__5 != null)
							{
								<>4__this._webStatus = "MATCH FOUND: PENDING";
								<>4__this.Log("Match Found! Accept needed.");
							}
							<sessions>5__4 = null;
							<activeSession>5__5 = null;
						}
						else
						{
							<>4__this.Log($"<color=red>[Sync] CheckForMatch failed: {<req>5__3.result} - {<req>5__3.error}</color>");
						}
						<>m__Finally1();
						<req>5__3 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__3 != null)
				{
					((IDisposable)<req>5__3).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <ClaimHostRoleCoroutine>d__107 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private string <json>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this._currentSession == null || <>4__this._userProfile == null)
					{
						return false;
					}
					if (<>4__this._isHost)
					{
						return false;
					}
					<>4__this.Log("<color=cyan>[PDS] Claiming host role for session " + <>4__this._currentSession.id + "...</color>");
					<json>5__1 = "{\"host_player_id\":\"" + <>4__this._userProfile.id + "\"}";
					<>2__current = <>4__this.CallAPI("/MatchmakingSession/" + <>4__this._currentSession.id, "PUT", <json>5__1, delegate(string res)
					{
						JObject val = <>4__this.ParseApiSingleObject(res);
						if (val != null)
						{
							<>4__this._currentSession.host_player_id = <>4__this._userProfile.id;
							<>4__this._isHost = true;
							<>4__this.Log("<color=green>[PDS] ✓ Host role claimed — session host_player_id set to our player ID.</color>");
						}
						else
						{
							<>4__this.Log("<color=red>[PDS] Failed to claim host role — API response was null.</color>");
						}
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <CreateMatchAndEntries>d__194 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this._matchCreationInProgress)
					{
						<>4__this.Log("<color=orange>[Match Creation] Already in progress - skipping duplicate call</color>");
						return false;
					}
					<>4__this._matchCreationInProgress = true;
					<>2__current = <>4__this.CreateMatchAndEntriesInternal();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this._matchCreationInProgress = false;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <CreateMatchAndEntriesInternal>d__195 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private bool <isManualLocalLobby>5__1;

			private string <currentMatchType>5__2;

			private bool <isCasualMatch>5__3;

			private string <activeSessionId>5__4;

			private Dictionary<string, int> <playerScores>5__5;

			private Dictionary<string, int> <playerScoresVsPar>5__6;

			private List<LiveLeaderboardPlugin.SBGLPlayer> <startingLeaderboard>5__7;

			private Dictionary<string, int> <startingPositionMap>5__8;

			private bool <isEffectiveHost>5__9;

			private List<string> <playerIds>5__10;

			private LiveLeaderboardPlugin <liveLeaderboard>5__11;

			private List<LiveLeaderboardPlugin.SBGLPlayer> <allLeaderboardPlayers>5__12;

			private List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator <>s__13;

			private LiveLeaderboardPlugin.SBGLPlayer <player>5__14;

			private string <strokeStr>5__15;

			private int <vsPar>5__16;

			private Exception <ex>5__17;

			private <>c__DisplayClass195_0 <>8__18;

			private float <waitElapsed>5__19;

			private float <nextApiCheckAt>5__20;

			private string <p2pId>5__21;

			private <>c__DisplayClass195_1 <>8__22;

			private <>c__DisplayClass195_2 <>8__23;

			private float <fallbackDelay>5__24;

			private string <prePostSessionId>5__25;

			private <>c__DisplayClass195_3 <>8__26;

			private string <finalCheckQuery>5__27;

			private <>c__DisplayClass195_4 <>8__28;

			private IEnumerable<ulong> <peers>5__29;

			private <>c__DisplayClass195_5 <>8__30;

			private List<string>.Enumerator <>s__31;

			private <>c__DisplayClass195_6 <>8__32;

			private <>c__DisplayClass195_7 <>8__33;

			private int <gamePoints>5__34;

			private int <scoreVsPar>5__35;

			private int <startingPosition>5__36;

			private int <score>5__37;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 11) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<currentMatchType>5__2 = null;
				<activeSessionId>5__4 = null;
				<playerScores>5__5 = null;
				<playerScoresVsPar>5__6 = null;
				<startingLeaderboard>5__7 = null;
				<startingPositionMap>5__8 = null;
				<playerIds>5__10 = null;
				<liveLeaderboard>5__11 = null;
				<allLeaderboardPlayers>5__12 = null;
				<>s__13 = default(List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator);
				<player>5__14 = null;
				<strokeStr>5__15 = null;
				<ex>5__17 = null;
				<>8__18 = null;
				<p2pId>5__21 = null;
				<>8__22 = null;
				<>8__23 = null;
				<prePostSessionId>5__25 = null;
				<>8__26 = null;
				<finalCheckQuery>5__27 = null;
				<>8__28 = null;
				<peers>5__29 = null;
				<>8__30 = null;
				<>s__31 = default(List<string>.Enumerator);
				<>8__32 = null;
				<>8__33 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0864: Unknown result type (might be due to invalid IL or missing references)
				//IL_086e: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (<>4__this._userProfile == null)
						{
							<>4__this.Log("<color=red>[Match Creation] Failed: Missing player profile</color>");
							return false;
						}
						<isManualLocalLobby>5__1 = <>4__this._currentSession == null;
						if (<isManualLocalLobby>5__1)
						{
							if (string.IsNullOrWhiteSpace(<>4__this._localManualSessionId))
							{
								<>4__this._localManualSessionId = <>4__this.BuildStableManualLocalSessionId();
							}
							<>4__this.Log("<color=cyan>[Match Creation] Manual local lobby detected. Session surrogate: " + <>4__this._localManualSessionId + "</color>");
						}
						<currentMatchType>5__2 = <>4__this._currentSession?.match_type ?? PlayerPrefs.GetString("MatchType", "");
						<isCasualMatch>5__3 = <>4__this.IsCurrentMatchCasual();
						if (IsProSeriesMatchType(<currentMatchType>5__2) || IsProSeriesMatchType(PlayerPrefs.GetString("MatchType", "")))
						{
							if (!<>4__this._proSeriesSkipLogged)
							{
								<>4__this.Log("<color=yellow>[Match] Pro Series match — automated upload skipped</color>");
								<>4__this._proSeriesSkipLogged = true;
							}
							<>4__this._matchEntriesCreated = true;
							return false;
						}
						<activeSessionId>5__4 = ((<>4__this._currentSession != null) ? <>4__this._currentSession.id : <>4__this._localManualSessionId);
						<>4__this.Log("<color=cyan>[Match Creation] Starting new match for session " + <activeSessionId>5__4 + "</color>");
						<>4__this._matchStartTime = DateTime.UtcNow;
						<playerScores>5__5 = new Dictionary<string, int>();
						<playerScoresVsPar>5__6 = new Dictionary<string, int>();
						<startingLeaderboard>5__7 = null;
						try
						{
							<liveLeaderboard>5__11 = Object.FindAnyObjectByType<LiveLeaderboardPlugin>((FindObjectsInactive)1);
							if ((Object)(object)<liveLeaderboard>5__11 != (Object)null)
							{
								<allLeaderboardPlayers>5__12 = <liveLeaderboard>5__11.GetCurrentLeaderboard();
								<startingLeaderboard>5__7 = new List<LiveLeaderboardPlugin.SBGLPlayer>(<allLeaderboardPlayers>5__12);
								<>4__this.Log($"<color=cyan>[Match Creation] Found {<allLeaderboardPlayers>5__12.Count} players on leaderboard</color>");
								<>s__13 = <allLeaderboardPlayers>5__12.GetEnumerator();
								try
								{
									while (<>s__13.MoveNext())
									{
										<player>5__14 = <>s__13.Current;
										if (<player>5__14 != null)
										{
											<playerScores>5__5[<player>5__14.Name] = <player>5__14.BaseScore;
											if (!string.IsNullOrEmpty(<player>5__14.RawStrokes))
											{
												<strokeStr>5__15 = <player>5__14.RawStrokes.Replace("±", "").Trim();
												int.TryParse(<strokeStr>5__15, out <vsPar>5__16);
												<playerScoresVsPar>5__6[<player>5__14.Name] = <vsPar>5__16;
												<strokeStr>5__15 = null;
											}
											<player>5__14 = null;
										}
									}
								}
								finally
								{
									((IDisposable)<>s__13).Dispose();
								}
								<>s__13 = default(List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator);
								<allLeaderboardPlayers>5__12 = null;
							}
							<liveLeaderboard>5__11 = null;
						}
						catch (Exception ex)
						{
							<ex>5__17 = ex;
							<>4__this.Log("<color=yellow>[Match Creation] Error prefetching leaderboard: " + <ex>5__17.Message + "</color>");
						}
						<>4__this._cachedLeaderboardScores = <playerScores>5__5;
						<>4__this._cachedLeaderboardScoresVsPar = <playerScoresVsPar>5__6;
						<>4__this._matchExpectedPlayerCount = <startingLeaderboard>5__7?.Count ?? 0;
						<startingPositionMap>5__8 = ((<startingLeaderboard>5__7 != null) ? <>4__this.BuildFinishPositionMap(<startingLeaderboard>5__7) : new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase));
						if (<isCasualMatch>5__3)
						{
							if (<startingLeaderboard>5__7 == null || <startingLeaderboard>5__7.Count == 0)
							{
								<>4__this.Log("<color=yellow>[Casual] Leaderboard is empty - deferring casual stat update until players appear</color>");
								if (<>4__this._monitorCoroutine == null)
								{
									<>4__this._monitorCoroutine = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.MonitorAndUpdateScores());
								}
								return false;
							}
							<>4__this.Log("<color=cyan>[Casual] Casual match detected - skipping Match/MatchEntry upload and incrementing player stats instead</color>");
							<>2__current = <>4__this.IncrementCasualMatchesPlayedForActivePlayers(<startingLeaderboard>5__7);
							<>1__state = 1;
							return true;
						}
						<isEffectiveHost>5__9 = <>4__this._isHost || NetworkServer.active;
						if (<isEffectiveHost>5__9)
						{
							<>4__this.Log("<color=cyan>[Match Creation] We are the host — creating Match record with priority</color>");
							if (<>4__this._currentSession != null)
							{
								<>8__18 = new <>c__DisplayClass195_0();
								<>8__18.existingMatchId = null;
								<>2__current = <>4__this.ResolveExistingMatchIdForCurrentSession(delegate(string id)
								{
									<>8__18.existingMatchId = id;
								});
								<>1__state = 2;
								return true;
							}
							goto IL_0a1e;
						}
						MatchResultSubmissionService.ReceivedP2PMatchId = null;
						<>4__this.Log("<color=cyan>[Match Creation] We are a client — waiting up to 12s for host to upload the match...</color>");
						<waitElapsed>5__19 = 0f;
						<nextApiCheckAt>5__20 = 2f;
						goto IL_089d;
					case 1:
						<>1__state = -1;
						if (<>4__this._monitorCoroutine != null)
						{
							((MonoBehaviour)<>4__this).StopCoroutine(<>4__this._monitorCoroutine);
							<>4__this._monitorCoroutine = null;
						}
						return false;
					case 2:
						<>1__state = -1;
						if (!string.IsNullOrEmpty(<>8__18.existingMatchId))
						{
							<>4__this._currentMatchId = <>8__18.existingMatchId;
							<>4__this.ShowUploadNotification("Match record already exists; reusing existing upload.");
							goto IL_0cf9;
						}
						<>8__18 = null;
						goto IL_0a1e;
					case 3:
						<>1__state = -1;
						if (!string.IsNullOrEmpty(<>8__22.apiMatchId))
						{
							<>4__this.Log($"<color=green>[Match Creation] ✓ Found host match via API at {<waitElapsed>5__19:0.#}s: {<>8__22.apiMatchId}</color>");
							<>4__this._currentMatchId = <>8__22.apiMatchId;
							<>4__this.ShowUploadNotification("Match record adopted from host.");
							goto IL_0cf9;
						}
						<>8__22 = null;
						goto IL_085e;
					case 4:
						<>1__state = -1;
						<waitElapsed>5__19 += 0.5f;
						<p2pId>5__21 = null;
						goto IL_089d;
					case 5:
						<>1__state = -1;
						goto IL_0992;
					case 6:
						<>1__state = -1;
						goto IL_0992;
					case 7:
						<>1__state = -1;
						if (!string.IsNullOrWhiteSpace(<>8__26.finalCheckId))
						{
							<>4__this.Log("<color=green>[Match Creation] ✓ Final pre-POST check found existing active match: " + <>8__26.finalCheckId + " — skipping duplicate POST</color>");
							<>4__this._currentMatchId = <>8__26.finalCheckId;
							if (<>4__this._currentSession != null)
							{
								<>4__this._currentSession.match_id = <>8__26.finalCheckId;
							}
							<>4__this.ShowUploadNotification("Match record already exists; reusing existing upload.");
							goto IL_0cf9;
						}
						<>8__26 = null;
						<finalCheckQuery>5__27 = null;
						goto IL_0bc9;
					case 8:
						<>1__state = -1;
						if (string.IsNullOrEmpty(<>8__28.newMatchId))
						{
							<>4__this.Log("<color=red>[Match Creation] Failed to create Match record</color>");
							<>4__this.ShowUploadNotification("Upload failed: could not create match record.", "failure");
							return false;
						}
						<>4__this._currentMatchId = <>8__28.newMatchId;
						<>4__this.Log("<color=green>[Match Creation] ✓ Match created: " + <>8__28.newMatchId + "</color>");
						<>4__this.ShowUploadNotification("Upload success: match record created.", "success");
						<peers>5__29 = CompetitivePluginCheck.GetKnownPeers();
						MatchResultSubmissionService.BroadcastMatchId(<>8__28.newMatchId, <peers>5__29);
						<>8__28 = null;
						<peers>5__29 = null;
						goto IL_0cf9;
					case 9:
						<>1__state = -1;
						<>8__30 = null;
						goto IL_0dd2;
					case 10:
						<>1__state = -1;
						<>4__this._matchExpectedPlayerCount = <playerIds>5__10.Count;
						<>s__31 = <playerIds>5__10.GetEnumerator();
						<>1__state = -3;
						goto IL_12ef;
					case 11:
						<>1__state = -3;
						goto IL_10e4;
					case 12:
						{
							<>1__state = -3;
							if (string.IsNullOrWhiteSpace(<>8__33.entryId))
							{
								<>4__this.Log("<color=yellow>[Match Creation] MatchEntry not ready yet for " + (<>8__33.playerName ?? <>8__33.CS$<>8__locals1.playerId) + "; gameplay monitor will retry if needed</color>");
							}
							<>8__33 = null;
							<>8__32 = null;
							goto IL_12ef;
						}
						IL_0cf9:
						if (<>4__this._currentSession != null)
						{
							<>8__30 = new <>c__DisplayClass195_5();
							<>8__30.<>4__this = <>4__this;
							<>8__30.linkMatchId = <>4__this._currentMatchId;
							<>2__current = <>4__this.CallAPI("/MatchmakingSession/" + <>4__this._currentSession.id, "PUT", "{\"match_id\":\"" + <>8__30.linkMatchId + "\"}", delegate(string res)
							{
								JObject val2 = <>8__30.<>4__this.ParseApiSingleObject(res);
								if (val2 != null)
								{
									<>8__30.<>4__this._currentSession.match_id = <>8__30.linkMatchId;
									<>8__30.<>4__this.Log("<color=green>[Match Creation] ✓ MatchmakingSession " + <>8__30.<>4__this._currentSession.id + " linked to match: " + <>8__30.linkMatchId + "</color>");
								}
								else
								{
									<>8__30.<>4__this.Log("<color=yellow>[Match Creation] Could not confirm MatchmakingSession update</color>");
								}
							});
							<>1__state = 9;
							return true;
						}
						<>4__this.Log("<color=cyan>[Match Creation] Local lobby mode: skipping MatchmakingSession link</color>");
						goto IL_0dd2;
						IL_12ef:
						if (<>s__31.MoveNext())
						{
							<>8__32 = new <>c__DisplayClass195_6();
							<>8__32.<>4__this = <>4__this;
							<>8__32.playerId = <>s__31.Current;
							<>8__33 = new <>c__DisplayClass195_7();
							<>8__33.CS$<>8__locals1 = <>8__32;
							<>8__33.playerName = null;
							<>8__33.preMatchMmr = null;
							<gamePoints>5__34 = 0;
							<scoreVsPar>5__35 = 0;
							if (<>8__33.CS$<>8__locals1.playerId == <>4__this._userProfile.id)
							{
								<>8__33.playerName = <>4__this._userProfile.display_name;
								<>8__33.preMatchMmr = <>4__this._userProfile.current_mmr.ToString();
								<>4__this.Log("<color=cyan>[Match Creation] Current player: " + <>8__33.playerName + " (MMR: " + <>8__33.preMatchMmr + ")</color>");
								goto IL_10e4;
							}
							<>2__current = <>4__this.CallAPI("/Player/" + <>8__33.CS$<>8__locals1.playerId, "GET", "", delegate(string res)
							{
								try
								{
									JObject val = <>8__33.CS$<>8__locals1.<>4__this.ParseApiSingleObject(res);
									if (val != null)
									{
										<>8__33.playerName = (string)val["display_name"];
										if (string.IsNullOrEmpty(<>8__33.playerName))
										{
											<>8__33.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Player " + <>8__33.CS$<>8__locals1.playerId + " has no display_name, using ID</color>");
											<>8__33.playerName = <>8__33.CS$<>8__locals1.playerId;
										}
										object obj2 = val["current_mmr"];
										if (obj2 != null)
										{
											<>8__33.preMatchMmr = obj2.ToString();
										}
										<>8__33.CS$<>8__locals1.<>4__this.Log("<color=cyan>[Match Creation] Fetched player: " + <>8__33.playerName + " (MMR: " + <>8__33.preMatchMmr + ")</color>");
									}
									else
									{
										<>8__33.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Failed to fetch Player " + <>8__33.CS$<>8__locals1.playerId + " - response null</color>");
										<>8__33.playerName = <>8__33.CS$<>8__locals1.playerId;
									}
								}
								catch (Exception ex2)
								{
									<>8__33.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Error fetching Player " + <>8__33.CS$<>8__locals1.playerId + ": " + ex2.Message + "</color>");
									<>8__33.playerName = <>8__33.CS$<>8__locals1.playerId;
								}
							});
							<>1__state = 11;
							return true;
						}
						<>m__Finally1();
						<>s__31 = default(List<string>.Enumerator);
						<>4__this._matchEntriesCreated = true;
						<>4__this.Log("<color=green>[Match Creation] ✓ Match and entries initialized. Starting score monitoring...</color>");
						if (<>4__this._monitorCoroutine == null)
						{
							<>4__this._monitorCoroutine = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.MonitorAndUpdateScores());
						}
						return false;
						IL_0a1e:
						<>4__this.Log("<color=cyan>[Match Creation] No existing Match found — proceeding with POST</color>");
						<prePostSessionId>5__25 = ((<>4__this._currentSession != null) ? <>4__this._currentSession.id : <>4__this._localManualSessionId);
						if (!string.IsNullOrWhiteSpace(<prePostSessionId>5__25))
						{
							<>8__26 = new <>c__DisplayClass195_3();
							<>8__26.<>4__this = <>4__this;
							<>8__26.finalCheckId = null;
							<finalCheckQuery>5__27 = UnityWebRequest.EscapeURL("{\"matchmaking_session_id\":\"" + <prePostSessionId>5__25 + "\"}");
							<>2__current = <>4__this.CallAPI("/Match?q=" + <finalCheckQuery>5__27 + "&sort_by=created_date", "GET", "", delegate(string res)
							{
								JObject obj = <>8__26.<>4__this.SelectNewestReusableMatch(<>8__26.<>4__this.ParseApiObjectList(res));
								<>8__26.finalCheckId = (string)((obj != null) ? obj["id"] : null);
							});
							<>1__state = 7;
							return true;
						}
						goto IL_0bc9;
						IL_089d:
						if (<waitElapsed>5__19 < 12f)
						{
							<p2pId>5__21 = MatchResultSubmissionService.ReceivedP2PMatchId;
							if (!string.IsNullOrEmpty(<p2pId>5__21))
							{
								<>4__this.Log("<color=green>[Match Creation] ✓ Received P2P Match ID from host: " + <p2pId>5__21 + "</color>");
								<>4__this._currentMatchId = <p2pId>5__21;
								if (<>4__this._currentSession != null)
								{
									<>4__this._currentSession.match_id = <p2pId>5__21;
								}
								<>4__this.ShowUploadNotification("Match record adopted from host via P2P.");
								goto IL_0cf9;
							}
							if (<>4__this._currentSession != null && <waitElapsed>5__19 >= <nextApiCheckAt>5__20)
							{
								<>8__22 = new <>c__DisplayClass195_1();
								<nextApiCheckAt>5__20 += 2f;
								<>8__22.apiMatchId = null;
								<>2__current = <>4__this.ResolveExistingMatchIdForCurrentSession(delegate(string id)
								{
									<>8__22.apiMatchId = id;
								}, logMisses: false);
								<>1__state = 3;
								return true;
							}
							goto IL_085e;
						}
						<>4__this.Log("<color=yellow>[Match Creation] Host did not upload within 12s — non-host fallback slot ordering...</color>");
						if (<>4__this._currentSession != null)
						{
							<>8__23 = new <>c__DisplayClass195_2();
							<fallbackDelay>5__24 = <>4__this.GetCurrentPlayerMatchUploadDelaySeconds();
							<>8__23.fallbackFoundId = null;
							if (<fallbackDelay>5__24 > 0f)
							{
								<>2__current = <>4__this.WaitForExistingMatchBeforeFallback(<fallbackDelay>5__24, delegate(string id)
								{
									<>8__23.fallbackFoundId = id;
								});
								<>1__state = 5;
								return true;
							}
							<>2__current = <>4__this.ResolveExistingMatchIdForCurrentSession(delegate(string id)
							{
								<>8__23.fallbackFoundId = id;
							}, logMisses: false);
							<>1__state = 6;
							return true;
						}
						goto IL_0a0c;
						IL_0992:
						if (!string.IsNullOrEmpty(<>8__23.fallbackFoundId))
						{
							<>4__this.Log("<color=green>[Match Creation] ✓ Match adopted in non-host fallback: " + <>8__23.fallbackFoundId + "</color>");
							<>4__this._currentMatchId = <>8__23.fallbackFoundId;
							<>4__this.ShowUploadNotification("Match record adopted from another player.");
							goto IL_0cf9;
						}
						<>8__23 = null;
						goto IL_0a0c;
						IL_10e4:
						if (!string.IsNullOrEmpty(<>8__33.playerName))
						{
							<>4__this._playerIdsByName[<>8__33.playerName] = <>8__33.CS$<>8__locals1.playerId;
							if (<>4__this._cachedLeaderboardScores.TryGetValue(<>8__33.playerName, out <score>5__37))
							{
								<gamePoints>5__34 = <score>5__37;
								<>4__this._cachedLeaderboardScoresVsPar.TryGetValue(<>8__33.playerName, out <scoreVsPar>5__35);
							}
							<>4__this._lastSubmittedScores[<>8__33.playerName] = <gamePoints>5__34;
							<>4__this._lastSubmittedScoresVsPar[<>8__33.playerName] = <scoreVsPar>5__35;
						}
						<startingPosition>5__36 = 0;
						if (!string.IsNullOrWhiteSpace(<>8__33.playerName))
						{
							<startingPositionMap>5__8.TryGetValue(<>8__33.playerName, out <startingPosition>5__36);
						}
						<>8__33.entryId = null;
						<>2__current = <>4__this.EnsureMatchEntryForPlayer("Match Creation", <>8__33.CS$<>8__locals1.playerId, <>8__33.playerName, <>8__33.preMatchMmr, null, <gamePoints>5__34, <scoreVsPar>5__35, <startingPosition>5__36, "Progressive match tracking - created at round start", delegate(string id)
						{
							<>8__33.entryId = id;
						});
						<>1__state = 12;
						return true;
						IL_0bc9:
						<prePostSessionId>5__25 = null;
						<>8__28 = new <>c__DisplayClass195_4();
						<>8__28.newMatchId = null;
						<>2__current = <>4__this.SubmitMatchEntry(<>4__this.CollectMatchStats(0f), delegate(string id)
						{
							<>8__28.newMatchId = id;
						});
						<>1__state = 8;
						return true;
						IL_0dd2:
						<>4__this._playerMatchEntryIds.Clear();
						<>4__this._playerIdsByName.Clear();
						<>4__this._lastSubmittedScores.Clear();
						<>4__this._lastSubmittedScoresVsPar.Clear();
						if (<startingLeaderboard>5__7 == null || <startingLeaderboard>5__7.Count == 0)
						{
							<>4__this.Log("<color=yellow>[Match Creation] Leaderboard empty at round start — deferring MatchEntry creation until the gameplay monitor sees players</color>");
							if (<>4__this._monitorCoroutine == null)
							{
								<>4__this._monitorCoroutine = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.MonitorAndUpdateScores());
							}
							return false;
						}
						<playerIds>5__10 = ((<>4__this._currentSession != null && <>4__this._currentSession.player_ids != null && <>4__this._currentSession.player_ids.Count > 0) ? <>4__this._currentSession.player_ids : new List<string> { <>4__this._userProfile.id });
						<>2__current = <>4__this.EnrichPlayerIdsFromLeaderboard(<startingLeaderboard>5__7, <playerIds>5__10);
						<>1__state = 10;
						return true;
						IL_085e:
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 4;
						return true;
						IL_0a0c:
						<>4__this.Log("<color=cyan>[Match Creation] No match found in non-host fallback — posting as fallback creator</color>");
						goto IL_0a1e;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__31).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <CreatePlaceholderMatchEntryForMissingSessionPlayer>d__212 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string playerId;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass212_0 <>8__1;

			private int <gamePoints>5__2;

			private int <scoreVsPar>5__3;

			private int <lastScore>5__4;

			private int <lastVsPar>5__5;

			private int <cachedScore>5__6;

			private int <cachedVsPar>5__7;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass212_0();
					<>8__1.<>4__this = <>4__this;
					if (string.IsNullOrWhiteSpace(playerId) || string.IsNullOrWhiteSpace(<>4__this._currentMatchId))
					{
						return false;
					}
					<>8__1.playerName = null;
					<>8__1.preMatchMmr = null;
					if (<>4__this._userProfile != null && string.Equals(playerId, <>4__this._userProfile.id, StringComparison.OrdinalIgnoreCase))
					{
						<>8__1.playerName = <>4__this._userProfile.display_name;
						<>8__1.preMatchMmr = <>4__this._userProfile.current_mmr.ToString();
						goto IL_0149;
					}
					<>2__current = <>4__this.CallAPI("/Player/" + playerId, "GET", "", delegate(string res)
					{
						JObject val = <>8__1.<>4__this.ParseApiSingleObject(res);
						if (val != null)
						{
							<>8__1.playerName = (string)val["display_name"];
							object obj = val["current_mmr"];
							if (obj != null)
							{
								<>8__1.preMatchMmr = obj.ToString();
							}
						}
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					goto IL_0149;
				case 2:
					{
						<>1__state = -1;
						if (!string.IsNullOrEmpty(<>8__1.entryId))
						{
							<>4__this._playerMatchEntryIds[playerId] = <>8__1.entryId;
							<>4__this._playerIdsByName[<>8__1.playerName.Trim()] = playerId;
							<>4__this._lastSubmittedScores[<>8__1.playerName] = <gamePoints>5__2;
							<>4__this._lastSubmittedScoresVsPar[<>8__1.playerName] = <scoreVsPar>5__3;
						}
						else
						{
							<>4__this.Log("<color=yellow>[Match Finalize] Could not create placeholder MatchEntry for missing session player " + <>8__1.playerName + "</color>");
						}
						return false;
					}
					IL_0149:
					if (string.IsNullOrWhiteSpace(<>8__1.playerName))
					{
						<>8__1.playerName = playerId;
					}
					<gamePoints>5__2 = 0;
					<scoreVsPar>5__3 = 0;
					if (<>4__this._lastSubmittedScores.TryGetValue(<>8__1.playerName, out <lastScore>5__4))
					{
						<gamePoints>5__2 = <lastScore>5__4;
					}
					else if (<>4__this._cachedLeaderboardScores.TryGetValue(<>8__1.playerName, out <cachedScore>5__6))
					{
						<gamePoints>5__2 = <cachedScore>5__6;
					}
					if (<>4__this._lastSubmittedScoresVsPar.TryGetValue(<>8__1.playerName, out <lastVsPar>5__5))
					{
						<scoreVsPar>5__3 = <lastVsPar>5__5;
					}
					else if (<>4__this._cachedLeaderboardScoresVsPar.TryGetValue(<>8__1.playerName, out <cachedVsPar>5__7))
					{
						<scoreVsPar>5__3 = <cachedVsPar>5__7;
					}
					if (<gamePoints>5__2 == 0)
					{
						<>4__this.Log("<color=yellow>[Match Finalize] Skipping placeholder for session player " + <>8__1.playerName + " — game points is 0</color>");
						return false;
					}
					<>8__1.entryId = null;
					<>2__current = <>4__this.EnsureMatchEntryForPlayer("Match Finalize", playerId, <>8__1.playerName, <>8__1.preMatchMmr, null, <gamePoints>5__2, <scoreVsPar>5__3, 0, "Placeholder entry created because player was in the session but missing from the final leaderboard snapshot", delegate(string id)
					{
						<>8__1.entryId = id;
					});
					<>1__state = 2;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <DownloadProfilePic>d__228 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string url;

			public SBGLPlugin <>4__this;

			private UnityWebRequest <req>5__1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<req>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<req>5__1 = UnityWebRequestTexture.GetTexture(url.Replace("http://", "https://"));
						<>1__state = -3;
						<>2__current = <req>5__1.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__1.result == 1)
						{
							<>4__this._profileTexture = DownloadHandlerTexture.GetContent(<req>5__1);
						}
						<>4__this._hasFetchedProfilePic = true;
						<>m__Finally1();
						<req>5__1 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__1 != null)
				{
					((IDisposable)<req>5__1).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <EnrichPlayerIdsFromLeaderboard>d__210 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<LiveLeaderboardPlugin.SBGLPlayer> startingLeaderboard;

			public List<string> playerIds;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass210_0 <>8__1;

			private List<string> <leaderboardNames>5__2;

			private Dictionary<string, string> <testOverrides>5__3;

			private HashSet<string> <knownIds>5__4;

			private List<string>.Enumerator <>s__5;

			private string <existingId>5__6;

			private List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator <>s__7;

			private LiveLeaderboardPlugin.SBGLPlayer <lbPlayer>5__8;

			private <>c__DisplayClass210_1 <>8__9;

			private string <lookupName>5__10;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<>8__1 = null;
				<leaderboardNames>5__2 = null;
				<testOverrides>5__3 = null;
				<knownIds>5__4 = null;
				<>s__5 = default(List<string>.Enumerator);
				<existingId>5__6 = null;
				<>s__7 = default(List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator);
				<lbPlayer>5__8 = null;
				<>8__9 = null;
				<lookupName>5__10 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass210_0();
						<>8__1.<>4__this = <>4__this;
						if (startingLeaderboard == null || startingLeaderboard.Count == 0 || playerIds == null)
						{
							return false;
						}
						<leaderboardNames>5__2 = (from p in startingLeaderboard?.Where((LiveLeaderboardPlugin.SBGLPlayer p) => p != null && !string.IsNullOrWhiteSpace(p.Name))
							select p.Name).ToList() ?? new List<string>();
						<testOverrides>5__3 = <>4__this.GetTestPlayerOverrides(<leaderboardNames>5__2);
						if (<testOverrides>5__3.Count > 0)
						{
							<>4__this.Log($"<color=magenta>[Test Override] {<testOverrides>5__3.Count} player override(s) active for this match</color>");
						}
						<knownIds>5__4 = new HashSet<string>(playerIds.Where((string id) => !string.IsNullOrWhiteSpace(id)), StringComparer.OrdinalIgnoreCase);
						<>8__1.knownNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
						if (<>4__this._userProfile != null && !string.IsNullOrWhiteSpace(<>4__this._userProfile.display_name) && !string.IsNullOrWhiteSpace(<>4__this._userProfile.id))
						{
							<>8__1.knownNames.Add(<>4__this._userProfile.display_name);
							<knownIds>5__4.Add(<>4__this._userProfile.id);
							if (!playerIds.Contains(<>4__this._userProfile.id))
							{
								playerIds.Add(<>4__this._userProfile.id);
							}
						}
						<>s__5 = <knownIds>5__4.ToList().GetEnumerator();
						<>1__state = -3;
						goto IL_032e;
					case 1:
						<>1__state = -3;
						<existingId>5__6 = null;
						goto IL_032e;
					case 2:
						{
							<>1__state = -4;
							if (!string.IsNullOrWhiteSpace(<>8__9.playerIdFromName))
							{
								<>8__1.knownNames.Add(<lbPlayer>5__8.Name);
								if (<knownIds>5__4.Add(<>8__9.playerIdFromName))
								{
									playerIds.Add(<>8__9.playerIdFromName);
									<>4__this.Log("<color=cyan>[Match Creation] Resolved leaderboard player " + <lbPlayer>5__8.Name + " -> " + <>8__9.playerIdFromName + "</color>");
								}
							}
							else
							{
								<>4__this.Log("<color=yellow>[Match Creation] Could not resolve leaderboard player '" + <lbPlayer>5__8.Name + "' to a Player ID</color>");
							}
							<>8__9 = null;
							<lookupName>5__10 = null;
							<lbPlayer>5__8 = null;
							break;
						}
						IL_032e:
						while (<>s__5.MoveNext())
						{
							<existingId>5__6 = <>s__5.Current;
							if (<>4__this._userProfile != null && string.Equals(<existingId>5__6, <>4__this._userProfile.id, StringComparison.OrdinalIgnoreCase))
							{
								continue;
							}
							<>2__current = <>4__this.CallAPI("/Player/" + <existingId>5__6, "GET", "", delegate(string res)
							{
								JObject val = <>8__1.<>4__this.ParseApiSingleObject(res);
								string text = (string)((val != null) ? val["display_name"] : null);
								if (!string.IsNullOrWhiteSpace(text))
								{
									<>8__1.knownNames.Add(text);
								}
							});
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>s__5 = default(List<string>.Enumerator);
						<>s__7 = startingLeaderboard.GetEnumerator();
						<>1__state = -4;
						break;
					}
					while (<>s__7.MoveNext())
					{
						<lbPlayer>5__8 = <>s__7.Current;
						<>8__9 = new <>c__DisplayClass210_1();
						if (<lbPlayer>5__8 == null || string.IsNullOrWhiteSpace(<lbPlayer>5__8.Name) || <>8__1.knownNames.Contains(<lbPlayer>5__8.Name))
						{
							continue;
						}
						<lookupName>5__10 = <>4__this.ApplyTestPlayerOverride(<lbPlayer>5__8.Name, <testOverrides>5__3);
						<>8__9.playerIdFromName = null;
						<>2__current = <>4__this.ResolvePlayerIdByNameFromApi(<lookupName>5__10, delegate(string id)
						{
							<>8__9.playerIdFromName = id;
						});
						<>1__state = 2;
						return true;
					}
					<>m__Finally2();
					<>s__7 = default(List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__5).Dispose();
			}

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>s__7).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <EnsureMatchEntryForPlayer>d__169 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string sourceTag;

			public string playerId;

			public string playerName;

			public string preMatchMmr;

			public string postMatchMmr;

			public int gamePoints;

			public int scoreVsPar;

			public int finishPosition;

			public string notes;

			public Action<string> onResolved;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass169_0 <>8__1;

			private string <cachedEntryId>5__2;

			private <>c__DisplayClass169_1 <>8__3;

			private string <resolvedPlayerName>5__4;

			private int <adjustedScore>5__5;

			private JObject <payload>5__6;

			private float <preMmr>5__7;

			private float <postMmr>5__8;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 2) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<cachedEntryId>5__2 = null;
				<>8__3 = null;
				<resolvedPlayerName>5__4 = null;
				<payload>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_038f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0394: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03de: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_040c: 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_043a: Unknown result type (might be due to invalid IL or missing references)
				//IL_045f: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass169_0();
						<>8__1.<>4__this = <>4__this;
						<>8__1.sourceTag = sourceTag;
						if (string.IsNullOrWhiteSpace(<>4__this._currentMatchId) || string.IsNullOrWhiteSpace(playerId))
						{
							onResolved?.Invoke(null);
							result = false;
							break;
						}
						if (<>4__this._playerMatchEntryIds.TryGetValue(playerId, out <cachedEntryId>5__2) && !string.IsNullOrWhiteSpace(<cachedEntryId>5__2))
						{
							onResolved?.Invoke(<cachedEntryId>5__2);
							result = false;
							break;
						}
						if (<>4__this._matchEntryCreationInProgress.Contains(playerId))
						{
							<>2__current = <>4__this.WaitForPendingMatchEntryCreation(playerId, onResolved);
							<>1__state = 1;
							result = true;
							break;
						}
						<>4__this._matchEntryCreationInProgress.Add(playerId);
						<>1__state = -3;
						<>8__3 = new <>c__DisplayClass169_1();
						<>8__3.CS$<>8__locals1 = <>8__1;
						<>8__3.existingEntryId = null;
						<>2__current = <>4__this.ResolveExistingMatchEntryId(<>4__this._currentMatchId, playerId, delegate(string id)
						{
							<>8__3.existingEntryId = id;
						});
						<>1__state = 2;
						result = true;
						break;
					case 1:
						<>1__state = -1;
						result = false;
						break;
					case 2:
						<>1__state = -3;
						<resolvedPlayerName>5__4 = (string.IsNullOrWhiteSpace(playerName) ? playerId : playerName.Trim());
						if (!string.IsNullOrWhiteSpace(<>8__3.existingEntryId))
						{
							<>4__this._playerMatchEntryIds[playerId] = <>8__3.existingEntryId;
							if (!string.IsNullOrWhiteSpace(<resolvedPlayerName>5__4))
							{
								<>4__this._playerIdsByName[<resolvedPlayerName>5__4] = playerId;
							}
							<>4__this.Log("<color=green>[" + <>8__3.CS$<>8__locals1.sourceTag + "] ✓ Adopted existing MatchEntry for " + <resolvedPlayerName>5__4 + ": " + <>8__3.existingEntryId + "</color>");
							onResolved?.Invoke(<>8__3.existingEntryId);
							result = false;
						}
						else
						{
							<adjustedScore>5__5 = gamePoints + scoreVsPar * -10;
							if (gamePoints != 0)
							{
								<payload>5__6 = new JObject
								{
									["match_id"] = JToken.op_Implicit(<>4__this._currentMatchId),
									["player_id"] = JToken.op_Implicit(playerId),
									["player_name"] = JToken.op_Implicit(<resolvedPlayerName>5__4),
									["game_points"] = JToken.op_Implicit(gamePoints),
									["over_under"] = JToken.op_Implicit(scoreVsPar),
									["score_vs_par"] = JToken.op_Implicit(scoreVsPar),
									["adjusted_match_score"] = JToken.op_Implicit(<adjustedScore>5__5),
									["notes"] = JToken.op_Implicit(notes ?? string.Empty)
								};
								<preMmr>5__7 = 0f;
								<postMmr>5__8 = 0f;
								if (!string.IsNullOrWhiteSpace(preMatchMmr) && float.TryParse(preMatchMmr, NumberStyles.Float, CultureInfo.InvariantCulture, out <preMmr>5__7))
								{
									<payload>5__6["pre_match_mmr"] = JToken.op_Implicit(<preMmr>5__7);
								}
								if (!string.IsNullOrWhiteSpace(postMatchMmr) && float.TryParse(postMatchMmr, NumberStyles.Float, CultureInfo.InvariantCulture, out <postMmr>5__8))
								{
									<payload>5__6["post_match_mmr"] = JToken.op_Implicit(<postMmr>5__8);
									<payload>5__6["mmr_change"] = JToken.op_Implicit(<postMmr>5__8 - <preMmr>5__7);
								}
								if (finishPosition > 0)
								{
									<payload>5__6["finish_position"] = JToken.op_Implicit(finishPosition);
								}
								<>8__3.createdEntryId = null;
								<>2__current = <>4__this.CallAPI("/MatchEntry", "POST", ((JToken)<payload>5__6).ToString((Formatting)0, Array.Empty<JsonConverter>()), delegate(string res)
								{
									try
									{
										JObject val = <>8__3.CS$<>8__locals1.<>4__this.ParseApiSingleObject(res);
										if (val != null)
										{
											<>8__3.createdEntryId = (string)val["id"];
										}
									}
									catch (Exception ex)
									{
										<>8__3.CS$<>8__locals1.<>4__this.Log("<color=yellow>[" + <>8__3.CS$<>8__locals1.sourceTag + "] Could not parse MatchEntry response: " + ex.Message + "</color>");
									}
								});
								<>1__state = 3;
								result = true;
								break;
							}
							<>4__this.Log("<color=yellow>[" + <>8__3.CS$<>8__locals1.sourceTag + "] Skipping MatchEntry POST for " + <resolvedPlayerName>5__4 + " — score is 0</color>");
							onResolved?.Invoke(null);
							result = false;
						}
						<>m__Finally1();
						break;
					case 3:
						<>1__state = -3;
						if (!string.IsNullOrWhiteSpace(<>8__3.createdEntryId))
						{
							<>4__this._playerMatchEntryIds[playerId] = <>8__3.createdEntryId;
							if (!string.IsNullOrWhiteSpace(<resolvedPlayerName>5__4))
							{
								<>4__this._playerIdsByName[<resolvedPlayerName>5__4] = playerId;
							}
							<>4__this.Log("<color=green>[" + <>8__3.CS$<>8__locals1.sourceTag + "] ✓ MatchEntry created for " + <resolvedPlayerName>5__4 + ": " + <>8__3.createdEntryId + "</color>");
						}
						onResolved?.Invoke(<>8__3.createdEntryId);
						<>8__3 = null;
						<resolvedPlayerName>5__4 = null;
						<payload>5__6 = null;
						<>m__Finally1();
						result = false;
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				<>4__this._matchEntryCreationInProgress.Remove(playerId);
			}

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

		[CompilerGenerated]
		private sealed class <EnsureUserProfileResolved>d__178 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string logContext;

			public float maxWaitSeconds;

			public SBGLPlugin <>4__this;

			private bool <attemptedSteamLookup>5__1;

			private float <waited>5__2;

			private string <steamName>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this._userProfile != null)
					{
						return false;
					}
					<attemptedSteamLookup>5__1 = false;
					<waited>5__2 = 0f;
					goto IL_01b1;
				case 1:
					<>1__state = -1;
					if (<>4__this._userProfile != null || <>4__this.TryUseSharedProfile(logContext))
					{
						return false;
					}
					goto IL_015c;
				case 2:
					{
						<>1__state = -1;
						<waited>5__2 += 0.5f;
						goto IL_01b1;
					}
					IL_01b1:
					if (<>4__this._userProfile == null)
					{
						if (<>4__this.TryUseSharedProfile(logContext))
						{
							return false;
						}
						if (!<attemptedSteamLookup>5__1)
						{
							<steamName>5__3 = <>4__this.TryGetSteamPlayerName();
							if (!string.IsNullOrWhiteSpace(<steamName>5__3) && <steamName>5__3 != "Player")
							{
								<attemptedSteamLookup>5__1 = true;
								<>4__this.Log("<color=cyan>[" + logContext + "] Attempting local profile resolution for '" + <steamName>5__3 + "'</color>");
								<>2__current = <>4__this.ResolveProfile(<steamName>5__3);
								<>1__state = 1;
								return true;
							}
							goto IL_015c;
						}
						goto IL_0164;
					}
					return false;
					IL_015c:
					<steamName>5__3 = null;
					goto IL_0164;
					IL_0164:
					if (<waited>5__2 >= maxWaitSeconds)
					{
						return false;
					}
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 2;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <FetchActiveSeasonId>d__215 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private string <query>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this._activeSeasonFetched = true;
					<query>5__1 = UnityWebRequest.EscapeURL("{\"status\":\"Active\"}");
					<>2__current = <>4__this.CallAPI("/Season?q=" + <query>5__1 + "&limit=1", "GET", "", delegate(string res)
					{
						if (string.IsNullOrEmpty(res))
						{
							return;
						}
						try
						{
							JToken val = JToken.Parse(res);
							JArray val2 = (JArray)(object)((val is JArray) ? val : null);
							JObject val3 = (JObject)((val2 != null) ? ((object)((IEnumerable)val2).OfType<JObject>().FirstOrDefault()) : ((object)((val is JObject) ? val : null)));
							string text = ((val3 == null) ? null : ((object)val3["id"])?.ToString());
							if (!string.IsNullOrEmpty(text))
							{
								<>4__this._activeSeasonId = text;
								<>4__this.Log("<color=cyan>[Season] Active season resolved: " + text + "</color>");
							}
							else
							{
								<>4__this.Log("<color=yellow>[Season] No active season found in API — falling back to hardcoded ID</color>");
							}
						}
						catch (Exception ex)
						{
							<>4__this.Log("<color=orange>[Season] Error parsing season response: " + ex.Message + "</color>");
						}
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <FinalizeAndResetAfterDrivingRange>d__170 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!<>4__this._matchStatsSubmitted && !string.IsNullOrEmpty(<>4__this._currentMatchId))
					{
						<>2__current = <>4__this.FinalizeMatchStats();
						<>1__state = 1;
						return true;
					}
					goto IL_007e;
				case 1:
					<>1__state = -1;
					goto IL_007e;
				case 2:
					<>1__state = -1;
					if (IsRankedTriggered && <>4__this._currentSession != null)
					{
						<>2__current = <>4__this.UpdateSessionStatus("completed");
						<>1__state = 3;
						return true;
					}
					break;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_007e:
					<>2__current = <>4__this.UploadCapturedMatchScreenshotIfNeeded("Driving Range fallback");
					<>1__state = 2;
					return true;
				}
				if (!string.IsNullOrWhiteSpace(<>4__this._currentMatchId))
				{
					<>4__this._finalizedMatchIds.Add(<>4__this._currentMatchId);
				}
				<>4__this.ResetPerMatchState();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <FinalizeFromGameplaySignal>d__144 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string source;

			public SBGLPlugin <>4__this;

			private int <attempt>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.Log("<color=cyan>[Match Signal] " + source + " detected - attempting early end-of-match finalization...</color>");
					<>4__this.StopGameplayCoroutinesForMatchEnd(source);
					<>2__current = <>4__this.CaptureMatchScreenshotForReview(source);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<attempt>5__1 = 0;
					goto IL_00ff;
				case 2:
					<>1__state = -1;
					<attempt>5__1++;
					goto IL_00ff;
				case 3:
					<>1__state = -1;
					<>4__this.Log("<color=yellow>[Match Signal] " + source + " did not yield a final snapshot yet - falling back to Driving Range finalization</color>");
					<>4__this._endOfMatchSignalCoroutine = null;
					return false;
				case 4:
					<>1__state = -1;
					if (IsRankedTriggered && <>4__this._currentSession != null)
					{
						<>2__current = <>4__this.UpdateSessionStatus("completed");
						<>1__state = 5;
						return true;
					}
					goto IL_0229;
				case 5:
					<>1__state = -1;
					goto IL_0229;
				case 6:
					{
						<>1__state = -1;
						<>4__this._endOfMatchSignalCoroutine = null;
						return false;
					}
					IL_0229:
					<>2__current = <>4__this.UploadCapturedMatchScreenshotIfNeeded(source);
					<>1__state = 6;
					return true;
					IL_00ff:
					if (<attempt>5__1 < 12 && !<>4__this.TryCaptureFinalLeaderboardSnapshot(source))
					{
						<>2__current = (object)new WaitForSeconds(0.25f);
						<>1__state = 2;
						return true;
					}
					if (<>4__this._finalLeaderboardSnapshot == null || <>4__this._finalLeaderboardSnapshot.Count == 0)
					{
						<>2__current = <>4__this.UploadCapturedMatchScreenshotIfNeeded(source + " (no final snapshot yet)");
						<>1__state = 3;
						return true;
					}
					if (!<>4__this._matchStatsSubmitted && !string.IsNullOrWhiteSpace(<>4__this._currentMatchId))
					{
						<>2__current = <>4__this.FinalizeMatchStats();
						<>1__state = 4;
						return true;
					}
					goto IL_0229;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <FinalizeMatchStats>d__211 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass211_0 <>8__1;

			private int <finalPlayerCount>5__2;

			private List<string> <leaderboardNames>5__3;

			private Dictionary<string, string> <testOverrides>5__4;

			private Dictionary<string, int> <finalPositionMap>5__5;

			private List<CachedLeaderboardPlayer>.Enumerator <>s__6;

			private <>c__DisplayClass211_1 <>8__7;

			private float <snapMmr>5__8;

			private string <resolveId>5__9;

			private List<CachedLeaderboardPlayer>.Enumerator <>s__10;

			private CachedLeaderboardPlayer <player>5__11;

			private <>c__DisplayClass211_2 <>8__12;

			private int <finalGamePoints>5__13;

			private int <finalScoreVsPar>5__14;

			private int <finishPosition>5__15;

			private string <cachedPreMmr>5__16;

			private string <cachedPostMmr>5__17;

			private float <resolvedPreMmr>5__18;

			private <>c__DisplayClass211_3 <>8__19;

			private string <finalizeLookupName>5__20;

			private int <expectedPlayerCount>5__21;

			private IEnumerator<string> <>s__22;

			private string <sessionPlayerId>5__23;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 3:
				case 4:
				case 5:
				case 6:
				case 7:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				case -5:
				case 8:
					try
					{
					}
					finally
					{
						<>m__Finally3();
					}
					break;
				}
				<>8__1 = null;
				<leaderboardNames>5__3 = null;
				<testOverrides>5__4 = null;
				<finalPositionMap>5__5 = null;
				<>s__6 = default(List<CachedLeaderboardPlayer>.Enumerator);
				<>8__7 = null;
				<resolveId>5__9 = null;
				<>s__10 = default(List<CachedLeaderboardPlayer>.Enumerator);
				<player>5__11 = null;
				<>8__12 = null;
				<cachedPreMmr>5__16 = null;
				<cachedPostMmr>5__17 = null;
				<>8__19 = null;
				<finalizeLookupName>5__20 = null;
				<>s__22 = null;
				<sessionPlayerId>5__23 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass211_0();
						<>8__1.<>4__this = <>4__this;
						if (IsProSeriesMatchType(PlayerPrefs.GetString("MatchType", "")) || <>4__this.IsCurrentMatchCasual())
						{
							<>4__this._matchStatsSubmitted = true;
							return false;
						}
						<>4__this.Log("<color=cyan>[Match Finalize] Performing final score update...</color>");
						if (<>4__this._finalLeaderboardSnapshot == null || <>4__this._finalLeaderboardSnapshot.Count == 0)
						{
							<>4__this.Log("<color=yellow>[Match Finalize] No cached end-of-match leaderboard snapshot available — skipping final upload to avoid driving range zeros</color>");
							<>4__this._matchStatsSubmitted = true;
							return false;
						}
						<finalPlayerCount>5__2 = <>4__this._finalLeaderboardSnapshot.Count((CachedLeaderboardPlayer p) => p != null && !string.IsNullOrWhiteSpace(p.Name) && p.BaseScore != 0);
						if (<finalPlayerCount>5__2 > 0)
						{
							<>4__this._matchExpectedPlayerCount = <finalPlayerCount>5__2;
							<>2__current = <>4__this.UpdateMatchPlayerCountIfNeeded(<finalPlayerCount>5__2, "cached final leaderboard");
							<>1__state = 1;
							return true;
						}
						goto IL_01b2;
					case 1:
						<>1__state = -1;
						goto IL_01b2;
					case 2:
						<>1__state = -3;
						goto IL_04e3;
					case 3:
						<>1__state = -4;
						goto IL_0a94;
					case 4:
						<>1__state = -4;
						<finalizeLookupName>5__20 = null;
						goto IL_08a6;
					case 5:
						<>1__state = -4;
						goto IL_0972;
					case 6:
						<>1__state = -4;
						if (!string.IsNullOrEmpty(<>8__19.CS$<>8__locals3.entryId))
						{
							<>2__current = <>4__this.UpdateMatchEntry(<>8__19.CS$<>8__locals3.entryId, <>8__19.CS$<>8__locals3.playerId, <player>5__11.Name, <finalGamePoints>5__13, <finalScoreVsPar>5__14, <finishPosition>5__15, <cachedPostMmr>5__17, <>8__19.preMatchMmr);
							<>1__state = 7;
							return true;
						}
						goto IL_0a8c;
					case 7:
						<>1__state = -4;
						goto IL_0a8c;
					case 8:
						<>1__state = -5;
						<sessionPlayerId>5__23 = null;
						goto IL_0bcc;
					case 9:
						{
							<>1__state = -1;
							break;
						}
						IL_04e3:
						<resolveId>5__9 = null;
						<>8__7 = null;
						goto IL_04f2;
						IL_0a8c:
						<>8__19 = null;
						goto IL_0a94;
						IL_0a94:
						<>8__12 = null;
						<cachedPreMmr>5__16 = null;
						<cachedPostMmr>5__17 = null;
						<player>5__11 = null;
						goto IL_0ab1;
						IL_05e3:
						<finishPosition>5__15 = 0;
						if (!string.IsNullOrWhiteSpace(<player>5__11.Name))
						{
							<finalPositionMap>5__5.TryGetValue(<player>5__11.Name, out <finishPosition>5__15);
						}
						<>4__this.TryGetPlayerIdForName(<player>5__11.Name, out <>8__12.playerId);
						<>4__this._playerMatchEntryIds.TryGetValue(<>8__12.playerId ?? "", out <>8__12.entryId);
						<cachedPreMmr>5__16 = null;
						<cachedPostMmr>5__17 = null;
						if (<>8__12.CS$<>8__locals2.finalPreMmrByName.TryGetValue(<player>5__11.Name, out <resolvedPreMmr>5__18))
						{
							<cachedPreMmr>5__16 = <resolvedPreMmr>5__18.ToString(CultureInfo.InvariantCulture);
							<cachedPostMmr>5__17 = (<resolvedPreMmr>5__18 + (float)<player>5__11.ProjectedDelta).ToString(CultureInfo.InvariantCulture);
						}
						if (!string.IsNullOrEmpty(<>8__12.entryId))
						{
							<>4__this.Log(string.Format("<color=cyan>[Match Finalize] Final update for {0}: {1} pts, {2} vs par, pos {3}, postMMR {4}</color>", <player>5__11.Name, <finalGamePoints>5__13, <finalScoreVsPar>5__14, <finishPosition>5__15, <cachedPostMmr>5__17 ?? "n/a"));
							<>2__current = <>4__this.UpdateMatchEntry(<>8__12.entryId, <>8__12.playerId, <player>5__11.Name, <finalGamePoints>5__13, <finalScoreVsPar>5__14, <finishPosition>5__15, <cachedPostMmr>5__17, <cachedPreMmr>5__16);
							<>1__state = 3;
							return true;
						}
						<>8__19 = new <>c__DisplayClass211_3();
						<>8__19.CS$<>8__locals3 = <>8__12;
						<>4__this.Log("<color=yellow>[Match Finalize] " + <player>5__11.Name + " has no entry — creating late entry...</color>");
						if (string.IsNullOrEmpty(<>8__19.CS$<>8__locals3.playerId))
						{
							<finalizeLookupName>5__20 = <>4__this.ApplyTestPlayerOverride(<player>5__11.Name, <testOverrides>5__4);
							<>2__current = <>4__this.ResolvePlayerIdByNameFromApi(<finalizeLookupName>5__20, delegate(string id)
							{
								<>8__19.CS$<>8__locals3.playerId = id;
							});
							<>1__state = 4;
							return true;
						}
						goto IL_08a6;
						IL_08a6:
						if (string.IsNullOrEmpty(<>8__19.CS$<>8__locals3.playerId))
						{
							<>4__this.Log("<color=yellow>[Match Finalize] Cannot resolve player ID for " + <player>5__11.Name + " — skipping late entry</color>");
							goto IL_0ab1;
						}
						<>8__19.preMatchMmr = <cachedPreMmr>5__16;
						if (string.IsNullOrWhiteSpace(<>8__19.preMatchMmr))
						{
							<>2__current = <>4__this.CallAPI("/Player/" + <>8__19.CS$<>8__locals3.playerId, "GET", "", delegate(string res)
							{
								JObject val2 = <>8__19.CS$<>8__locals3.CS$<>8__locals2.<>4__this.ParseApiSingleObject(res);
								object obj2 = ((val2 != null) ? val2["current_mmr"] : null);
								if (obj2 != null)
								{
									<>8__19.preMatchMmr = obj2.ToString();
								}
							});
							<>1__state = 5;
							return true;
						}
						goto IL_0972;
						IL_0ab1:
						while (<>s__10.MoveNext())
						{
							<player>5__11 = <>s__10.Current;
							<>8__12 = new <>c__DisplayClass211_2();
							<>8__12.CS$<>8__locals2 = <>8__1;
							if (<player>5__11 == null)
							{
								continue;
							}
							<finalGamePoints>5__13 = <player>5__11.BaseScore;
							<finalScoreVsPar>5__14 = <>4__this.ParseScoreVsPar(<player>5__11.RawStrokes);
							if (<finalGamePoints>5__13 == 0)
							{
								<>4__this.Log("<color=yellow>[Match Finalize] Skipping " + <player>5__11.Name + " — game points is 0 (spectator/no score)</color>");
								continue;
							}
							goto IL_05e3;
						}
						<>m__Finally2();
						<>s__10 = default(List<CachedLeaderboardPlayer>.Enumerator);
						if (<>4__this._currentSession?.player_ids == null || <>4__this._currentSession.player_ids.Count <= 0)
						{
							break;
						}
						<>s__22 = <>4__this._currentSession.player_ids.Where((string id) => !string.IsNullOrWhiteSpace(id)).Distinct<string>(StringComparer.Ordinal).GetEnumerator();
						<>1__state = -5;
						goto IL_0bcc;
						IL_0459:
						<>4__this.TryGetPlayerIdForName(<>8__7.p.Name, out <resolveId>5__9);
						if (!string.IsNullOrWhiteSpace(<resolveId>5__9))
						{
							<>2__current = <>4__this.CallAPI("/Player/" + <resolveId>5__9, "GET", "", delegate(string res)
							{
								JObject val = <>8__7.CS$<>8__locals1.<>4__this.ParseApiSingleObject(res);
								object obj = ((val != null) ? val["current_mmr"] : null);
								if (obj != null && float.TryParse(obj.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
								{
									<>8__7.CS$<>8__locals1.finalPreMmrByName[<>8__7.p.Name] = result;
									<>8__7.CS$<>8__locals1.<>4__this.Log($"<color=cyan>[Match Finalize] MMR for {<>8__7.p.Name} resolved from API: {result}</color>");
								}
							});
							<>1__state = 2;
							return true;
						}
						goto IL_04e3;
						IL_04f2:
						while (<>s__6.MoveNext())
						{
							<>8__7 = new <>c__DisplayClass211_1();
							<>8__7.CS$<>8__locals1 = <>8__1;
							<>8__7.p = <>s__6.Current;
							if (<>8__7.p == null || string.IsNullOrWhiteSpace(<>8__7.p.Name) || <>8__7.p.BaseScore == 0)
							{
								continue;
							}
							if (!string.IsNullOrWhiteSpace(<>8__7.p.MMR) && float.TryParse(<>8__7.p.MMR, NumberStyles.Float, CultureInfo.InvariantCulture, out <snapMmr>5__8))
							{
								<>8__7.CS$<>8__locals1.finalPreMmrByName[<>8__7.p.Name] = <snapMmr>5__8;
								continue;
							}
							if (<>4__this._userProfile != null && string.Equals(<>8__7.p.Name, <>4__this._userProfile.display_name, StringComparison.OrdinalIgnoreCase))
							{
								<>8__7.CS$<>8__locals1.finalPreMmrByName[<>8__7.p.Name] = <>4__this._userProfile.current_mmr;
								<>4__this.Log($"<color=cyan>[Match Finalize] MMR for local player {<>8__7.p.Name} resolved from profile: {<>4__this._userProfile.current_mmr}</color>");
								continue;
							}
							goto IL_0459;
						}
						<>m__Finally1();
						<>s__6 = default(List<CachedLeaderboardPlayer>.Enumerator);
						<>s__10 = <>4__this._finalLeaderboardSnapshot.GetEnumerator();
						<>1__state = -4;
						goto IL_0ab1;
						IL_0bcc:
						while (<>s__22.MoveNext())
						{
							<sessionPlayerId>5__23 = <>s__22.Current;
							if (<>4__this._playerMatchEntryIds.ContainsKey(<sessionPlayerId>5__23))
							{
								continue;
							}
							<>2__current = <>4__this.CreatePlaceholderMatchEntryForMissingSessionPlayer(<sessionPlayerId>5__23);
							<>1__state = 8;
							return true;
						}
						<>m__Finally3();
						<>s__22 = null;
						<expectedPlayerCount>5__21 = <>4__this._currentSession.player_ids.Count((string id) => !string.IsNullOrWhiteSpace(id));
						if (<expectedPlayerCount>5__21 > <>4__this._matchExpectedPlayerCount)
						{
							<>4__this._matchExpectedPlayerCount = <expectedPlayerCount>5__21;
							<>2__current = <>4__this.UpdateMatchPlayerCountIfNeeded(<expectedPlayerCount>5__21, "session player_ids fallback");
							<>1__state = 9;
							return true;
						}
						break;
						IL_01b2:
						<>4__this.Log($"<color=cyan>[Match Finalize] Using cached final snapshot with {<>4__this._finalLeaderboardSnapshot.Count} players</color>");
						<leaderboardNames>5__3 = (from p in <>4__this._finalLeaderboardSnapshot?.Where((CachedLeaderboardPlayer p) => p != null && !string.IsNullOrWhiteSpace(p.Name))
							select p.Name).ToList() ?? new List<string>();
						<testOverrides>5__4 = <>4__this.GetTestPlayerOverrides(<leaderboardNames>5__3);
						<finalPositionMap>5__5 = <>4__this.BuildFinishPositionMap(<>4__this._finalLeaderboardSnapshot);
						<>8__1.finalPreMmrByName = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);
						<>s__6 = <>4__this._finalLeaderboardSnapshot.GetEnumerator();
						<>1__state = -3;
						goto IL_04f2;
						IL_0972:
						<>2__current = <>4__this.EnsureMatchEntryForPlayer("Match Finalize", <>8__19.CS$<>8__locals3.playerId, <player>5__11.Name, <>8__19.preMatchMmr, <cachedPostMmr>5__17, <finalGamePoints>5__13, <finalScoreVsPar>5__14, <finishPosition>5__15, "Late entry - joined after match start", delegate(string id)
						{
							<>8__19.CS$<>8__locals3.entryId = id;
						});
						<>1__state = 6;
						return true;
					}
					<>4__this._matchStatsSubmitted = true;
					<>4__this.Log("<color=green>[Match Finalize] ✓ Match stats finalized</color>");
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__6).Dispose();
			}

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>s__10).Dispose();
			}

			private void <>m__Finally3()
			{
				<>1__state = -1;
				if (<>s__22 != null)
				{
					<>s__22.Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <HandleCourseEndRpcCoroutine>d__155 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private float <waited>5__1;

			private int <i>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 3u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Expected O, but got Unknown
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>1__state = -3;
						<>4__this.Log("<color=cyan>[Match Signal] CourseManager client RPC InformEndingCourse received — preparing final upload</color>");
						<i>5__2 = 0;
						goto IL_00bf;
					case 1:
						<>1__state = -3;
						<i>5__2++;
						goto IL_00bf;
					case 2:
						<>1__state = -3;
						<waited>5__1 = 0f;
						goto IL_0141;
					case 3:
						<>1__state = -3;
						<waited>5__1 += 0.25f;
						goto IL_0141;
					case 4:
						{
							<>1__state = -3;
							<>m__Finally1();
							return false;
						}
						IL_0141:
						if (string.IsNullOrWhiteSpace(<>4__this._currentMatchId) && <waited>5__1 < 6f)
						{
							<>2__current = (object)new WaitForSeconds(0.25f);
							<>1__state = 3;
							return true;
						}
						<>2__current = <>4__this.UploadCapturedMatchScreenshotIfNeeded("CourseManager.RpcInformEndingCourse");
						<>1__state = 4;
						return true;
						IL_00ce:
						<>2__current = <>4__this.CaptureMatchScreenshotForReview("CourseManager.RpcInformEndingCourse (forced)");
						<>1__state = 2;
						return true;
						IL_00bf:
						if (<i>5__2 < 8)
						{
							try
							{
								if (<>4__this.TryCaptureFinalLeaderboardSnapshot("CourseManager.RpcInformEndingCourse"))
								{
									goto IL_00ce;
								}
							}
							catch
							{
							}
							<>2__current = (object)new WaitForSeconds(0.125f);
							<>1__state = 1;
							return true;
						}
						goto IL_00ce;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				<>4__this._courseEndRpcCoroutine = null;
			}

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

		[CompilerGenerated]
		private sealed class <IncrementCasualMatchesPlayedForActivePlayers>d__132 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<LiveLeaderboardPlugin.SBGLPlayer> leaderboardPlayers;

			public SBGLPlugin <>4__this;

			private List<string> <leaderboardNames>5__1;

			private Dictionary<string, string> <testOverrides>5__2;

			private int <updatedPlayers>5__3;

			private List<string>.Enumerator <>s__4;

			private string <leaderboardName>5__5;

			private <>c__DisplayClass132_0 <>8__6;

			private string <lookupName>5__7;

			private int <updatedCount>5__8;

			private string <json>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 2u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<leaderboardNames>5__1 = null;
				<testOverrides>5__2 = null;
				<>s__4 = default(List<string>.Enumerator);
				<leaderboardName>5__5 = null;
				<>8__6 = null;
				<lookupName>5__7 = null;
				<json>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<leaderboardNames>5__1 = (from player in leaderboardPlayers?.Where((LiveLeaderboardPlugin.SBGLPlayer player) => player != null && !string.IsNullOrWhiteSpace(player.Name))
							select player.Name.Trim()).Distinct<string>(StringComparer.OrdinalIgnoreCase).ToList() ?? new List<string>();
						if (<leaderboardNames>5__1.Count == 0)
						{
							<>4__this.Log("<color=yellow>[Casual] No active leaderboard names found - skipping casual stat increment</color>");
							return false;
						}
						<testOverrides>5__2 = <>4__this.GetTestPlayerOverrides(<leaderboardNames>5__1);
						<updatedPlayers>5__3 = 0;
						<>s__4 = <leaderboardNames>5__1.GetEnumerator();
						<>1__state = -3;
						goto IL_0527;
					case 1:
						<>1__state = -3;
						goto IL_02a9;
					case 2:
						<>1__state = -3;
						<updatedCount>5__8 = <>8__6.casualMatchesPlayed + 1;
						<json>5__9 = "{" + $"\"casual_matches_played\":{<updatedCount>5__8}" + "}";
						<>8__6.updated = false;
						<>2__current = <>4__this.CallAPI("/Player/" + <>8__6.playerId, "PUT", <json>5__9, delegate(string res)
						{
							if (<>8__6.<>4__this.ParseApiSingleObject(res) != null)
							{
								<>8__6.updated = true;
							}
						});
						<>1__state = 3;
						return true;
					case 3:
						{
							<>1__state = -3;
							if (!<>8__6.updated)
							{
								<>4__this.Log("<color=yellow>[Casual] Failed to update casual_matches_played for " + <leaderboardName>5__5 + "</color>");
							}
							else
							{
								<updatedPlayers>5__3++;
								<>4__this._playerIdsByName[<leaderboardName>5__5] = <>8__6.playerId;
								if (!string.IsNullOrWhiteSpace(<>8__6.resolvedDisplayName))
								{
									<>4__this._playerIdsByName[<>8__6.resolvedDisplayName.Trim()] = <>8__6.playerId;
								}
								<>4__this.Log($"<color=green>[Casual] ✓ Updated {<>8__6.resolvedDisplayName} ({<>8__6.playerId}) casual_matches_played: {<>8__6.casualMatchesPlayed} -> {<updatedCount>5__8}</color>");
								<>8__6 = null;
								<lookupName>5__7 = null;
								<json>5__9 = null;
								<leaderboardName>5__5 = null;
							}
							goto IL_0527;
						}
						IL_0527:
						if (<>s__4.MoveNext())
						{
							<leaderboardName>5__5 = <>s__4.Current;
							<>8__6 = new <>c__DisplayClass132_0();
							<>8__6.<>4__this = <>4__this;
							<lookupName>5__7 = <>4__this.ApplyTestPlayerOverride(<leaderboardName>5__5, <testOverrides>5__2);
							<>8__6.playerId = null;
							if (!string.IsNullOrWhiteSpace(<>4__this._userProfile?.id) && string.Equals(<leaderboardName>5__5, <>4__this._userProfile.display_name, StringComparison.OrdinalIgnoreCase))
							{
								<>8__6.playerId = <>4__this._userProfile.id;
							}
							if (string.IsNullOrWhiteSpace(<>8__6.playerId))
							{
								<>4__this.TryGetPlayerIdForName(<leaderboardName>5__5, out <>8__6.playerId);
							}
							if (string.IsNullOrWhiteSpace(<>8__6.playerId) && !string.Equals(<lookupName>5__7, <leaderboardName>5__5, StringComparison.OrdinalIgnoreCase))
							{
								<>4__this.TryGetPlayerIdForName(<lookupName>5__7, out <>8__6.playerId);
							}
							if (string.IsNullOrWhiteSpace(<>8__6.playerId))
							{
								<>2__current = <>4__this.ResolvePlayerIdByNameFromApi(<lookupName>5__7, delegate(string id)
								{
									<>8__6.playerId = id;
								});
								<>1__state = 1;
								return true;
							}
							goto IL_02a9;
						}
						<>m__Finally1();
						<>s__4 = default(List<string>.Enumerator);
						<>4__this._matchEntriesCreated = true;
						<>4__this._matchStatsSubmitted = true;
						if (<updatedPlayers>5__3 > 0)
						{
							<>4__this.ShowUploadNotification($"Casual stats updated for {<updatedPlayers>5__3} player(s).", "success");
						}
						else
						{
							<>4__this.ShowUploadNotification("Casual match detected, but no player stats were updated.", "warning");
						}
						<>4__this.Log($"<color=cyan>[Casual] Casual match handling complete - updated {<updatedPlayers>5__3}/{<leaderboardNames>5__1.Count} players</color>");
						return false;
						IL_02a9:
						if (string.IsNullOrWhiteSpace(<>8__6.playerId))
						{
							<>4__this.Log("<color=yellow>[Casual] Could not resolve player ID for '" + <leaderboardName>5__5 + "' - skipping casual stat update</color>");
							goto IL_0527;
						}
						<>8__6.casualMatchesPlayed = 0;
						<>8__6.resolvedDisplayName = <leaderboardName>5__5;
						<>2__current = <>4__this.CallAPI("/Player/" + <>8__6.playerId, "GET", "", delegate(string res)
						{
							JObject val = <>8__6.<>4__this.ParseApiSingleObject(res);
							if (val != null)
							{
								<>8__6.resolvedDisplayName = ((string)val["display_name"]) ?? <>8__6.resolvedDisplayName;
								int.TryParse(((object)val["casual_matches_played"])?.ToString() ?? "0", out <>8__6.casualMatchesPlayed);
							}
						});
						<>1__state = 2;
						return true;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__4).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <LeaveQueue>d__183 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass183_0 <>8__1;

			private string <json>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<json>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass183_0();
					<>8__1.<>4__this = <>4__this;
					if (string.IsNullOrEmpty(<>4__this._currentQueueId))
					{
						<>4__this.ResetPluginState();
						return false;
					}
					<>4__this._webStatus = "LEAVING...";
					<json>5__2 = "{\"player_id\":\"" + <>4__this._userProfile.id + "\",\"status\":\"cancelled\"}";
					<>8__1.leaveSuccess = false;
					<>2__current = <>4__this.CallAPI("/MatchmakingQueue/" + <>4__this._currentQueueId, "PUT", <json>5__2, delegate(string res)
					{
						if (<>8__1.<>4__this.ParseApiSingleObject(res) != null)
						{
							<>8__1.<>4__this.ResetPluginState();
							<>8__1.<>4__this.Log("✓ Left Queue.");
							<>8__1.leaveSuccess = true;
						}
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!<>8__1.leaveSuccess)
					{
						<>4__this.Log("<color=orange>Leave queue request failed. Check logs above for details.</color>");
						<>4__this.ResetPluginState();
					}
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <MatchmakingLoop>d__182 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass182_0 <>8__1;

			private string <checkQuery>5__2;

			private string <checkUrl>5__3;

			private UnityWebRequest <checkReq>5__4;

			private List<JObject> <existing>5__5;

			private string <patchJson>5__6;

			private string <json>5__7;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<checkQuery>5__2 = null;
				<checkUrl>5__3 = null;
				<checkReq>5__4 = null;
				<existing>5__5 = null;
				<patchJson>5__6 = null;
				<json>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: Invalid comparison between Unknown and I4
				//IL_0261: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass182_0();
						<>8__1.<>4__this = <>4__this;
						if (<>4__this._userProfile == null)
						{
							<>4__this.Log("<color=red>No profile loaded.</color>");
							return false;
						}
						<>4__this._isQueueing = true;
						<>4__this._webStatus = "JOINING...";
						<>4__this._queueStartTime = DateTime.Now;
						<>8__1.existingId = null;
						<checkQuery>5__2 = "{\"player_id\":\"" + <>4__this._userProfile.id + "\",\"status\":\"queued\"}";
						<checkUrl>5__3 = <>4__this.GetBaseApiUrl() + "/MatchmakingQueue?q=" + UnityWebRequest.EscapeURL(<checkQuery>5__2);
						<>4__this.Log("<color=cyan>[Queue] Checking for existing entry for player " + <>4__this._userProfile.id + "...</color>");
						<checkReq>5__4 = UnityWebRequest.Get(<checkUrl>5__3);
						<>1__state = -3;
						<>4__this.ApplyApiHeaders(<checkReq>5__4);
						<>2__current = <checkReq>5__4.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<checkReq>5__4.result == 1)
						{
							<existing>5__5 = <>4__this.ParseApiObjectList(<checkReq>5__4.downloadHandler.text);
							if (<existing>5__5 != null && <existing>5__5.Count > 0)
							{
								<>8__1.existingId = (string)<existing>5__5[0]["id"];
								<>4__this.Log("<color=yellow>[Queue] Found existing entry " + <>8__1.existingId + " — patching has_mod:true</color>");
							}
							else
							{
								<>4__this.Log("<color=cyan>[Queue] No existing entry found — will create new.</color>");
							}
							<existing>5__5 = null;
						}
						else
						{
							<>4__this.Log($"<color=orange>[Queue] Could not check existing entries: {<checkReq>5__4.result} — will attempt POST anyway.</color>");
						}
						<>m__Finally1();
						<checkReq>5__4 = null;
						if (<>8__1.existingId != null)
						{
							<patchJson>5__6 = "{\"has_mod\":true,\"created_by\":\"SBGL_UnifiedMod\",\"match_type\":\"" + <>4__this.GetQueueMatchTypePayload() + "\"," + $"\"queued_at\":\"{DateTime.UtcNow:yyyy-MM-ddTHH:mm:ss.fffZ}\"" + "}";
							<>2__current = <>4__this.CallAPI("/MatchmakingQueue/" + <>8__1.existingId, "PUT", <patchJson>5__6, delegate(string res)
							{
								JObject val2 = <>8__1.<>4__this.ParseApiSingleObject(res);
								if (val2 != null)
								{
									<>8__1.<>4__this._currentQueueId = <>8__1.existingId;
									<>8__1.<>4__this._webStatus = "QUEUED";
									<>8__1.<>4__this.Log("<color=green>[Queue] ✓ Updated existing entry " + <>8__1.existingId + " with has_mod:true.</color>");
								}
								else
								{
									<>8__1.<>4__this.Log("<color=red>[Queue] Failed to update existing entry " + <>8__1.existingId + ".</color>");
								}
							});
							<>1__state = 2;
							return true;
						}
						<json>5__7 = "{\"player_id\":\"" + <>4__this._userProfile.id + "\",\"user_id\":\"" + <>4__this._userProfile.id + "\",\"display_name\":\"" + <>4__this._userProfile.display_name + "\"," + $"\"mmr_snapshot\":{<>4__this._userProfile.current_mmr}," + "\"region\":\"" + <>4__this._userProfile.region + "\",\"state_province\":\"" + <>4__this._userProfile.state_province + "\",\"match_type\":\"" + <>4__this.GetQueueMatchTypePayload() + "\",\"has_mod\":true,\"created_by\":\"SBGL_UnifiedMod\",\"status\":\"queued\"," + $"\"queued_at\":\"{DateTime.UtcNow:yyyy-MM-ddTHH:mm:ss.fffZ}\"" + "}";
						<>2__current = <>4__this.CallAPI("/MatchmakingQueue", "POST", <json>5__7, delegate(string res)
						{
							JObject val = <>8__1.<>4__this.ParseApiSingleObject(res);
							<>8__1.<>4__this._currentQueueId = ((string)((val != null) ? val["id"] : null)) ?? <>8__1.<>4__this._currentQueueId;
							<>8__1.<>4__this._webStatus = "QUEUED";
							<>8__1.<>4__this.Log("<color=green>[Queue] ✓ Created new entry " + <>8__1.<>4__this._currentQueueId + " with has_mod:true.</color>");
						});
						<>1__state = 3;
						return true;
					case 2:
						<>1__state = -1;
						<patchJson>5__6 = null;
						break;
					case 3:
						<>1__state = -1;
						<json>5__7 = null;
						break;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<checkReq>5__4 != null)
				{
					((IDisposable)<checkReq>5__4).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <MonitorAndUpdateScores>d__197 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private LiveLeaderboardPlugin <liveLeaderboard>5__1;

			private List<LiveLeaderboardPlugin.SBGLPlayer> <allLeaderboardPlayers>5__2;

			private Dictionary<string, int> <livePositionMap>5__3;

			private int <activePlayerCount>5__4;

			private List<string> <leaderboardNames>5__5;

			private Dictionary<string, string> <testOverrides>5__6;

			private <>c__DisplayClass197_0 <>8__7;

			private List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator <>s__8;

			private LiveLeaderboardPlugin.SBGLPlayer <player>5__9;

			private int <newGamePoints>5__10;

			private int <newScoreVsPar>5__11;

			private bool <scoresChanged>5__12;

			private int <lastScore>5__13;

			private string <strokeStr>5__14;

			private int <lastVsPar>5__15;

			private <>c__DisplayClass197_1 <>8__16;

			private string <monitorLookupName>5__17;

			private <>c__DisplayClass197_2 <>8__18;

			private int <finishPosition>5__19;

			private int <finishPosition>5__20;

			private string <perHolePreMmr>5__21;

			private string <perHolePostMmr>5__22;

			private float <perHolePreF>5__23;

			private int <projDelta>5__24;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 5) <= 3u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<liveLeaderboard>5__1 = null;
				<allLeaderboardPlayers>5__2 = null;
				<livePositionMap>5__3 = null;
				<leaderboardNames>5__5 = null;
				<testOverrides>5__6 = null;
				<>8__7 = null;
				<>s__8 = default(List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator);
				<player>5__9 = null;
				<strokeStr>5__14 = null;
				<>8__16 = null;
				<monitorLookupName>5__17 = null;
				<>8__18 = null;
				<perHolePreMmr>5__21 = null;
				<perHolePostMmr>5__22 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>4__this.Log("<color=cyan>[Match Monitor] Starting score monitoring for gameplay</color>");
						break;
					case 1:
						<>1__state = -1;
						if (!<>4__this._matchEntriesCreated && string.IsNullOrWhiteSpace(<>4__this._currentMatchId) && !<>4__this._matchCreationInProgress && Time.realtimeSinceStartup >= <>4__this._nextEnsureMatchCreateAttemptAt)
						{
							<>8__7 = new <>c__DisplayClass197_0();
							<>4__this._nextEnsureMatchCreateAttemptAt = Time.realtimeSinceStartup + 6f;
							<>8__7.shouldUpload = false;
							<>2__current = <>4__this.ValidateMatchUpload(delegate(bool ok)
							{
								<>8__7.shouldUpload = ok;
							});
							<>1__state = 2;
							return true;
						}
						goto IL_01a5;
					case 2:
						<>1__state = -1;
						if (<>8__7.shouldUpload)
						{
							<>4__this.Log("<color=yellow>[Match Monitor] Missing match records mid-round - attempting creation/adoption...</color>");
							<>2__current = <>4__this.CreateMatchAndEntries();
							<>1__state = 3;
							return true;
						}
						goto IL_019d;
					case 3:
						<>1__state = -1;
						goto IL_019d;
					case 4:
						<>1__state = -1;
						goto IL_02c7;
					case 5:
						<>1__state = -3;
						if (!string.IsNullOrEmpty(<>8__16.playerId))
						{
							<>4__this._playerIdsByName[<player>5__9.Name.Trim()] = <>8__16.playerId;
						}
						<monitorLookupName>5__17 = null;
						goto IL_05c4;
					case 6:
						<>1__state = -3;
						<finishPosition>5__19 = 0;
						if (!string.IsNullOrWhiteSpace(<player>5__9.Name))
						{
							<livePositionMap>5__3.TryGetValue(<player>5__9.Name, out <finishPosition>5__19);
						}
						<>2__current = <>4__this.EnsureMatchEntryForPlayer("Match Monitor", <>8__18.CS$<>8__locals1.playerId, <player>5__9.Name, <>8__18.preMatchMmr, null, <newGamePoints>5__10, <newScoreVsPar>5__11, <finishPosition>5__19, "Live leaderboard backfill during round", delegate(string id)
						{
							<>8__18.CS$<>8__locals1.entryId = id;
						});
						<>1__state = 7;
						return true;
					case 7:
						<>1__state = -3;
						<>8__18 = null;
						goto IL_077e;
					case 8:
						{
							<>1__state = -3;
							<>4__this._lastSubmittedScores[<player>5__9.Name] = <newGamePoints>5__10;
							<>4__this._lastSubmittedScoresVsPar[<player>5__9.Name] = <newScoreVsPar>5__11;
							<perHolePreMmr>5__21 = null;
							<perHolePostMmr>5__22 = null;
							goto IL_0974;
						}
						IL_077e:
						if (!string.IsNullOrEmpty(<>8__16.entryId) && !string.IsNullOrEmpty(<>8__16.playerId))
						{
							<>4__this._matchEntriesCreated = true;
							<finishPosition>5__20 = 0;
							if (!string.IsNullOrWhiteSpace(<player>5__9.Name))
							{
								<livePositionMap>5__3.TryGetValue(<player>5__9.Name, out <finishPosition>5__20);
							}
							<perHolePreMmr>5__21 = ((!string.IsNullOrWhiteSpace(<player>5__9.MMR) && <player>5__9.MMR != "..." && <player>5__9.MMR != "--") ? <player>5__9.MMR : null);
							<perHolePostMmr>5__22 = null;
							if (<perHolePreMmr>5__21 != null && float.TryParse(<perHolePreMmr>5__21, NumberStyles.Float, CultureInfo.InvariantCulture, out <perHolePreF>5__23))
							{
								<projDelta>5__24 = <>4__this.ParseProjectedMmrDelta(<player>5__9.ProjectedDisplay);
								<perHolePostMmr>5__22 = (<perHolePreF>5__23 + (float)<projDelta>5__24).ToString(CultureInfo.InvariantCulture);
							}
							<>2__current = <>4__this.UpdateMatchEntry(<>8__16.entryId, <>8__16.playerId, <player>5__9.Name, <newGamePoints>5__10, <newScoreVsPar>5__11, 0, <perHolePostMmr>5__22, <perHolePreMmr>5__21);
							<>1__state = 8;
							return true;
						}
						goto IL_0974;
						IL_0974:
						<>8__16 = null;
						goto IL_097c;
						IL_0411:
						<scoresChanged>5__12 = false;
						if (<>4__this._lastSubmittedScores.TryGetValue(<player>5__9.Name, out <lastScore>5__13))
						{
							if (<lastScore>5__13 != <newGamePoints>5__10 || !<>4__this._lastSubmittedScoresVsPar.TryGetValue(<player>5__9.Name, out <lastVsPar>5__15) || <lastVsPar>5__15 != <newScoreVsPar>5__11)
							{
								<scoresChanged>5__12 = true;
							}
						}
						else
						{
							<scoresChanged>5__12 = true;
						}
						if (<scoresChanged>5__12)
						{
							<>8__16 = new <>c__DisplayClass197_1();
							<>8__16.<>4__this = <>4__this;
							<>8__16.playerId = null;
							<>8__16.entryId = null;
							if (!<>4__this.TryGetPlayerIdForName(<player>5__9.Name, out <>8__16.playerId))
							{
								<monitorLookupName>5__17 = <>4__this.ApplyTestPlayerOverride(<player>5__9.Name, <testOverrides>5__6);
								<>2__current = <>4__this.ResolvePlayerIdByNameFromApi(<monitorLookupName>5__17, delegate(string id)
								{
									<>8__16.playerId = id;
								});
								<>1__state = 5;
								return true;
							}
							goto IL_05c4;
						}
						goto IL_097c;
						IL_097c:
						<player>5__9 = null;
						goto IL_0984;
						IL_019d:
						<>8__7 = null;
						goto IL_01a5;
						IL_05c4:
						if (!string.IsNullOrEmpty(<>8__16.playerId))
						{
							<>4__this._playerMatchEntryIds.TryGetValue(<>8__16.playerId, out <>8__16.entryId);
						}
						if (!string.IsNullOrEmpty(<>8__16.playerId) && string.IsNullOrEmpty(<>8__16.entryId))
						{
							<>8__18 = new <>c__DisplayClass197_2();
							<>8__18.CS$<>8__locals1 = <>8__16;
							<>8__18.preMatchMmr = null;
							<>2__current = <>4__this.CallAPI("/Player/" + <>8__18.CS$<>8__locals1.playerId, "GET", "", delegate(string res)
							{
								JObject val = <>8__18.CS$<>8__locals1.<>4__this.ParseApiSingleObject(res);
								object obj = ((val != null) ? val["current_mmr"] : null);
								if (obj != null)
								{
									<>8__18.preMatchMmr = obj.ToString();
								}
							});
							<>1__state = 6;
							return true;
						}
						goto IL_077e;
						IL_02c7:
						<leaderboardNames>5__5 = (from p in <allLeaderboardPlayers>5__2?.Where((LiveLeaderboardPlugin.SBGLPlayer p) => p != null && !string.IsNullOrWhiteSpace(p.Name))
							select p.Name).ToList() ?? new List<string>();
						<testOverrides>5__6 = <>4__this.GetTestPlayerOverrides(<leaderboardNames>5__5);
						<>s__8 = <allLeaderboardPlayers>5__2.GetEnumerator();
						<>1__state = -3;
						goto IL_0984;
						IL_0984:
						while (<>s__8.MoveNext())
						{
							<player>5__9 = <>s__8.Current;
							if (<player>5__9 == null)
							{
								continue;
							}
							<newGamePoints>5__10 = <player>5__9.BaseScore;
							<newScoreVsPar>5__11 = 0;
							if (!string.IsNullOrEmpty(<player>5__9.RawStrokes))
							{
								<strokeStr>5__14 = <player>5__9.RawStrokes.Replace("±", "").Trim();
								int.TryParse(<strokeStr>5__14, out <newScoreVsPar>5__11);
								<strokeStr>5__14 = null;
							}
							if (<newGamePoints>5__10 == 0)
							{
								continue;
							}
							goto IL_0411;
						}
						<>m__Finally1();
						<>s__8 = default(List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator);
						<liveLeaderboard>5__1 = null;
						<allLeaderboardPlayers>5__2 = null;
						<livePositionMap>5__3 = null;
						<leaderboardNames>5__5 = null;
						<testOverrides>5__6 = null;
						break;
						IL_01a5:
						if (<>4__this._currentMatchId == null)
						{
							break;
						}
						<liveLeaderboard>5__1 = Object.FindAnyObjectByType<LiveLeaderboardPlugin>((FindObjectsInactive)1);
						if ((Object)(object)<liveLeaderboard>5__1 == (Object)null)
						{
							break;
						}
						<allLeaderboardPlayers>5__2 = <liveLeaderboard>5__1.GetCurrentLeaderboard();
						if (<allLeaderboardPlayers>5__2 == null || <allLeaderboardPlayers>5__2.Count == 0)
						{
							break;
						}
						<>4__this.CacheLeaderboardSnapshot(<allLeaderboardPlayers>5__2, "live gameplay");
						<livePositionMap>5__3 = <>4__this.BuildFinishPositionMap(<allLeaderboardPlayers>5__2);
						<activePlayerCount>5__4 = <allLeaderboardPlayers>5__2.Count((LiveLeaderboardPlugin.SBGLPlayer p) => p != null && !string.IsNullOrWhiteSpace(p.Name) && p.BaseScore != 0);
						if (<activePlayerCount>5__4 > 0)
						{
							<>4__this._matchExpectedPlayerCount = <activePlayerCount>5__4;
							<>2__current = <>4__this.UpdateMatchPlayerCountIfNeeded(<activePlayerCount>5__4, "live leaderboard");
							<>1__state = 4;
							return true;
						}
						goto IL_02c7;
					}
					if (<>4__this._isInGameplay)
					{
						<>2__current = (object)new WaitForSeconds(2f);
						<>1__state = 1;
						return true;
					}
					<>4__this.Log("<color=cyan>[Match Monitor] Score monitoring ended</color>");
					<>4__this._monitorCoroutine = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__8).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <MonitorLobbyNameForUpload>d__196 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private WaitForSeconds <checkDelay>5__1;

			private string <liveLobbyName>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<checkDelay>5__1 = null;
				<liveLobbyName>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (<>4__this._isInGameplay && !<>4__this._matchEntriesCreated)
					{
						<liveLobbyName>5__2 = CompetitivePluginCheck._currentLobbyName;
						if (string.IsNullOrEmpty(<liveLobbyName>5__2) || !<liveLobbyName>5__2.StartsWith("SBGL-", StringComparison.OrdinalIgnoreCase))
						{
							<liveLobbyName>5__2 = null;
							goto IL_010b;
						}
						<>4__this.Log("<color=yellow>[LobbyMonitor] Lobby renamed to '" + <liveLobbyName>5__2 + "' mid-round - triggering upload...</color>");
						((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.ValidateMatchUpload(delegate(bool shouldUpload)
						{
							if (shouldUpload)
							{
								<>4__this.Log("<color=yellow>[LobbyMonitor] Eligibility confirmed - creating match records...</color>");
								((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.CreateMatchAndEntries());
							}
							else
							{
								<>4__this.Log("<color=orange>[LobbyMonitor] Lobby is SBGL-* but failed eligibility check - skipping upload</color>");
								<>4__this._matchEntriesCreated = true;
							}
						}));
					}
					goto IL_0130;
				}
				<>1__state = -1;
				<>4__this.Log("<color=cyan>[LobbyMonitor] Starting mid-round lobby rename monitor</color>");
				<checkDelay>5__1 = new WaitForSeconds(3f);
				goto IL_010b;
				IL_010b:
				if (<>4__this._isInGameplay && !<>4__this._matchEntriesCreated)
				{
					<>2__current = <checkDelay>5__1;
					<>1__state = 1;
					return true;
				}
				goto IL_0130;
				IL_0130:
				<>4__this.Log("<color=cyan>[LobbyMonitor] Lobby rename monitor stopped</color>");
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <PollSessionStatus>d__185 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private string <fullUrl>5__1;

			private UnityWebRequest <req>5__2;

			private string <raw>5__3;

			private JObject <session>5__4;

			private string <statusFromApi>5__5;

			private List<string> <acceptedIds>5__6;

			private string <latestSteamLobbyLink>5__7;

			private string <latestMatchId>5__8;

			private string <readyJson>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<fullUrl>5__1 = null;
				<req>5__2 = null;
				<raw>5__3 = null;
				<session>5__4 = null;
				<statusFromApi>5__5 = null;
				<acceptedIds>5__6 = null;
				<latestSteamLobbyLink>5__7 = null;
				<latestMatchId>5__8 = null;
				<readyJson>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Invalid comparison between Unknown and I4
				//IL_0563: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
						<>1__state = -1;
						<fullUrl>5__1 = <>4__this.GetBaseApiUrl() + "/MatchmakingSession/" + <>4__this._currentSession.id;
						<>4__this.Log("<color=cyan>[Sync] GET /MatchmakingSession/" + <>4__this._currentSession.id + " (polling status)</color>");
						<>4__this.Log("<color=cyan>[Sync] Full URL: " + <fullUrl>5__1 + "</color>");
						<req>5__2 = UnityWebRequest.Get(<fullUrl>5__1);
						<>1__state = -3;
						<>4__this.ApplyApiHeaders(<req>5__2);
						<>2__current = <req>5__2.SendWebRequest();
						<>1__state = 1;
						result = true;
						goto end_IL_0000;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__2.result != 1)
						{
							<>4__this.Log($"<color=red>[Sync] PollSessionStatus failed: {<req>5__2.result} - {<req>5__2.error}</color>");
							break;
						}
						<raw>5__3 = <req>5__2.downloadHandler.text;
						<session>5__4 = <>4__this.ParseApiSingleObject(<raw>5__3);
						if (<session>5__4 == null)
						{
							result = false;
							<>m__Finally1();
						}
						else
						{
							<statusFromApi>5__5 = (string)<session>5__4["status"];
							<>4__this._currentSession.status = <statusFromApi>5__5 ?? <>4__this._currentSession.status;
							<>4__this.Log("<color=cyan>[Sync] Status from API: " + <statusFromApi>5__5 + "</color>");
							JToken obj = <session>5__4["accepted_player_ids"];
							<acceptedIds>5__6 = ((obj != null) ? obj.ToObject<List<string>>() : null);
							if (<acceptedIds>5__6 == null)
							{
								goto IL_035e;
							}
							<>4__this._currentSession.accepted_player_ids = <acceptedIds>5__6;
							<>4__this.Log($"<color=cyan>[Sync] Updated accepted_player_ids: {<acceptedIds>5__6.Count} players have accepted</color>");
							if (!(<>4__this._currentSession.status == "pending_accept") || <>4__this._currentSession.accepted_player_ids.Count != <>4__this._currentSession.player_ids.Count)
							{
								goto IL_035e;
							}
							<>4__this.Log($"<color=green>[Sync] All {<>4__this._currentSession.player_ids.Count} players have accepted! Transitioning to ready...</color>");
							<>4__this._currentSession.status = "ready";
							<>4__this._webStatus = (<>4__this._isHost ? "READY: HOST" : "READY: JOIN");
							<readyJson>5__9 = "{\"status\":\"ready\"}";
							<>2__current = <>4__this.CallAPI("/MatchmakingSession/" + <>4__this._currentSession.id, "PUT", <readyJson>5__9, delegate
							{
								<>4__this.Log("<color=green>[Sync] ✓ Session transitioned to READY</color>");
							});
							<>1__state = 2;
							result = true;
						}
						goto end_IL_0000;
					case 2:
						{
							<>1__state = -3;
							<readyJson>5__9 = null;
							goto IL_035e;
						}
						IL_035e:
						<latestSteamLobbyLink>5__7 = (string)<session>5__4["steam_lobby_link"];
						if (!string.IsNullOrEmpty(<latestSteamLobbyLink>5__7) && <latestSteamLobbyLink>5__7 != <>4__this._currentSession.steam_lobby_link)
						{
							<>4__this._currentSession.steam_lobby_link = <latestSteamLobbyLink>5__7;
							<>4__this.Log("Sync: steam_lobby_link received/updated from API.");
						}
						<latestMatchId>5__8 = (string)<session>5__4["match_id"];
						if (!string.IsNullOrEmpty(<latestMatchId>5__8) && <latestMatchId>5__8 != <>4__this._currentSession.match_id)
						{
							<>4__this._currentSession.match_id = <latestMatchId>5__8;
							<>4__this.Log("Sync: match_id received/updated from API: " + <latestMatchId>5__8);
						}
						if (<>4__this._currentSession.status == "ready")
						{
							<>4__this._webStatus = (<>4__this._isHost ? "READY: HOST" : "READY: JOIN");
							<>4__this.Log("<color=green>[Sync] Session is READY - Host should start game</color>");
						}
						else if (<>4__this._currentSession.status == "cancelled" || <>4__this._currentSession.status == "completed")
						{
							<>4__this.Log("Match ended with status: " + <>4__this._currentSession.status + ".");
							<>4__this.ResetPluginState();
						}
						<raw>5__3 = null;
						<session>5__4 = null;
						<statusFromApi>5__5 = null;
						<acceptedIds>5__6 = null;
						<latestSteamLobbyLink>5__7 = null;
						<latestMatchId>5__8 = null;
						break;
					}
					<>m__Finally1();
					<req>5__2 = null;
					result = false;
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__2 != null)
				{
					((IDisposable)<req>5__2).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <RefreshPlayerList>d__180 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private string <query>5__1;

			private string <fullUrl>5__2;

			private UnityWebRequest <req>5__3;

			private string <rawJson>5__4;

			private List<JObject> <queueEntries>5__5;

			private List<PlayerData> <queuedPlayers>5__6;

			private JObject <myEntry>5__7;

			private string <myStatus>5__8;

			private int <countQueued>5__9;

			private int <countMatched>5__10;

			private List<JObject>.Enumerator <>s__11;

			private JObject <entry>5__12;

			private string <status>5__13;

			private string <status>5__14;

			private string <serverTime>5__15;

			private DateTime <parsedTime>5__16;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<query>5__1 = null;
				<fullUrl>5__2 = null;
				<req>5__3 = null;
				<rawJson>5__4 = null;
				<queueEntries>5__5 = null;
				<queuedPlayers>5__6 = null;
				<myEntry>5__7 = null;
				<myStatus>5__8 = null;
				<>s__11 = default(List<JObject>.Enumerator);
				<entry>5__12 = null;
				<status>5__13 = null;
				<status>5__14 = null;
				<serverTime>5__15 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Invalid comparison between Unknown and I4
				//IL_0549: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<query>5__1 = "{\"$or\":[{\"status\":\"queued\"},{\"status\":\"matched\"}]}";
						<fullUrl>5__2 = <>4__this.GetBaseApiUrl() + "/MatchmakingQueue?q=" + UnityWebRequest.EscapeURL(<query>5__1);
						<>4__this.Log("<color=cyan>[Sync] GET /MatchmakingQueue (fetching queued players)</color>");
						<>4__this.Log("<color=cyan>[Sync] Full URL: " + <fullUrl>5__2.Substring(0, Math.Min(150, <fullUrl>5__2.Length)) + "...</color>");
						<req>5__3 = UnityWebRequest.Get(<fullUrl>5__2);
						<>1__state = -3;
						<>4__this.ApplyApiHeaders(<req>5__3);
						<>2__current = <req>5__3.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__3.result == 1)
						{
							<rawJson>5__4 = <req>5__3.downloadHandler.text;
							<queueEntries>5__5 = <>4__this.ParseApiObjectList(<rawJson>5__4);
							<queuedPlayers>5__6 = new List<PlayerData>(<queueEntries>5__5.Count);
							<myEntry>5__7 = null;
							<myStatus>5__8 = null;
							<countQueued>5__9 = 0;
							<countMatched>5__10 = 0;
							<>s__11 = <queueEntries>5__5.GetEnumerator();
							try
							{
								while (<>s__11.MoveNext())
								{
									<entry>5__12 = <>s__11.Current;
									<status>5__13 = (string)<entry>5__12["status"];
									if (string.Equals(<status>5__13, "queued", StringComparison.OrdinalIgnoreCase))
									{
										<countQueued>5__9++;
										<queuedPlayers>5__6.Add(new PlayerData
										{
											name = (((string)<entry>5__12["display_name"]) ?? ((string)<entry>5__12["user_id"]) ?? "Unknown"),
											mmr = (((object)<entry>5__12["mmr_snapshot"])?.ToString() ?? "0")
										});
									}
									else if (string.Equals(<status>5__13, "matched", StringComparison.OrdinalIgnoreCase))
									{
										<countMatched>5__10++;
									}
									if (<>4__this._userProfile != null && <myEntry>5__7 == null && string.Equals((string)<entry>5__12["player_id"], <>4__this._userProfile.id, StringComparison.Ordinal))
									{
										<myEntry>5__7 = <entry>5__12;
										<myStatus>5__8 = <status>5__13;
									}
									<status>5__13 = null;
									<entry>5__12 = null;
								}
							}
							finally
							{
								((IDisposable)<>s__11).Dispose();
							}
							<>s__11 = default(List<JObject>.Enumerator);
							<>4__this._queuedPlayers = <queuedPlayers>5__6;
							<>4__this._onlineCount = <countQueued>5__9 + <countMatched>5__10;
							<>4__this._queuedCount = <countQueued>5__9;
							<>4__this._matchedCount = <countMatched>5__10;
							if (<>4__this._userProfile != null && <myEntry>5__7 != null)
							{
								<status>5__14 = <myStatus>5__8;
								if (<status>5__14 == "queued" && !<>4__this._isQueueing)
								{
									<>4__this._isQueueing = true;
									<>4__this._currentQueueId = ((string)<myEntry>5__7["id"]) ?? <>4__this._currentQueueId;
									<>4__this._webStatus = "QUEUED (SYNCED)";
									<serverTime>5__15 = (string)<myEntry>5__7["queued_at"];
									if (DateTime.TryParse(<serverTime>5__15, null, DateTimeStyles.RoundtripKind, out <parsedTime>5__16))
									{
										<>4__this._queueStartTime = <parsedTime>5__16.ToUniversalTime();
									}
									<>4__this.Log("Sync: Found active session on server. Reconnecting UI...");
									<serverTime>5__15 = null;
								}
								else if (<status>5__14 == "matched" && <>4__this._currentSession == null)
								{
									<>4__this._webStatus = "MATCH FOUND (SYNCED)";
									<>2__current = <>4__this.CheckForMatch();
									<>1__state = 2;
									return true;
								}
								goto IL_0508;
							}
							goto IL_0511;
						}
						<>4__this.Log($"<color=red>[Sync] RefreshPlayerList failed: {<req>5__3.result} - {<req>5__3.error}</color>");
						break;
					case 2:
						{
							<>1__state = -3;
							goto IL_0508;
						}
						IL_0511:
						<rawJson>5__4 = null;
						<queueEntries>5__5 = null;
						<queuedPlayers>5__6 = null;
						<myEntry>5__7 = null;
						<myStatus>5__8 = null;
						break;
						IL_0508:
						<status>5__14 = null;
						goto IL_0511;
					}
					<>m__Finally1();
					<req>5__3 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__3 != null)
				{
					((IDisposable)<req>5__3).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <ResolveExistingMatchEntryId>d__167 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string matchId;

			public string playerId;

			public Action<string> onResolved;

			public bool logMisses;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass167_0 <>8__1;

			private string <query>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<query>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass167_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.resolvedId = null;
					if (string.IsNullOrWhiteSpace(matchId) || string.IsNullOrWhiteSpace(playerId))
					{
						onResolved?.Invoke(null);
						return false;
					}
					<query>5__2 = "{\"match_id\":\"" + matchId + "\",\"player_id\":\"" + playerId + "\"}";
					<>2__current = <>4__this.CallAPI("/MatchEntry?q=" + UnityWebRequest.EscapeURL(<query>5__2) + "&limit=1&sort_by=created_date", "GET", "", delegate(string res)
					{
						JObject val = <>8__1.<>4__this.ParseApiObjectList(res).FirstOrDefault();
						if (val != null)
						{
							<>8__1.resolvedId = (string)val["id"];
						}
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (logMisses && string.IsNullOrWhiteSpace(<>8__1.resolvedId))
					{
						<>4__this.Log("<color=cyan>[Match Entry] No existing MatchEntry found yet for player " + playerId + "</color>");
					}
					onResolved?.Invoke(<>8__1.resolvedId);
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <ResolveExistingMatchIdForCurrentSession>d__161 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Action<string> onResolved;

			public bool logMisses;

			public SBGLPlugin <>4__this;

			private string <resolvedId>5__1;

			private string <activeSessionId>5__2;

			private string <query>5__3;

			private string <fullUrl>5__4;

			private UnityWebRequest <req>5__5;

			private JObject <existingMatch>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<resolvedId>5__1 = null;
				<activeSessionId>5__2 = null;
				<query>5__3 = null;
				<fullUrl>5__4 = null;
				<req>5__5 = null;
				<existingMatch>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0200: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Invalid comparison between Unknown and I4
				//IL_0330: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<resolvedId>5__1 = null;
						<activeSessionId>5__2 = ((<>4__this._currentSession != null) ? <>4__this._currentSession.id : <>4__this._localManualSessionId);
						if (string.IsNullOrWhiteSpace(<activeSessionId>5__2))
						{
							onResolved?.Invoke(null);
							return false;
						}
						if (!string.IsNullOrWhiteSpace(<>4__this._currentSession?.match_id))
						{
							<resolvedId>5__1 = <>4__this._currentSession.match_id;
							if (!<>4__this._finalizedMatchIds.Contains(<resolvedId>5__1))
							{
								<>4__this.Log("<color=cyan>[Match Creation] Session already linked to Match ID " + <resolvedId>5__1 + "</color>");
								onResolved?.Invoke(<resolvedId>5__1);
								return false;
							}
							<>4__this.Log("<color=yellow>[Match Creation] Session match_id " + <resolvedId>5__1 + " was already finalized — clearing link and forcing new match</color>");
							<>4__this._currentSession.match_id = null;
							<resolvedId>5__1 = null;
						}
						<query>5__3 = "{\"matchmaking_session_id\":\"" + <activeSessionId>5__2 + "\"}";
						<fullUrl>5__4 = <>4__this.GetBaseApiUrl() + "/Match?q=" + UnityWebRequest.EscapeURL(<query>5__3) + "&sort_by=created_date";
						<req>5__5 = UnityWebRequest.Get(<fullUrl>5__4);
						<>1__state = -3;
						<>4__this.ApplyApiHeaders(<req>5__5);
						<>2__current = <req>5__5.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__5.result == 1)
						{
							<existingMatch>5__6 = <>4__this.SelectNewestReusableMatch(<>4__this.ParseApiObjectList(<req>5__5.downloadHandler.text));
							JObject obj = <existingMatch>5__6;
							<resolvedId>5__1 = (string)((obj != null) ? obj["id"] : null);
							if (!string.IsNullOrWhiteSpace(<resolvedId>5__1))
							{
								if (<>4__this._currentSession != null)
								{
									<>4__this._currentSession.match_id = <resolvedId>5__1;
								}
								<>4__this.Log("<color=green>[Match Creation] ✓ Reusing newest active Match ID from API for session " + <activeSessionId>5__2 + ": " + <resolvedId>5__1 + "</color>");
							}
							else if (logMisses)
							{
								<>4__this.Log("<color=cyan>[Match Creation] No existing Match found yet for session " + <activeSessionId>5__2 + "</color>");
							}
							<existingMatch>5__6 = null;
						}
						else
						{
							<>4__this.Log($"<color=yellow>[Match Creation] Existing Match lookup failed: {<req>5__5.result} - {<req>5__5.error}</color>");
						}
						<>m__Finally1();
						<req>5__5 = null;
						onResolved?.Invoke(<resolvedId>5__1);
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__5 != null)
				{
					((IDisposable)<req>5__5).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <ResolvePlayerIdByNameFromApi>d__202 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string playerName;

			public Action<string> onResolved;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass202_0 <>8__1;

			private string <escapedExactName>5__2;

			private string <exactQuery>5__3;

			private string <escapedRegexName>5__4;

			private string <anchoredRegexQuery>5__5;

			private string <fuzzyName>5__6;

			private string <fuzzyQuery>5__7;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<escapedExactName>5__2 = null;
				<exactQuery>5__3 = null;
				<escapedRegexName>5__4 = null;
				<anchoredRegexQuery>5__5 = null;
				<fuzzyName>5__6 = null;
				<fuzzyQuery>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass202_0();
					<>8__1.<>4__this = <>4__this;
					if (onResolved == null)
					{
						return false;
					}
					if (string.IsNullOrWhiteSpace(playerName))
					{
						onResolved(null);
						return false;
					}
					<>8__1.normalizedName = playerName.Trim();
					<>8__1.resolvedId = null;
					<escapedExactName>5__2 = <>8__1.normalizedName.Replace("\\", "\\\\").Replace("\"", "\\\"");
					<exactQuery>5__3 = "{\"$or\":[{\"display_name\":\"" + <escapedExactName>5__2 + "\"},{\"ign\":\"" + <escapedExactName>5__2 + "\"}]}";
					<>2__current = <>4__this.CallAPI("/Player?q=" + UnityWebRequest.EscapeURL(<exactQuery>5__3) + "&limit=1", "GET", "", delegate(string res)
					{
						JObject val3 = <>8__1.<>4__this.ParseApiObjectList(res)?.FirstOrDefault();
						if (val3 != null)
						{
							<>8__1.resolvedId = (string)val3["id"];
						}
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (string.IsNullOrWhiteSpace(<>8__1.resolvedId))
					{
						<escapedRegexName>5__4 = Regex.Escape(<>8__1.normalizedName).Replace("\\ ", " ");
						<anchoredRegexQuery>5__5 = "{\"$or\":[{\"display_name\":{\"$regex\":\"^" + <escapedRegexName>5__4 + "$\",\"$options\":\"i\"}},{\"ign\":{\"$regex\":\"^" + <escapedRegexName>5__4 + "$\",\"$options\":\"i\"}}]}";
						<>2__current = <>4__this.CallAPI("/Player?q=" + UnityWebRequest.EscapeURL(<anchoredRegexQuery>5__5) + "&limit=1", "GET", "", delegate(string res)
						{
							JObject val4 = <>8__1.<>4__this.ParseApiObjectList(res)?.FirstOrDefault();
							if (val4 != null)
							{
								<>8__1.resolvedId = (string)val4["id"];
							}
						});
						<>1__state = 2;
						return true;
					}
					goto IL_0243;
				case 2:
					<>1__state = -1;
					<escapedRegexName>5__4 = null;
					<anchoredRegexQuery>5__5 = null;
					goto IL_0243;
				case 3:
					{
						<>1__state = -1;
						<fuzzyName>5__6 = null;
						<fuzzyQuery>5__7 = null;
						break;
					}
					IL_0243:
					if (!string.IsNullOrWhiteSpace(<>8__1.resolvedId))
					{
						break;
					}
					<fuzzyName>5__6 = <>8__1.normalizedName.Replace("\\", "\\\\").Replace("\"", "\\\"");
					<fuzzyQuery>5__7 = "{\"$or\":[{\"display_name\":{\"$regex\":\"" + <fuzzyName>5__6 + "\",\"$options\":\"i\"}},{\"ign\":{\"$regex\":\"" + <fuzzyName>5__6 + "\",\"$options\":\"i\"}}]}";
					<>2__current = <>4__this.CallAPI("/Player?q=" + UnityWebRequest.EscapeURL(<fuzzyQuery>5__7), "GET", "", delegate(string res)
					{
						List<JObject> list = <>8__1.<>4__this.ParseApiObjectList(res);
						if (list != null && list.Count != 0)
						{
							JObject val = ((IEnumerable<JObject>)list).FirstOrDefault((Func<JObject, bool>)((JObject r) => string.Equals((string)((r != null) ? r["display_name"] : null), <>8__1.normalizedName, StringComparison.OrdinalIgnoreCase) || string.Equals((string)((r != null) ? r["ign"] : null), <>8__1.normalizedName, StringComparison.OrdinalIgnoreCase)));
							JObject val2 = val ?? list.FirstOrDefault();
							if (val2 != null)
							{
								<>8__1.resolvedId = (string)val2["id"];
							}
						}
					});
					<>1__state = 3;
					return true;
				}
				onResolved(<>8__1.resolvedId);
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <ResolveProfile>d__225 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string steamName;

			public SBGLPlugin <>4__this;

			private string <fullUrl>5__1;

			private UnityWebRequest <req>5__2;

			private string <raw>5__3;

			private JObject <profile>5__4;

			private string <picUrl>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<fullUrl>5__1 = null;
				<req>5__2 = null;
				<raw>5__3 = null;
				<profile>5__4 = null;
				<picUrl>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Invalid comparison between Unknown and I4
				//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<fullUrl>5__1 = <>4__this.GetBaseApiUrl() + "/Player?q=" + UnityWebRequest.EscapeURL("{\"display_name\":\"" + steamName + "\"}");
						<>4__this.Log("<color=cyan>[Init] GET /Player (resolving profile for " + steamName + ")</color>");
						<>4__this.Log("<color=cyan>[Init] Full URL: " + <fullUrl>5__1.Substring(0, Math.Min(150, <fullUrl>5__1.Length)) + "...</color>");
						<req>5__2 = UnityWebRequest.Get(<fullUrl>5__1);
						<>1__state = -3;
						<>4__this.ApplyApiHeaders(<req>5__2);
						<>2__current = <req>5__2.SendWebRequest();
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__2.result == 1)
						{
							<raw>5__3 = <req>5__2.downloadHandler.text;
							<profile>5__4 = <>4__this.ParseApiSingleObject(<raw>5__3);
							if (<profile>5__4 == null)
							{
								<>4__this.Log("<color=orange>Profile sync failed: response was not valid JSON object.</color>");
								result = false;
								<>m__Finally1();
								break;
							}
							<>4__this._userProfile = new PlayerProfile
							{
								id = (string)<profile>5__4["id"],
								display_name = (string)<profile>5__4["display_name"],
								region = (((string)<profile>5__4["region"]) ?? "US"),
								state_province = (string)<profile>5__4["state_province"]
							};
							float.TryParse(((object)<profile>5__4["current_mmr"])?.ToString(), out <>4__this._userProfile.current_mmr);
							<>4__this.Log("Profile Sync: " + <>4__this._userProfile.display_name + " from " + <>4__this._userProfile.state_province);
							<picUrl>5__5 = (string)<profile>5__4["profile_pic_url"];
							if (!string.IsNullOrEmpty(<picUrl>5__5) && !<>4__this._hasFetchedProfilePic)
							{
								((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.DownloadProfilePic(<picUrl>5__5));
							}
							<raw>5__3 = null;
							<profile>5__4 = null;
							<picUrl>5__5 = null;
						}
						else
						{
							<>4__this.Log($"<color=red>[Init] ResolveProfile failed: {<req>5__2.result} - {<req>5__2.error}</color>");
						}
						<>m__Finally1();
						<req>5__2 = null;
						result = false;
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__2 != null)
				{
					((IDisposable)<req>5__2).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <SubmitMatchEntry>d__216 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MatchStats stats;

			public Action<string> onMatchIdReceived;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass216_0 <>8__1;

			private string <seasonId>5__2;

			private string <rawMatchType>5__3;

			private string <apiMatchType>5__4;

			private bool <isProSeries>5__5;

			private JObject <payload>5__6;

			private string <json>5__7;

			private int <proSeriesWeek>5__8;

			private string <proSeriesEventName>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<seasonId>5__2 = null;
				<rawMatchType>5__3 = null;
				<apiMatchType>5__4 = null;
				<payload>5__6 = null;
				<json>5__7 = null;
				<proSeriesEventName>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c4: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: 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_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass216_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.onMatchIdReceived = onMatchIdReceived;
					if (stats == null)
					{
						return false;
					}
					<seasonId>5__2 = <>4__this._activeSeasonId ?? "69de6bf4fb103cb0d5eb00c5";
					<rawMatchType>5__3 = PlayerPrefs.GetString("MatchType", "ranked_season_1");
					<apiMatchType>5__4 = (IsProSeriesMatchType(<rawMatchType>5__3) ? "pro_series" : "mmr");
					<isProSeries>5__5 = <apiMatchType>5__4 == "pro_series";
					<payload>5__6 = new JObject
					{
						["matchmaking_session_id"] = JToken.op_Implicit(stats.matchmaking_session_id),
						["season_id"] = JToken.op_Implicit(<seasonId>5__2),
						["match_date"] = JToken.op_Implicit(stats.match_date),
						["match_type"] = JToken.op_Implicit(<apiMatchType>5__4),
						["player_count"] = JToken.op_Implicit(Mathf.Max(0, <>4__this._matchExpectedPlayerCount)),
						["status"] = JToken.op_Implicit("Pending"),
						["submitted_by_name"] = JToken.op_Implicit(stats.player_name),
						["mode"] = JToken.op_Implicit(""),
						["notes"] = JToken.op_Implicit("Auto-submitted via SBGL Unified Mod")
					};
					if (<isProSeries>5__5)
					{
						<payload>5__6["pro_series_season_id"] = JToken.op_Implicit("69b59af135403a1cb7b113c8");
						<proSeriesWeek>5__8 = PlayerPrefs.GetInt("ProSeriesWeek", 0);
						if (<proSeriesWeek>5__8 > 0)
						{
							<payload>5__6["pro_series_week"] = JToken.op_Implicit(<proSeriesWeek>5__8);
						}
						<proSeriesEventName>5__9 = PlayerPrefs.GetString("ProSeriesEventName", "");
						if (!string.IsNullOrWhiteSpace(<proSeriesEventName>5__9))
						{
							<payload>5__6["pro_series_event_name"] = JToken.op_Implicit(<proSeriesEventName>5__9);
						}
						<proSeriesEventName>5__9 = null;
					}
					<json>5__7 = ((JToken)<payload>5__6).ToString((Formatting)0, Array.Empty<JsonConverter>());
					<>4__this.Log("<color=cyan>[Match Stats] Submitting Match entry to API</color>");
					<>4__this.Log("<color=cyan>[Match Stats] Full URL: " + <>4__this.GetBaseApiUrl() + "/Match</color>");
					<>4__this.Log("<color=cyan>[Match Stats] Payload: " + <json>5__7 + "</color>");
					<>2__current = <>4__this.CallAPI("/Match", "POST", <json>5__7, delegate(string res)
					{
						JObject val = <>8__1.<>4__this.ParseApiSingleObject(res);
						if (val != null)
						{
							string text = ((string)val["id"]) ?? "unknown";
							<>8__1.<>4__this._lastUploadedPlayerCount = Mathf.Max(0, <>8__1.<>4__this._matchExpectedPlayerCount);
							<>8__1.<>4__this.Log("<color=green>[Match Stats] ✓ Match entry created (ID: " + text + ")</color>");
							<>8__1.<>4__this.ShowUploadNotification("Upload success: match ID " + text + ".", "success");
							<>8__1.onMatchIdReceived?.Invoke(text);
						}
						else
						{
							<>8__1.<>4__this.Log("<color=yellow>[Match Stats] Response received but could not parse ID</color>");
							<>8__1.<>4__this.ShowUploadNotification("Upload failed: invalid API response.", "failure");
						}
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <SubmitMatchEntryForPlayer>d__217 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string matchId;

			public string playerId;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass217_0 <>8__1;

			private int <gamePoints>5__2;

			private int <scoreVsPar>5__3;

			private string <leaderboardName>5__4;

			private bool <foundScores>5__5;

			private int <tries>5__6;

			private string <json>5__7;

			private Dictionary<string, string>.Enumerator <>s__8;

			private KeyValuePair<string, string> <kvp>5__9;

			private int <cachedScore>5__10;

			private string <matchKey>5__11;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<leaderboardName>5__4 = null;
				<json>5__7 = null;
				<>s__8 = default(Dictionary<string, string>.Enumerator);
				<kvp>5__9 = default(KeyValuePair<string, string>);
				<matchKey>5__11 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0502: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass217_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.playerId = playerId;
					<gamePoints>5__2 = 0;
					<scoreVsPar>5__3 = 0;
					<>8__1.playerDisplayName = null;
					<leaderboardName>5__4 = null;
					<>s__8 = <>4__this._playerIdsByName.GetEnumerator();
					try
					{
						while (<>s__8.MoveNext())
						{
							<kvp>5__9 = <>s__8.Current;
							if (!string.IsNullOrWhiteSpace(<kvp>5__9.Value) && string.Equals(<kvp>5__9.Value, <>8__1.playerId, StringComparison.OrdinalIgnoreCase))
							{
								<leaderboardName>5__4 = <kvp>5__9.Key?.Trim();
								break;
							}
							<kvp>5__9 = default(KeyValuePair<string, string>);
						}
					}
					finally
					{
						((IDisposable)<>s__8).Dispose();
					}
					<>s__8 = default(Dictionary<string, string>.Enumerator);
					if (!string.IsNullOrEmpty(<leaderboardName>5__4))
					{
						<>8__1.playerDisplayName = <leaderboardName>5__4;
						<>4__this.Log("<color=cyan>[Match Stats] Using leaderboard name mapping for " + <>8__1.playerId + ": " + <>8__1.playerDisplayName + "</color>");
					}
					if (string.IsNullOrEmpty(<>8__1.playerDisplayName) && <>8__1.playerId == <>4__this._userProfile.id)
					{
						<>8__1.playerDisplayName = <>4__this._userProfile.display_name;
						<>4__this.Log("<color=cyan>[Match Stats] Current user: " + <>8__1.playerDisplayName + "</color>");
					}
					if (string.IsNullOrEmpty(<>8__1.playerDisplayName))
					{
						<>4__this.Log("<color=cyan>[Match Stats] Fetching profile for opponent " + <>8__1.playerId + " (fallback)</color>");
						<>2__current = <>4__this.CallAPI("/Player/" + <>8__1.playerId, "GET", "", delegate(string res)
						{
							try
							{
								JObject val2 = <>8__1.<>4__this.ParseApiSingleObject(res);
								if (val2 != null)
								{
									<>8__1.playerDisplayName = (string)val2["display_name"];
									<>8__1.<>4__this.Log("<color=cyan>[Match Stats] Opponent display name (API): " + <>8__1.playerDisplayName + "</color>");
								}
							}
							catch (Exception ex)
							{
								<>8__1.<>4__this.Log("<color=yellow>[Match Stats] Error parsing opponent profile: " + ex.Message + "</color>");
							}
						});
						<>1__state = 1;
						return true;
					}
					goto IL_02c1;
				case 1:
					<>1__state = -1;
					goto IL_02c1;
				case 2:
					<>1__state = -1;
					goto IL_0514;
				case 3:
					{
						<>1__state = -1;
						return false;
					}
					IL_02c1:
					<foundScores>5__5 = false;
					<tries>5__6 = 0;
					goto IL_0514;
					IL_0514:
					while (!<foundScores>5__5 && <tries>5__6 < 5)
					{
						if (!string.IsNullOrEmpty(<>8__1.playerDisplayName))
						{
							if (<>4__this._cachedLeaderboardScores.TryGetValue(<>8__1.playerDisplayName, out <cachedScore>5__10))
							{
								<gamePoints>5__2 = <cachedScore>5__10;
								<>4__this._cachedLeaderboardScoresVsPar.TryGetValue(<>8__1.playerDisplayName, out <scoreVsPar>5__3);
								<foundScores>5__5 = true;
								<>4__this.Log($"<color=green>[Match Stats] ✓ Found cached scores for {<>8__1.playerDisplayName}: {<gamePoints>5__2} pts, {<scoreVsPar>5__3} vs par</color>");
								break;
							}
							<matchKey>5__11 = <>4__this._cachedLeaderboardScores.Keys.FirstOrDefault((string k) => string.Equals(k?.Trim(), <>8__1.playerDisplayName?.Trim(), StringComparison.OrdinalIgnoreCase));
							if (!string.IsNullOrEmpty(<matchKey>5__11))
							{
								<gamePoints>5__2 = <>4__this._cachedLeaderboardScores[<matchKey>5__11];
								<>4__this._cachedLeaderboardScoresVsPar.TryGetValue(<matchKey>5__11, out <scoreVsPar>5__3);
								<foundScores>5__5 = true;
								<>4__this.Log($"<color=green>[Match Stats] ✓ Found cached scores via fallback key '{<matchKey>5__11}' for {<>8__1.playerDisplayName}: {<gamePoints>5__2} pts, {<scoreVsPar>5__3} vs par</color>");
								break;
							}
							<matchKey>5__11 = null;
						}
						<tries>5__6++;
						if (!<foundScores>5__5 && <tries>5__6 < 5)
						{
							<>4__this.Log($"<color=yellow>[Match Stats] Scores not cached yet for {<>8__1.playerDisplayName ?? <>8__1.playerId}, retry {<tries>5__6}/5...</color>");
							<>2__current = (object)new WaitForSeconds(0.5f);
							<>1__state = 2;
							return true;
						}
					}
					if (!<foundScores>5__5)
					{
						<>4__this.Log("<color=yellow>[Match Stats] ⚠ No leaderboard data found for " + (<>8__1.playerDisplayName ?? <>8__1.playerId) + " after retries</color>");
					}
					<json>5__7 = "{\"match_id\":\"" + matchId + "\",\"player_id\":\"" + <>8__1.playerId + "\",\"player_name\":\"" + (<>8__1.playerDisplayName ?? "Unknown") + "\"," + $"\"game_points\":{<gamePoints>5__2}," + $"\"score_vs_par\":{<scoreVsPar>5__3}," + "\"notes\":\"Auto-submitted player entry via SBGL Unified Mod\"}";
					<>4__this.Log($"<color=cyan>[Match Stats] Submitting MatchEntry for {<>8__1.playerDisplayName ?? <>8__1.playerId}: {<gamePoints>5__2} pts, {<scoreVsPar>5__3} vs par</color>");
					<>2__current = <>4__this.CallAPI("/MatchEntry", "POST", <json>5__7, delegate(string res)
					{
						JObject val = <>8__1.<>4__this.ParseApiSingleObject(res);
						if (val != null)
						{
							string text = ((string)val["id"]) ?? "unknown";
							<>8__1.<>4__this.Log("<color=green>[Match Stats] ✓ MatchEntry created (ID: " + text + ") for player " + (<>8__1.playerDisplayName ?? <>8__1.playerId) + "</color>");
						}
						else
						{
							<>8__1.<>4__this.Log("<color=yellow>[Match Stats] Could not parse MatchEntry response for player " + (<>8__1.playerDisplayName ?? <>8__1.playerId) + "</color>");
						}
					});
					<>1__state = 3;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <SubmitMatchStats>d__213 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass213_0 <>8__1;

			private float <matchDuration>5__2;

			private MatchStats <stats>5__3;

			private Dictionary<string, int> <playerScores>5__4;

			private Dictionary<string, int> <playerScoresVsPar>5__5;

			private LiveLeaderboardPlugin <liveLeaderboard>5__6;

			private List<LiveLeaderboardPlugin.SBGLPlayer> <allLeaderboardPlayers>5__7;

			private List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator <>s__8;

			private LiveLeaderboardPlugin.SBGLPlayer <leaderboardPlayer>5__9;

			private int <gamePoints>5__10;

			private int <scoreVsPar>5__11;

			private string <strokeStr>5__12;

			private Exception <ex>5__13;

			private List<string>.Enumerator <>s__14;

			private string <playerId>5__15;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 3)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<stats>5__3 = null;
				<playerScores>5__4 = null;
				<playerScoresVsPar>5__5 = null;
				<liveLeaderboard>5__6 = null;
				<allLeaderboardPlayers>5__7 = null;
				<>s__8 = default(List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator);
				<leaderboardPlayer>5__9 = null;
				<strokeStr>5__12 = null;
				<ex>5__13 = null;
				<>s__14 = default(List<string>.Enumerator);
				<playerId>5__15 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass213_0();
						<>8__1.<>4__this = <>4__this;
						if (<>4__this._userProfile == null || <>4__this._currentSession == null)
						{
							<>4__this.Log("<color=red>[Match Stats] Failed: Missing profile or session</color>");
							return false;
						}
						if (IsProSeriesMatchType(PlayerPrefs.GetString("MatchType", "")) || <>4__this.IsCurrentMatchCasual())
						{
							<>4__this._matchStatsSubmitted = true;
							return false;
						}
						<>4__this.Log("<color=cyan>[Match Stats] Collecting data for session: " + <>4__this._currentSession.id + "</color>");
						<matchDuration>5__2 = 0f;
						if (<>4__this._matchStartTime.HasValue)
						{
							<matchDuration>5__2 = (float)(DateTime.UtcNow - <>4__this._matchStartTime.Value).TotalSeconds;
						}
						<stats>5__3 = <>4__this.CollectMatchStats(<matchDuration>5__2);
						if (<stats>5__3 == null)
						{
							<>4__this.Log("<color=red>[Match Stats] Failed to collect stats</color>");
							return false;
						}
						<>4__this.Log($"<color=cyan>[Match Stats] Duration: {<matchDuration>5__2}s | Host: {<stats>5__3.is_host} | Player: {<stats>5__3.player_name}</color>");
						<>8__1.matchId = null;
						<>2__current = <>4__this.SubmitMatchEntry(<stats>5__3, delegate(string id)
						{
							<>8__1.matchId = id;
						});
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						if (string.IsNullOrEmpty(<>8__1.matchId))
						{
							<>4__this.Log("<color=red>[Match Stats] Failed to get Match ID from submission</color>");
							return false;
						}
						<>2__current = <>4__this.CallAPI("/MatchmakingSession/" + <>4__this._currentSession.id, "PUT", "{\"match_id\":\"" + <>8__1.matchId + "\"}", delegate(string res)
						{
							JObject val = <>8__1.<>4__this.ParseApiSingleObject(res);
							if (val != null)
							{
								<>8__1.<>4__this._currentSession.match_id = <>8__1.matchId;
								<>8__1.<>4__this.Log("<color=green>[Match Stats] ✓ MatchmakingSession " + <>8__1.<>4__this._currentSession.id + " linked to match: " + <>8__1.matchId + "</color>");
							}
							else
							{
								<>8__1.<>4__this.Log("<color=yellow>[Match Stats] Could not confirm MatchmakingSession update</color>");
							}
						});
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						<playerScores>5__4 = new Dictionary<string, int>();
						<playerScoresVsPar>5__5 = new Dictionary<string, int>();
						try
						{
							<liveLeaderboard>5__6 = Object.FindAnyObjectByType<LiveLeaderboardPlugin>((FindObjectsInactive)1);
							if ((Object)(object)<liveLeaderboard>5__6 != (Object)null)
							{
								<allLeaderboardPlayers>5__7 = <liveLeaderboard>5__6.GetCurrentLeaderboard();
								<>4__this.Log($"<color=cyan>[Match Stats] Leaderboard has {<allLeaderboardPlayers>5__7.Count} visible players</color>");
								<>s__8 = <allLeaderboardPlayers>5__7.GetEnumerator();
								try
								{
									while (<>s__8.MoveNext())
									{
										<leaderboardPlayer>5__9 = <>s__8.Current;
										if (<leaderboardPlayer>5__9 != null)
										{
											<gamePoints>5__10 = <leaderboardPlayer>5__9.BaseScore;
											<scoreVsPar>5__11 = 0;
											if (!string.IsNullOrEmpty(<leaderboardPlayer>5__9.RawStrokes))
											{
												<strokeStr>5__12 = <leaderboardPlayer>5__9.RawStrokes.Replace("±", "").Trim();
												int.TryParse(<strokeStr>5__12, out <scoreVsPar>5__11);
												<strokeStr>5__12 = null;
											}
											<playerScores>5__4[<leaderboardPlayer>5__9.Name] = <gamePoints>5__10;
											<playerScoresVsPar>5__5[<leaderboardPlayer>5__9.Name] = <scoreVsPar>5__11;
											<>4__this.Log($"<color=cyan>[Match Stats] Cached: {<leaderboardPlayer>5__9.Name} = {<gamePoints>5__10} pts, {<scoreVsPar>5__11} vs par</color>");
											<leaderboardPlayer>5__9 = null;
										}
									}
								}
								finally
								{
									((IDisposable)<>s__8).Dispose();
								}
								<>s__8 = default(List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator);
								<allLeaderboardPlayers>5__7 = null;
							}
							else
							{
								<>4__this.Log("<color=yellow>[Match Stats] LiveLeaderboard not found - will use placeholder scores</color>");
							}
							<liveLeaderboard>5__6 = null;
						}
						catch (Exception ex)
						{
							<ex>5__13 = ex;
							<>4__this.Log("<color=yellow>[Match Stats] Error fetching leaderboard data: " + <ex>5__13.Message + "</color>");
						}
						<>4__this._cachedLeaderboardScores = <playerScores>5__4;
						<>4__this._cachedLeaderboardScoresVsPar = <playerScoresVsPar>5__5;
						if (<>4__this._currentSession.player_ids == null || <>4__this._currentSession.player_ids.Count <= 0)
						{
							break;
						}
						<>4__this.Log($"<color=cyan>[Match Stats] Creating MatchEntry records for {<>4__this._currentSession.player_ids.Count} players</color>");
						<>s__14 = <>4__this._currentSession.player_ids.GetEnumerator();
						<>1__state = -3;
						goto IL_05ce;
					case 3:
						{
							<>1__state = -3;
							<playerId>5__15 = null;
							goto IL_05ce;
						}
						IL_05ce:
						if (<>s__14.MoveNext())
						{
							<playerId>5__15 = <>s__14.Current;
							<>2__current = <>4__this.SubmitMatchEntryForPlayer(<>8__1.matchId, <playerId>5__15);
							<>1__state = 3;
							return true;
						}
						<>m__Finally1();
						<>s__14 = default(List<string>.Enumerator);
						break;
					}
					<>4__this._matchStatsSubmitted = true;
					<>4__this.Log("<color=green>[Match Stats] ✓ Match and player entries submitted successfully</color>");
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__14).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <TransitionToReady>d__188 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = _readyTransitionDelay;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <UpdateMatchEntry>d__198 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string entryId;

			public string playerId;

			public string playerName;

			public int gamePoints;

			public int scoreVsPar;

			public int finishPosition;

			public string postMatchMmr;

			public string preMatchMmr;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass198_0 <>8__1;

			private int <adjustedScore>5__2;

			private JObject <payload>5__3;

			private float <postMmrF>5__4;

			private string <json>5__5;

			private float <preMmrF>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<payload>5__3 = null;
				<json>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//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_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass198_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.playerName = playerName;
					<>4__this.Log($"<color=cyan>[Score Update] Hole completed for {<>8__1.playerName}: {gamePoints} pts, {scoreVsPar} vs par</color>");
					<adjustedScore>5__2 = gamePoints + scoreVsPar * -10;
					<payload>5__3 = new JObject
					{
						["game_points"] = JToken.op_Implicit(gamePoints),
						["over_under"] = JToken.op_Implicit(scoreVsPar),
						["score_vs_par"] = JToken.op_Implicit(scoreVsPar),
						["adjusted_match_score"] = JToken.op_Implicit(<adjustedScore>5__2),
						["notes"] = JToken.op_Implicit("Updated after hole completion")
					};
					if (finishPosition > 0)
					{
						<payload>5__3["finish_position"] = JToken.op_Implicit(finishPosition);
					}
					if (!string.IsNullOrWhiteSpace(postMatchMmr) && float.TryParse(postMatchMmr, NumberStyles.Float, CultureInfo.InvariantCulture, out <postMmrF>5__4))
					{
						<payload>5__3["post_match_mmr"] = JToken.op_Implicit(<postMmrF>5__4);
						if (!string.IsNullOrWhiteSpace(preMatchMmr) && float.TryParse(preMatchMmr, NumberStyles.Float, CultureInfo.InvariantCulture, out <preMmrF>5__6))
						{
							<payload>5__3["mmr_change"] = JToken.op_Implicit(<postMmrF>5__4 - <preMmrF>5__6);
						}
					}
					<json>5__5 = ((JToken)<payload>5__3).ToString((Formatting)0, Array.Empty<JsonConverter>());
					<>2__current = <>4__this.CallAPI("/MatchEntry/" + entryId, "PUT", <json>5__5, delegate(string res)
					{
						try
						{
							JObject val = <>8__1.<>4__this.ParseApiSingleObject(res);
							if (val != null)
							{
								<>8__1.<>4__this.Log("<color=green>[Score Update] ✓ MatchEntry updated for " + <>8__1.playerName + "</color>");
							}
						}
						catch (Exception ex)
						{
							<>8__1.<>4__this.Log("<color=yellow>[Score Update] Could not update MatchEntry: " + ex.Message + "</color>");
						}
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <UpdateMatchPlayerCountIfNeeded>d__203 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public int actualPlayerCount;

			public string source;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass203_0 <>8__1;

			private string <json>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<json>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass203_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.actualPlayerCount = actualPlayerCount;
					<>8__1.source = source;
					if (<>8__1.actualPlayerCount <= 0 || string.IsNullOrEmpty(<>4__this._currentMatchId))
					{
						return false;
					}
					if (<>4__this._lastUploadedPlayerCount == <>8__1.actualPlayerCount)
					{
						return false;
					}
					<json>5__2 = "{" + $"\"player_count\":{<>8__1.actualPlayerCount}" + "}";
					<>2__current = <>4__this.CallAPI("/Match/" + <>4__this._currentMatchId, "PUT", <json>5__2, delegate(string res)
					{
						JObject val = <>8__1.<>4__this.ParseApiSingleObject(res);
						if (val != null)
						{
							<>8__1.<>4__this._lastUploadedPlayerCount = <>8__1.actualPlayerCount;
							<>8__1.<>4__this.Log($"<color=green>[Match Count] ✓ Updated match player_count to {<>8__1.actualPlayerCount} ({<>8__1.source})</color>");
						}
						else
						{
							<>8__1.<>4__this.Log($"<color=yellow>[Match Count] Could not confirm player_count update to {<>8__1.actualPlayerCount} ({<>8__1.source})</color>");
						}
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <UpdateSessionStatus>d__222 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string status;

			public SBGLPlugin <>4__this;

			private string <json>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this._currentSession == null || <>4__this._currentSession.id == "DEBUG")
					{
						return false;
					}
					<json>5__1 = "{\"status\":\"" + status + "\"}";
					<>2__current = <>4__this.CallAPI("/MatchmakingSession/" + <>4__this._currentSession.id, "PUT", <json>5__1, null);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <UploadCapturedMatchScreenshotIfNeeded>d__148 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string source;

			public SBGLPlugin <>4__this;

			private <>c__DisplayClass148_0 <>8__1;

			private float <staggerDelay>5__2;

			private JObject <payload>5__3;

			private <>c__DisplayClass148_1 <>8__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 3u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<payload>5__3 = null;
				<>8__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0303: Unknown result type (might be due to invalid IL or missing references)
				//IL_0324: Expected O, but got Unknown
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
						<>1__state = -1;
						if (<>4__this._matchScreenshotUploadCompleted || <>4__this._matchScreenshotUploadInProgress)
						{
							result = false;
						}
						else if ((string.IsNullOrWhiteSpace(<>4__this._pendingUploadedScreenshotUrl) && (<>4__this._pendingMatchScreenshotBytes == null || <>4__this._pendingMatchScreenshotBytes.Length == 0)) || string.IsNullOrWhiteSpace(<>4__this._currentMatchId))
						{
							result = false;
						}
						else
						{
							<>4__this._matchScreenshotUploadInProgress = true;
							<>1__state = -3;
							<>8__1 = new <>c__DisplayClass148_0();
							<>8__1.<>4__this = <>4__this;
							<staggerDelay>5__2 = <>4__this.GetCurrentPlayerScreenshotUploadDelaySeconds();
							if (!(<staggerDelay>5__2 > 0f))
							{
								goto IL_0139;
							}
							<>2__current = (object)new WaitForSeconds(<staggerDelay>5__2);
							<>1__state = 1;
							result = true;
						}
						goto end_IL_0000;
					case 1:
						<>1__state = -3;
						goto IL_0139;
					case 2:
						<>1__state = -3;
						if (<>8__1.readSucceeded && !string.IsNullOrWhiteSpace(<>8__1.existingScreenshotUrl))
						{
							<>4__this._matchScreenshotUploadCompleted = true;
							<>4__this.ClearPendingMatchScreenshot();
							<>4__this.Log("<color=cyan>[Match Screenshot] Match " + <>4__this._currentMatchId + " already has a screenshot - skipping duplicate upload (" + source + ")</color>");
							result = false;
							break;
						}
						if (!string.IsNullOrWhiteSpace(<>4__this._pendingUploadedScreenshotUrl))
						{
							goto IL_02fd;
						}
						<>8__4 = new <>c__DisplayClass148_1();
						<>8__4.uploadedFileUrl = null;
						<>2__current = <>4__this.UploadMatchScreenshotFile(delegate(string url)
						{
							<>8__4.uploadedFileUrl = url;
						});
						<>1__state = 3;
						result = true;
						goto end_IL_0000;
					case 3:
						<>1__state = -3;
						if (string.IsNullOrWhiteSpace(<>8__4.uploadedFileUrl))
						{
							<>4__this.Log("<color=yellow>[Match Screenshot] UploadFile did not return a file URL (" + source + ") - keeping screenshot for retry</color>");
							result = false;
							break;
						}
						<>4__this._pendingUploadedScreenshotUrl = <>8__4.uploadedFileUrl;
						<>8__4 = null;
						goto IL_02fd;
					case 4:
						{
							<>1__state = -3;
							if (<>8__1.uploadSucceeded)
							{
								<>4__this._matchScreenshotUploadCompleted = true;
								<>4__this.ClearPendingMatchScreenshot();
								<>4__this.Log("<color=green>[Match Screenshot] ✓ Attached scoreboard screenshot to Match " + <>4__this._currentMatchId + "</color>");
								<>4__this.ShowUploadNotification("Attached end-of-match screenshot for review.");
							}
							else
							{
								<>4__this.Log("<color=yellow>[Match Screenshot] Screenshot upload did not succeed yet (" + source + ") - will keep the screenshot for fallback retry</color>");
							}
							<>8__1 = null;
							<payload>5__3 = null;
							<>m__Finally1();
							result = false;
							goto end_IL_0000;
						}
						IL_0139:
						<>8__1.existingScreenshotUrl = null;
						<>8__1.readSucceeded = false;
						<>2__current = <>4__this.CallAPI("/Match/" + <>4__this._currentMatchId, "GET", "", delegate(string res)
						{
							<>8__1.readSucceeded = true;
							JObject val2 = <>8__1.<>4__this.ParseApiSingleObject(res);
							<>8__1.existingScreenshotUrl = (string)((val2 != null) ? val2["screenshot_url"] : null);
						});
						<>1__state = 2;
						result = true;
						goto end_IL_0000;
						IL_02fd:
						<payload>5__3 = new JObject { ["screenshot_url"] = JToken.op_Implicit(<>4__this._pendingUploadedScreenshotUrl) };
						<>8__1.uploadSucceeded = false;
						<>2__current = <>4__this.CallAPI("/Match/" + <>4__this._currentMatchId, "PUT", ((JToken)<payload>5__3).ToString((Formatting)0, Array.Empty<JsonConverter>()), delegate(string res)
						{
							JObject val = <>8__1.<>4__this.ParseApiSingleObject(res);
							<>8__1.uploadSucceeded = val != null;
						});
						<>1__state = 4;
						result = true;
						goto end_IL_0000;
					}
					<>m__Finally1();
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				<>4__this._matchScreenshotUploadInProgress = false;
			}

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

		[CompilerGenerated]
		private sealed class <UploadMatchScreenshotFile>d__149 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Action<string> onUploaded;

			public SBGLPlugin <>4__this;

			private string <uploadUrl>5__1;

			private WWWForm <form>5__2;

			private UnityWebRequest <req>5__3;

			private JObject <response>5__4;

			private string <fileUrl>5__5;

			private string <errorMsg>5__6;

			private int <length>5__7;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<uploadUrl>5__1 = null;
				<form>5__2 = null;
				<req>5__3 = null;
				<response>5__4 = null;
				<fileUrl>5__5 = null;
				<errorMsg>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Invalid comparison between Unknown and I4
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				//IL_0261: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (<>4__this._pendingMatchScreenshotBytes == null || <>4__this._pendingMatchScreenshotBytes.Length == 0)
						{
							onUploaded?.Invoke(null);
							return false;
						}
						<uploadUrl>5__1 = <>4__this.GetCoreIntegrationEndpointUrl("UploadFile");
						<form>5__2 = new WWWForm();
						<form>5__2.AddBinaryData("file", <>4__this._pendingMatchScreenshotBytes, <>4__this._pendingMatchScreenshotFileName ?? <>4__this.BuildMatchScreenshotFileName(), "image/jpeg");
						<>4__this.Log($"<color=cyan>[Match Screenshot] Uploading screenshot file via Core/UploadFile ({(float)<>4__this._pendingMatchScreenshotBytes.Length / 1024f:0.#} KB)</color>");
						<req>5__3 = UnityWebRequest.Post(<uploadUrl>5__1, <form>5__2);
						<>1__state = -3;
						<>4__this.ApplyIntegrationHeaders(<req>5__3);
						<req>5__3.SetRequestHeader("Accept", "application/json");
						<>2__current = <req>5__3.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__3.result == 1)
						{
							<response>5__4 = <>4__this.ParseApiSingleObject(<req>5__3.downloadHandler.text);
							JObject obj = <response>5__4;
							string text = (string)((obj != null) ? obj["file_url"] : null);
							if (text == null)
							{
								JObject obj2 = <response>5__4;
								text = (string)((obj2 != null) ? obj2["url"] : null);
							}
							<fileUrl>5__5 = text;
							if (!string.IsNullOrWhiteSpace(<fileUrl>5__5))
							{
								<>4__this.Log("<color=green>[Match Screenshot] ✓ Screenshot uploaded to file storage</color>");
								onUploaded?.Invoke(<fileUrl>5__5);
							}
							else
							{
								<>4__this.Log("<color=yellow>[Match Screenshot] UploadFile succeeded but response did not contain file_url</color>");
								onUploaded?.Invoke(null);
							}
							<response>5__4 = null;
							<fileUrl>5__5 = null;
						}
						else
						{
							<errorMsg>5__6 = $"[Match Screenshot] UploadFile failed: {<req>5__3.result}";
							if (!string.IsNullOrEmpty(<req>5__3.error))
							{
								<errorMsg>5__6 = <errorMsg>5__6 + " - " + <req>5__3.error;
							}
							if (<req>5__3.responseCode > 0)
							{
								<errorMsg>5__6 += $" (HTTP {<req>5__3.responseCode})";
							}
							DownloadHandler downloadHandler = <req>5__3.downloadHandler;
							if (!string.IsNullOrEmpty((downloadHandler != null) ? downloadHandler.text : null))
							{
								<length>5__7 = Math.Min(240, <req>5__3.downloadHandler.text.Length);
								<errorMsg>5__6 = <errorMsg>5__6 + " - Response: " + <req>5__3.downloadHandler.text.Substring(0, <length>5__7);
							}
							<>4__this.Log("<color=red>" + <errorMsg>5__6 + "</color>");
							onUploaded?.Invoke(null);
							<errorMsg>5__6 = null;
						}
						<>m__Finally1();
						<req>5__3 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__3 != null)
				{
					((IDisposable)<req>5__3).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <UploadSteamLobbyLink>d__193 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string steamLink;

			public SBGLPlugin <>4__this;

			private string <json>5__1;

			private UnityWebRequest <req>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<json>5__1 = null;
				<req>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Invalid comparison between Unknown and I4
				//IL_0251: 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_0126: Expected O, but got Unknown
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Expected O, but got Unknown
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (<>4__this._currentSession == null || string.IsNullOrEmpty(steamLink))
						{
							return false;
						}
						if (string.Equals(<>4__this._currentSession.steam_lobby_link, steamLink, StringComparison.Ordinal))
						{
							<>4__this.Log("Steam Lobby Link already synced. Skipping redundant upload.");
							return false;
						}
						<>4__this._steamLinkUploadAttempts++;
						<>4__this._lastUploadAttemptAt = DateTime.Now;
						<>4__this._lastGeneratedSteamLink = steamLink;
						<>4__this.Log("Uploading Steam Lobby Link to API...");
						<json>5__1 = "{\"steam_lobby_link\":\"" + steamLink + "\"}";
						<req>5__2 = new UnityWebRequest(<>4__this.GetBaseApiUrl() + "/MatchmakingSession/" + <>4__this._currentSession.id, "PUT");
						<>1__state = -3;
						<req>5__2.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(<json>5__1));
						<req>5__2.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
						<>4__this.ApplyApiHeaders(<req>5__2);
						<>2__current = <req>5__2.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__2.result == 1)
						{
							<>4__this._steamLinkUploadSuccesses++;
							<>4__this._lastUploadSuccessAt = DateTime.Now;
							<>4__this._lastUploadedSteamLink = steamLink;
							<>4__this._currentSession.steam_lobby_link = steamLink;
							<>4__this._lastUploadError = "-";
							<>4__this.Log("<color=green>Steam Lobby Link uploaded successfully.</color>");
						}
						else
						{
							<>4__this._steamLinkUploadFailures++;
							<>4__this._lastUploadError = $"{<req>5__2.result}: {<req>5__2.error}";
							<>4__this.Log("<color=red>Steam Lobby Link upload failed: " + <>4__this._lastUploadError + "</color>");
						}
						<>m__Finally1();
						<req>5__2 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__2 != null)
				{
					((IDisposable)<req>5__2).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <ValidateMatchUpload>d__231 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Action<bool> callback;

			public SBGLPlugin <>4__this;

			private string <lobbyName>5__1;

			private bool <allowFallback>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (PlayerPrefs.GetString("MatchType", "").Contains("pro_series"))
					{
						if (!<>4__this._proSeriesSkipLogged)
						{
							<>4__this.Log("<color=yellow>[Match] Pro Series match — automated upload skipped</color>");
							<>4__this._proSeriesSkipLogged = true;
						}
						callback?.Invoke(obj: false);
						return false;
					}
					if (<>4__this._userProfile == null)
					{
						<>2__current = <>4__this.EnsureUserProfileResolved("Match Upload Validation", 6f);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<>4__this._userProfile == null)
				{
					<>4__this.Log("<color=yellow>[Match Upload Validation] Profile is still null after waiting for resolution</color>");
					<>4__this.ShowUploadNotification("Upload validation failed: missing profile", "failure");
					callback?.Invoke(obj: false);
					return false;
				}
				<lobbyName>5__1 = <>4__this.ResolveCurrentLobbyName();
				if (<>4__this.IgnoreSbglLobbyRequirementEnabled)
				{
					<>4__this.Log("<color=orange>[Match Upload Validation] Upload All Matches enabled. Bypassing SBGL-* lobby requirement for '" + <lobbyName>5__1 + "'.</color>");
					<>4__this.ShowUploadNotification("Uploading match results (Upload All Matches enabled)...");
					callback?.Invoke(obj: true);
					return false;
				}
				if (string.IsNullOrEmpty(<lobbyName>5__1))
				{
					<allowFallback>5__2 = <>4__this._isInGameplay || IsRankedTriggered || <>4__this._currentSession != null;
					if (<allowFallback>5__2)
					{
						<>4__this.Log("<color=orange>[Match Upload Validation] Lobby name unresolved (blank). Allowing upload due to active ranked/session context.</color>");
						<>4__this.ShowUploadNotification("Uploading match results (lobby name unresolved)...");
						callback?.Invoke(obj: true);
						return false;
					}
				}
				if (!IsSbglLobbyName(<lobbyName>5__1))
				{
					<>4__this.Log("<color=yellow>[Match Upload Validation] Lobby name '" + <lobbyName>5__1 + "' does not match 'SBGL-*' pattern</color>");
					<>4__this.ShowUploadNotification("Upload blocked: Lobby '" + <lobbyName>5__1 + "' is not SBGL-*", "warning");
					callback?.Invoke(obj: false);
					return false;
				}
				<>4__this.Log("<color=cyan>[Match Upload Validation] ✓ Lobby name matches pattern: " + <lobbyName>5__1 + "</color>");
				<>4__this.ShowUploadNotification("Uploading match results for " + <lobbyName>5__1 + "...");
				<>4__this.Log("<color=green>[Match Upload Validation] ✓ Validation passed - proceeding with upload</color>");
				callback?.Invoke(obj: true);
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <WaitForExistingMatchBeforeFallback>d__165 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float delaySeconds;

			public Action<string> onResolved;

			public SBGLPlugin <>4__this;

			private float <waited>5__1;

			private <>c__DisplayClass165_0 <>8__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this._currentSession == null || delaySeconds <= 0f)
					{
						onResolved?.Invoke(null);
						return false;
					}
					<waited>5__1 = 0f;
					break;
				case 1:
					<>1__state = -1;
					if (!string.IsNullOrEmpty(<>8__2.existingMatchId))
					{
						onResolved?.Invoke(<>8__2.existingMatchId);
						return false;
					}
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<waited>5__1 += 1f;
					<>8__2 = null;
					break;
				}
				if (<waited>5__1 < delaySeconds)
				{
					<>8__2 = new <>c__DisplayClass165_0();
					<>8__2.existingMatchId = null;
					<>2__current = <>4__this.ResolveExistingMatchIdForCurrentSession(delegate(string id)
					{
						<>8__2.existingMatchId = id;
					}, logMisses: false);
					<>1__state = 1;
					return true;
				}
				onResolved?.Invoke(null);
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <WaitForPendingMatchEntryCreation>d__168 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string playerId;

			public Action<string> onResolved;

			public SBGLPlugin <>4__this;

			private float <waited>5__1;

			private string <resolvedEntryId>5__2;

			private string <entryId>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<resolvedEntryId>5__2 = null;
				<entryId>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<waited>5__1 = 0f;
					break;
				case 1:
					<>1__state = -1;
					<waited>5__1 += 0.25f;
					<entryId>5__3 = null;
					break;
				}
				if (!string.IsNullOrWhiteSpace(playerId) && <>4__this._matchEntryCreationInProgress.Contains(playerId) && <waited>5__1 < 3f)
				{
					if (<>4__this._playerMatchEntryIds.TryGetValue(playerId, out <entryId>5__3) && !string.IsNullOrWhiteSpace(<entryId>5__3))
					{
						onResolved?.Invoke(<entryId>5__3);
						return false;
					}
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 1;
					return true;
				}
				if (!string.IsNullOrWhiteSpace(playerId) && <>4__this._playerMatchEntryIds.TryGetValue(playerId, out <resolvedEntryId>5__2) && !string.IsNullOrWhiteSpace(<resolvedEntryId>5__2))
				{
					onResolved?.Invoke(<resolvedEntryId>5__2);
				}
				else
				{
					onResolved?.Invoke(null);
				}
				return false;
			}

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

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

		private Dictionary<string, string> _randomizedPlayerMap = null;

		private static readonly List<string> _sbglTestNames = new List<string>
		{
			"TrashxCat", "KingCire03", "FucklTheIRS", "Jackie", "TikTok Z4C_FN", "adthykrshnn", "mrguy7608", "Noah_Boatt", "YoMaMMeJr", "TheMrEStudio",
			"Odius9064", "Jake paul", "f19chy", "Kodakblackarack", "ArrowTheFighter", "limbo", "Marcus_Pipes", "That Traynor", "Blinkerfluid", "TaxiCAB",
			"Achunl2", "Cinereous", "Liafeon", "Peter", "Inkie", "LLENN", "Nanainasuit", "Midnight", "PattyTits", "Bekuh",
			"Lunwik", "yackback", "AlpineMilk", "HandsomeSkippy", "TheOneKP", "RealJosher", "Ooshida", "Moto", "Jozza", "Patrick Swayze",
			"ryan.scibetta", "Zaikr", "Thalosii", "paradiorevey", "Ricee", "Slacker87", "MRGoldberg", "trusted", "designedsilence", "The Oreo Orgy",
			"Zoboomafoo", "Yoda Cage", "Black Dolphin", "Pengini", "antyde", "Glider", "lyth", "Jabobus.o7", "dkgaming219", "Cody",
			"Sidimmu", "снусмумрик", "Skydown26", "Jeb", "Vac", "Slem Dogg", "Batto", "Broj0e"
		};

		private ConfigEntry<bool> _showLogsConfig;

		private ConfigEntry<bool> _showFlowDebugConfig;

		private ConfigEntry<bool> _showUploadNoticesConfig;

		private ConfigEntry<bool> _ignoreSbglLobbyRequirementConfig;

		private ConfigEntry<string> _testPlayerOverridesConfig;

		private ConfigEntry<bool> _testRandomizeAllPlayersConfig;

		private ManualLogSource _bepinexLogger;

		private bool _isInitializing = true;

		private int _onlineCount = 0;

		private int _queuedCount = 0;

		private int _matchedCount = 0;

		public static bool IsRankedTriggered = false;

		public static string CurrentMatchId = null;

		private bool _isQueueing = false;

		private string _webStatus = "IDLE";

		private string _currentQueueId = "";

		private PlayerProfile _userProfile = null;

		private MatchmakingSession _currentSession = null;

		private bool _isHost = false;

		private bool _hasAccepted = false;

		private string _hostRulesetSelection = "ranked";

		private string _queueTypeSelection = "ranked";

		private DateTime? _queueStartTime = null;

		private bool _hostLobbyStarted = false;

		private bool _hostServerWasActive = false;

		private bool _hostCancelSent = false;

		private bool _matchStatsSubmitted = false;

		private bool _proSeriesSkipLogged = false;

		private DateTime? _matchStartTime = null;

		private Dictionary<string, int> _cachedLeaderboardScores = new Dictionary<string, int>();

		private Dictionary<string, int> _cachedLeaderboardScoresVsPar = new Dictionary<string, int>();

		private string __currentMatchId = null;

		private HashSet<string> _finalizedMatchIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private Dictionary<string, string> _playerMatchEntryIds = new Dictionary<string, string>();

		private HashSet<string> _matchEntryCreationInProgress = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private Dictionary<string, string> _playerIdsByName = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private Dictionary<string, int> _lastSubmittedScores = new Dictionary<string, int>();

		private Dictionary<string, int> _lastSubmittedScoresVsPar = new Dictionary<string, int>();

		private int _matchExpectedPlayerCount = 2;

		private int _lastUploadedPlayerCount = -1;

		private List<CachedLeaderboardPlayer> _finalLeaderboardSnapshot = new List<CachedLeaderboardPlayer>();

		private byte[] _pendingMatchScreenshotBytes = null;

		private string _pendingMatchScreenshotFileName = null;

		private string _pendingUploadedScreenshotUrl = null;

		private bool _matchScreenshotUploadInProgress = false;

		private bool _matchScreenshotUploadCompleted = false;

		private bool _matchEntriesCreated = false;

		private bool _matchCreationInProgress = false;

		private bool _isInGameplay = false;

		private bool _matchEndedReceived = false;

		private Coroutine _monitorCoroutine = null;

		private Coroutine _lobbyMonitorCoroutine = null;

		private Coroutine _endOfMatchSignalCoroutine = null;

		private Coroutine _matchScreenshotSignalCoroutine = null;

		private Coroutine _courseEndRpcCoroutine = null;

		private float _nextEnsureMatchCreateAttemptAt = 0f;

		private string _localManualSessionId = null;

		private const int MatchScreenshotMaxWidth = 1920;

		private const int MatchScreenshotMaxHeight = 1080;

		private const int MatchScreenshotTargetMaxBytes = 819200;

		private const int MatchScreenshotHardMaxBytes = 1048576;

		private string _activeSeasonId = null;

		private bool _activeSeasonFetched = false;

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

		private List<PlayerData> _queuedPlayers = new List<PlayerData>();

		private Vector2 _logScroll;

		private Texture2D _profileTexture = null;

		private Texture2D _solidBgTex = null;

		private bool _hasFetchedProfilePic = false;

		private GUIStyle _centerLabelStyle = null;

		private GUIStyle _debugLineStyle = null;

		private string _uploadNotification = "";

		private DateTime _uploadNotificationTime = DateTime.MinValue;

		private const float _uploadNotificationDuration = 4f;

		private Color _uploadNotificationColor = new Color(0.2f, 0.85f, 1f);

		private string _debugLobbySessionSource = "";

		private string _debugLobbyPrefsSource = "";

		private string _debugLobbyCapturedSource = "";

		private string _debugLobbyResolved = "";

		private string _debugLobbyResolvedBy = "none";

		private MatchResultSubmissionService _matchResultSubmission;

		private static readonly WaitForSeconds _syncLoopDelay = new WaitForSeconds(5f);

		private static readonly WaitForSeconds _readyTransitionDelay = new WaitForSeconds(0.5f);

		private int _syncTickCount = 0;

		private int _lobbyCreatedEventCount = 0;

		private int _steamLinkUploadAttempts = 0;

		private int _steamLinkUploadSuccesses = 0;

		private int _steamLinkUploadFailures = 0;

		private int _autoJoinAttempts = 0;

		private int _autoJoinSuccesses = 0;

		private int _autoJoinFailures = 0;

		private DateTime? _lastLobbyCreatedAt = null;

		private DateTime? _lastUploadAttemptAt = null;

		private DateTime? _lastUploadSuccessAt = null;

		private DateTime? _lastAutoJoinAttemptAt = null;

		private DateTime? _lastAutoJoinSuccessAt = null;

		private string _lastGeneratedSteamLink = "-";

		private string _lastUploadedSteamLink = "-";

		private string _lastAutoJoinSteamLink = "-";

		private string _lastUploadError = "-";

		private string _lastAutoJoinError = "-";

		private bool IgnoreSbglLobbyRequirementEnabled => _ignoreSbglLobbyRequirementConfig?.Value ?? false;

		private string _currentMatchId
		{
			get
			{
				return __currentMatchId;
			}
			set
			{
				__currentMatchId = value;
				CurrentMatchId = value;
			}
		}

		public bool IsQueueing => _isQueueing;

		public bool IsHost => _isHost;

		public bool HasAccepted => _hasAccepted;

		public PlayerProfile UserProfile => _userProfile;

		public MatchmakingSession CurrentSession => _currentSession;

		private string GetBaseApiUrl()
		{
			return UnifiedPlugin.GetCurrentPlayerApi().Replace("/Player", "");
		}

		private string GetAppId()
		{
			return UnifiedPlugin.GetCurrentAppId();
		}

		private string GetAuthToken()
		{
			return UnifiedPlugin.GetCurrentAuthToken();
		}

		public void SetConfig(ConfigEntry<bool> showLogs, ConfigEntry<bool> showFlowDebug, ConfigEntry<bool> showUploadNotices, ConfigEntry<bool> ignoreSbglLobbyRequirement, ConfigEntry<string> testPlayerOverrides, ConfigEntry<bool> testRandomizeAllPlayers, ManualLogSource bepinexLogger)
		{
			_showLogsConfig = showLogs;
			_showFlowDebugConfig = showFlowDebug;
			_showUploadNoticesConfig = showUploadNotices;
			_ignoreSbglLobbyRequirementConfig = ignoreSbglLobbyRequirement;
			_testPlayerOverridesConfig = testPlayerOverrides;
			_testRandomizeAllPlayersConfig = testRandomizeAllPlayers;
			_bepinexLogger = bepinexLogger;
		}

		private Dictionary<string, string> GetTestPlayerOverrides(List<string> currentPlayerNames = null)
		{
			if (_testRandomizeAllPlayersConfig != null && _testRandomizeAllPlayersConfig.Value && currentPlayerNames != null)
			{
				if (_randomizedPlayerMap == null || _randomizedPlayerMap.Count != currentPlayerNames.Count || !_randomizedPlayerMap.Keys.SequenceEqual(currentPlayerNames))
				{
					List<string> source = new List<string>(_sbglTestNames);
					Random rand = new Random();
					Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
					List<string> list = source.OrderBy((string x) => rand.Next()).ToList();
					int num = 0;
					foreach (string currentPlayerName in currentPlayerNames)
					{
						if (string.IsNullOrWhiteSpace(currentPlayerName))
						{
							continue;
						}
						if (_userProfile != null && string.Equals(currentPlayerName, _userProfile.display_name, StringComparison.OrdinalIgnoreCase))
						{
							dictionary[currentPlayerName] = currentPlayerName;
							continue;
						}
						if (num >= list.Count)
						{
							num = 0;
						}
						dictionary[currentPlayerName] = list[num++];
					}
					_randomizedPlayerMap = dictionary;
				}
				return _randomizedPlayerMap;
			}
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			string text = _testPlayerOverridesConfig?.Value;
			if (string.IsNullOrWhiteSpace(text))
			{
				return dictionary2;
			}
			string[] array = text.Split(',');
			foreach (string text2 in array)
			{
				int num2 = text2.IndexOf('=');
				if (num2 > 0 && num2 < text2.Length - 1)
				{
					string text3 = text2.Substring(0, num2).Trim();
					string value = text2.Substring(num2 + 1).Trim();
					if (!string.IsNullOrWhiteSpace(text3) && !string.IsNullOrWhiteSpace(value))
					{
						dictionary2[text3] = value;
					}
				}
			}
			return dictionary2;
		}

		private string ApplyTestPlayerOverride(string displayName, Dictionary<string, string> overrides)
		{
			if (overrides != null && overrides.TryGetValue(displayName, out var value))
			{
				Log("<color=magenta>[Test Override] '" + displayName + "' → '" + value + "'</color>");
				return value;
			}
			return displayName;
		}

		public IEnumerator MatchmakingLoopCoroutine()
		{
			return MatchmakingLoop();
		}

		public IEnumerator AcceptMatchCoroutine()
		{
			return AcceptMatch();
		}

		public void InitiateHostSequencePublic()
		{
			InitiateHostSequence();
		}

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

		private static bool IsProSeriesMatchType(string matchType)
		{
			return !string.IsNullOrWhiteSpace(matchType) && matchType.IndexOf("pro_series", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static bool IsCasualMatchType(string matchType)
		{
			return !string.IsNullOrWhiteSpace(matchType) && matchType.IndexOf("casual", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private bool IsCurrentMatchCasual()
		{
			if (IsCasualMatchType(_currentSession?.match_type))
			{
				return true;
			}
			return IsCasualMatchType(PlayerPrefs.GetString("MatchType", ""));
		}

		private string GetQueueMatchTypePayload()
		{
			string @string = PlayerPrefs.GetString("MatchType", "ranked_season_1");
			return IsCasualMatchType(@string) ? "casual" : "ranked";
		}

		[IteratorStateMachine(typeof(<IncrementCasualMatchesPlayedForActivePlayers>d__132))]
		private IEnumerator IncrementCasualMatchesPlayedForActivePlayers(List<LiveLeaderboardPlugin.SBGLPlayer> leaderboardPlayers)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <IncrementCasualMatchesPlayedForActivePlayers>d__132(0)
			{
				<>4__this = this,
				leaderboardPlayers = leaderboardPlayers
			};
		}

		private void Awake()
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002a: 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)
			_solidBgTex = new Texture2D(1, 1);
			_solidBgTex.SetPixel(0, 0, new Color(0.02f, 0.02f, 0.02f, 1f));
			_solidBgTex.Apply();
			SceneManager.sceneLoaded += OnSceneLoaded;
			CourseManager.MatchStateChanged += OnCourseManagerMatchStateChanged;
			CourseManager.ForceDisplayScoreboardChanged += OnCourseManagerForceDisplayScoreboardChanged;
			new Harmony("com.sbgl.matchmaking").PatchAll();
			Log("Plugin Loaded v6.2.1. Self-Sync Reconciliation Active.");
			_matchResultSubmission = new MatchResultSubmissionService(GetBaseApiUrl, Log, CallAPI, ParseApiSingleObject, delegate(IEnumerator coro)
			{
				((MonoBehaviour)this).StartCoroutine(coro);
			});
			UnifiedPlugin.ApiConfigChanged += OnApiConfigChanged;
			((MonoBehaviour)this).StartCoroutine(BackgroundSyncLoop());
		}

		private void OnApiConfigChanged()
		{
			Log("⚡ API Configuration changed - Switching environments and refreshing profile");
			_userProfile = null;
			_isInitializing = true;
			_webStatus = "ENVIRONMENT SWITCHING...";
			ResetPluginState();
		}

		private void OnEnable()
		{
			try
			{
				SteamMatchmaking.OnLobbyCreated += OnLobbyCreatedCallback;
			}
			catch (Exception ex)
			{
				Log("Warning: Could not hook LobbyCreated event: " + ex.Message);
			}
		}

		private void OnDisable()
		{
			try
			{
				SteamMatchmaking.OnLobbyCreated -= OnLobbyCreatedCallback;
			}
			catch
			{
			}
		}

		private void OnLobbyCreatedCallback(Result result, Lobby lobby)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if ((int)result != 1)
			{
				_lastUploadError = $"Lobby create callback failed: {result}";
				Log($"Lobby creation failed: {result}");
				return;
			}
			SteamId id = ((Lobby)(ref lobby)).Id;
			if (!((SteamId)(ref id)).IsValid)
			{
				_lastUploadError = "Lobby created callback had invalid lobby id.";
				Log("Lobby ID is invalid!");
			}
			else
			{
				if (!_isHost || _currentSession == null)
				{
					return;
				}
				ulong value = ((Lobby)(ref lobby)).Id.Value;
				ulong num = 0uL;
				try
				{
					if (SteamClient.IsValid)
					{
						num = SteamClient.SteamId.Value;
					}
				}
				catch
				{
				}
				if (num != 0)
				{
					string text = $"steam://joinlobby/4069520/{value}/{num}";
					_lobbyCreatedEventCount++;
					_lastLobbyCreatedAt = DateTime.Now;
					_lastGeneratedSteamLink = text;
					Log($"Lobby created! ID: {value}, uploading link...");
					((MonoBehaviour)this).StartCoroutine(UploadSteamLobbyLink(text));
				}
				else
				{
					_lastUploadError = "Steam client invalid while trying to build host steam link.";
					Log("<color=orange>Lobby created but Steam ID could not be resolved.</color>");
				}
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			string text = ((Scene)(ref scene)).name.ToLower();
			Log("<color=cyan>[Scene] Loaded: " + ((Scene)(ref scene)).name + "</color>");
			string text2 = ResolveCurrentLobbyName();
			bool flag = !string.IsNullOrEmpty(text2) && text2.StartsWith("SBGL-", StringComparison.OrdinalIgnoreCase);
			bool flag2 = IgnoreSbglLobbyRequirementEnabled || IsRankedTriggered || flag;
			if (!text.Contains("menu") && !text.Contains("drivingrange") && !text.Contains("driving range") && !text.Contains("lobby"))
			{
				_isInGameplay = true;
				if (_currentSession != null && string.Equals(_currentSession.status, "completed", StringComparison.OrdinalIgnoreCase))
				{
					Log("<color=cyan>[Match] Previous MatchmakingSession status was 'completed' — clearing session so new match can be created</color>");
					_currentSession = null;
				}
				if (flag2 && ((_currentSession != null && (_currentSession.status == "ready" || _currentSession.status == "in_progress")) || _currentSession == null) && !_matchEntriesCreated)
				{
					Log("<color=yellow>[Match] Entering gameplay - validating match eligibility...</color>");
					((MonoBehaviour)this).StartCoroutine(ValidateMatchUpload(delegate(bool shouldUpload)
					{
						if (shouldUpload)
						{
							Log("<color=yellow>[Match] Creating match records...</color>");
							((MonoBehaviour)this).StartCoroutine(CreateMatchAndEntries());
						}
						else
						{
							Log("<color=orange>[Match] Match does not meet upload criteria at load - starting lobby rename monitor</color>");
						}
					}));
				}
				if (_monitorCoroutine == null)
				{
					_monitorCoroutine = ((MonoBehaviour)this).StartCoroutine(MonitorAndUpdateScores());
				}
				if (_lobbyMonitorCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(_lobbyMonitorCoroutine);
				}
				_lobbyMonitorCoroutine = ((MonoBehaviour)this).StartCoroutine(MonitorLobbyNameForUpload());
			}
			if (_isInGameplay && (text.Contains("drivingrange") || text.Contains("driving range")))
			{
				_isInGameplay = false;
				StopGameplayCoroutinesForMatchEnd("scene transition to driving range");
				TryCaptureFinalLeaderboardSnapshot("scene transition");
			}
			if (text.Contains("drivingrange") || text.Contains("driving range"))
			{
				if (!_matchStatsSubmitted && !string.IsNullOrEmpty(_currentMatchId))
				{
					Log("<color=cyan>[Match Stats] Returned to Driving Range - running final match finalization before reset...</color>");
					((MonoBehaviour)this).StartCoroutine(FinalizeAndResetAfterDrivingRange());
				}
				else
				{
					if (_matchStatsSubmitted && !string.IsNullOrWhiteSpace(_currentMatchId))
					{
						_finalizedMatchIds.Add(_currentMatchId);
					}
					ResetPerMatchState();
				}
				if (_isQueueing && !_hasAccepted)
				{
					Log("<color=orange>[Queue] Player entered Driving Range while queued - cancelling queue entry...</color>");
					((MonoBehaviour)this).StartCoroutine(LeaveQueue());
				}
			}
			if (text.Contains("menu"))
			{
				if (_isHost && _hostLobbyStarted && _hostServerWasActive && _currentSession != null)
				{
					((MonoBehaviour)this).StartCoroutine(CancelSessionAsHost("host_returned_to_menu"));
				}
				ResetPluginState();
				Log("Returned to Menu: State Reset.");
			}
		}

		private void OnCourseManagerMatchStateChanged(MatchState previousState, MatchState currentState)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (_isInGameplay)
			{
				Log($"<color=cyan>[Match Signal] CourseManager.MatchStateChanged: {previousState} -> {currentState} (ignored for course-end)</color>");
			}
		}

		private void OnCourseManagerForceDisplayScoreboardChanged()
		{
			if (_isInGameplay && CourseManager.ForceDisplayScoreboard)
			{
				Log("<color=cyan>[Match Signal] CourseManager forced the scoreboard (capture-only)</color>");
				if (_matchScreenshotSignalCoroutine == null && !_matchScreenshotUploadCompleted)
				{
					_matchScreenshotSignalCoroutine = ((MonoBehaviour)this).StartCoroutine(CaptureAndStorePerHoleScreenshot("CourseManager.ForceDisplayScoreboardChanged"));
				}
			}
		}

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

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

		private void TryBeginAssemblyDrivenFinalization(string source)
		{
			if (_endOfMatchSignalCoroutine == null && !_matchStatsSubmitted && !string.IsNullOrWhiteSpace(_currentMatchId))
			{
				_endOfMatchSignalCoroutine = ((MonoBehaviour)this).StartCoroutine(FinalizeFromGameplaySignal(source));
			}
		}

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

		private void StopGameplayCoroutinesForMatchEnd(string source)
		{
			if (_monitorCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_monitorCoroutine);
				_monitorCoroutine = null;
				Log("<color=cyan>[Match] Score monitoring stopped (" + source + ")</color>");
			}
			if (_lobbyMonitorCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_lobbyMonitorCoroutine);
				_lobbyMonitorCoroutine = null;
			}
		}

		private bool TryCaptureFinalLeaderboardSnapshot(string source)
		{
			try
			{
				LiveLeaderboardPlugin liveLeaderboardPlugin = Object.FindAnyObjectByType<LiveLeaderboardPlugin>((FindObjectsInactive)1);
				if ((Object)(object)liveLeaderboardPlugin == (Object)null)
				{
					return _finalLeaderboardSnapshot != null && _finalLeaderboardSnapshot.Count > 0;
				}
				liveLeaderboardPlugin.CaptureLeaderboardSnapshot();
				CacheLeaderboardSnapshot(liveLeaderboardPlugin.GetFinalLeaderboardSnapshot(), source);
				if (_finalLeaderboardSnapshot != null && _finalLeaderboardSnapshot.Count > 0)
				{
					Log("<color=green>[Match] ✓ Leaderboard snapshot captured from " + source + "</color>");
					return true;
				}
			}
			catch (Exception ex)
			{
				Log("<color=yellow>[Match] Could not capture " + source + " snapshot: " + ex.Message + "</color>");
			}
			return _finalLeaderboardSnapshot != null && _finalLeaderboardSnapshot.Count > 0;
		}

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

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

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

		private string BuildMatchScreenshotFileName()
		{
			string text = ((!string.IsNullOrWhiteSpace(_currentMatchId)) ? _currentMatchId : DateTime.UtcNow.ToString("yyyyMMddHHmmss"));
			return "match-" + text + ".jpg";
		}

		private string GetCoreIntegrationEndpointUrl(string functionName)
		{
			string baseApiUrl = GetBaseApiUrl();
			int num = baseApiUrl.LastIndexOf("/entities", StringComparison.OrdinalIgnoreCase);
			string text = ((num >= 0) ? baseApiUrl.Substring(0, num) : baseApiUrl);
			return text + "/integration-endpoints/Core/" + functionName;
		}

		private void ApplyIntegrationHeaders(UnityWebRequest req)
		{
			if (req != null)
			{
				string authToken = GetAuthToken();
				if (!string.IsNullOrWhiteSpace(authToken))
				{
					req.SetRequestHeader("api_key", authToken);
				}
				req.SetRequestHeader("X-App-Id", GetAppId());
			}
		}

		private void ClearPendingMatchScreenshot()
		{
			_pendingMatchScreenshotBytes = null;
			_pendingMatchScreenshotFileName = null;
			_pendingUploadedScreenshotUrl = null;
		}

		public void OnCourseRpcInformEndingCourse()
		{
			try
			{
				if (_courseEndRpcCoroutine == null)
				{
					_courseEndRpcCoroutine = ((MonoBehaviour)this).StartCoroutine(HandleCourseEndRpcCoroutine());
				}
			}
			catch (Exception ex)
			{
				Log("<color=yellow>[Match Signal] Error starting CourseEnd RPC handler: " + ex.Message + "</color>");
			}
		}

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

		private float GetCurrentPlayerScreenshotUploadDelaySeconds()
		{
			if (_currentSession?.player_ids == null || string.IsNullOrWhiteSpace(_userProfile?.id))
			{
				return 0f;
			}
			List<string> list = _currentSession.player_ids.Where((string id) => !string.IsNullOrWhiteSpace(id)).Distinct<string>(StringComparer.Ordinal).OrderBy<string, string>((string id) => id, StringComparer.Ordinal)
				.ToList();
			if (list.Count == 0)
			{
				return 0f;
			}
			int num = list.FindIndex((string id) => string.Equals(id, _userProfile.id, StringComparison.Ordinal));
			if (num <= 0)
			{
				return 0f;
			}
			float num2 = (float)num * 0.5f;
			Log($"<color=cyan>[Match Screenshot] Upload slot {num + 1}/{list.Count}; waiting {num2:0.#}s before checking Match.screenshot_url</color>");
			return num2;
		}

		private Texture2D ResizeTextureToFit(Texture2D source, int maxWidth, int maxHeight)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null || ((Texture)source).width <= 0 || ((Texture)source).height <= 0)
			{
				return source;
			}
			if (((Texture)source).width <= maxWidth && ((Texture)source).height <= maxHeight)
			{
				return source;
			}
			float num = Mathf.Min((float)maxWidth / (float)((Texture)source).width, (float)maxHeight / (float)((Texture)source).height);
			int num2 = Mathf.Max(1, Mathf.RoundToInt((float)((Texture)source).width * num));
			int num3 = Mathf.Max(1, Mathf.RoundToInt((float)((Texture)source).height * num));
			RenderTexture active = RenderTexture.active;
			RenderTexture temporary = RenderTexture.GetTemporary(num2, num3, 0, (RenderTextureFormat)0);
			try
			{
				Graphics.Blit((Texture)(object)source, temporary);
				RenderTexture.active = temporary;
				Texture2D val = new Texture2D(num2, num3, (TextureFormat)3, false);
				val.ReadPixels(new Rect(0f, 0f, (float)num2, (float)num3), 0, 0, false);
				val.Apply(false, false);
				return val;
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
			}
		}

		private byte[] EncodeScreenshotBytes(Texture2D texture)
		{
			if ((Object)(object)texture == (Object)null)
			{
				return null;
			}
			byte[] array = null;
			int[] array2 = new int[5] { 90, 80, 70, 60, 50 };
			int[] array3 = array2;
			foreach (int num in array3)
			{
				byte[] array4 = ImageConversion.EncodeToJPG(texture, num);
				if (array4 != null && array4.Length != 0)
				{
					array = array4;
					if (array4.Length <= 819200)
					{
						return array4;
					}
				}
			}
			if (array != null && array.Length <= 1048576)
			{
				return array;
			}
			if (array != null)
			{
				Log($"<color=yellow>[Match Screenshot] Best JPEG was still too large ({(float)array.Length / 1024f:0.#} KB) - skipping screenshot upload</color>");
			}
			return null;
		}

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

		[IteratorStateMachine(typeof(<ResolveExistingMatchIdForCurrentSession>d__161))]
		private IEnumerator ResolveExistingMatchIdForCurrentSession(Action<string> onResolved, bool logMisses = true)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ResolveExistingMatchIdForCurrentSession>d__161(0)
			{
				<>4__this = this,
				onResolved = onResolved,
				logMisses = logMisses
			};
		}

		private JObject SelectNewestReusableMatch(IEnumerable<JObject> matches)
		{
			return (from match in matches?.Where((JObject match) => match != null).Where(delegate(JObject match)
				{
					string text = (string)match["id"];
					return !string.IsNullOrWhiteSpace(text) && !_finalizedMatchIds.Contains(text);
				})
				orderby ParseApiTimestamp((string)match["created_date"]) descending
				select match).FirstOrDefault();
		}

		private static DateTime ParseApiTimestamp(string value)
		{
			if (DateTime.TryParse(value, null, DateTimeStyles.RoundtripKind, out var result))
			{
				return result;
			}
			return DateTime.MinValue;
		}

		private float GetCurrentPlayerMatchUploadDelaySeconds()
		{
			if (_currentSession?.player_ids == null || string.IsNullOrWhiteSpace(_userProfile?.id))
			{
				return 0f;
			}
			List<string> list = _currentSession.player_ids.Where((string id) => !string.IsNullOrWhiteSpace(id)).Distinct<string>(StringComparer.Ordinal).OrderBy<string, string>((string id) => id, StringComparer.Ordinal)
				.ToList();
			if (list.Count == 0)
			{
				return 0f;
			}
			int num = list.FindIndex((string id) => string.Equals(id, _userProfile.id, StringComparison.Ordinal));
			if (num <= 0)
			{
				return 0f;
			}
			float num2 = (float)num * 2f;
			Log($"<color=cyan>[Match Creation] Fallback upload slot {num + 1}/{list.Count}; waiting {num2:0.#}s before POST</color>");
			return num2;
		}

		[IteratorStateMachine(typeof(<WaitForExistingMatchBeforeFallback>d__165))]
		private IEnumerator WaitForExistingMatchBeforeFallback(float delaySeconds, Action<string> onResolved)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForExistingMatchBeforeFallback>d__165(0)
			{
				<>4__this = this,
				delaySeconds = delaySeconds,
				onResolved = onResolved
			};
		}

		private string BuildStableManualLocalSessionId()
		{
			string currentSteamLobbyId = CompetitivePluginCheck.GetCurrentSteamLobbyId();
			if (!string.IsNullOrWhiteSpace(currentSteamLobbyId))
			{
				return "local-lobby-" + currentSteamLobbyId;
			}
			string text = ResolveCurrentLobbyName();
			if (!string.IsNullOrWhiteSpace(text))
			{
				string text2 = Regex.Replace(text.Trim(), "[^A-Za-z0-9_-]+", "-").Trim('-');
				if (!string.IsNullOrWhiteSpace(text2))
				{
					return "local-name-" + text2;
				}
			}
			return "local-manual";
		}

		[IteratorStateMachine(typeof(<ResolveExistingMatchEntryId>d__167))]
		private IEnumerator ResolveExistingMatchEntryId(string matchId, string playerId, Action<string> onResolved, bool logMisses = false)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ResolveExistingMatchEntryId>d__167(0)
			{
				<>4__this = this,
				matchId = matchId,
				playerId = playerId,
				onResolved = onResolved,
				logMisses = logMisses
			};
		}

		[IteratorStateMachine(typeof(<WaitForPendingMatchEntryCreation>d__168))]
		private IEnumerator WaitForPendingMatchEntryCreation(string playerId, Action<string> onResolved)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForPendingMatchEntryCreation>d__168(0)
			{
				<>4__this = this,
				playerId = playerId,
				onResolved = onResolved
			};
		}

		[IteratorStateMachine(typeof(<EnsureMatchEntryForPlayer>d__169))]
		private IEnumerator EnsureMatchEntryForPlayer(string sourceTag, string playerId, string playerName, string preMatchMmr, string postMatchMmr, int gamePoints, int scoreVsPar, int finishPosition, string notes, Action<string> onResolved)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnsureMatchEntryForPlayer>d__169(0)
			{
				<>4__this = this,
				sourceTag = sourceTag,
				playerId = playerId,
				playerName = playerName,
				preMatchMmr = preMatchMmr,
				postMatchMmr = postMatchMmr,
				gamePoints = gamePoints,
				scoreVsPar = scoreVsPar,
				finishPosition = finishPosition,
				notes = notes,
				onResolved = onResolved
			};
		}

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

		private void ResetPerMatchState()
		{
			if (_endOfMatchSignalCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_endOfMatchSignalCoroutine);
				_endOfMatchSignalCoroutine = null;
			}
			if (_matchScreenshotSignalCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_matchScreenshotSignalCoroutine);
				_matchScreenshotSignalCoroutine = null;
			}
			_currentMatchId = null;
			if (_currentSession != null)
			{
				_currentSession.match_id = null;
			}
			_playerMatchEntryIds.Clear();
			_matchEntryCreationInProgress.Clear();
			_playerIdsByName.Clear();
			_lastSubmittedScores.Clear();
			_lastSubmittedScoresVsPar.Clear();
			_matchEntriesCreated = false;
			_matchStatsSubmitted = false;
			_proSeriesSkipLogged = false;
			_matchEndedReceived = false;
			ClearPendingMatchScreenshot();
			_matchScreenshotUploadInProgress = false;
			_matchScreenshotUploadCompleted = false;
			_localManualSessionId = null;
			_cachedLeaderboardScores.Clear();
			_cachedLeaderboardScoresVsPar.Clear();
			_finalLeaderboardSnapshot.Clear();
			MatchResultSubmissionService.ReceivedP2PMatchId = null;
			_lastUploadedPlayerCount = -1;
			Log("<color=cyan>[Match] Per-match state reset - ready for new round</color>");
		}

		private void ResetPluginState()
		{
			if (_monitorCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_monitorCoroutine);
				_monitorCoroutine = null;
			}
			if (_endOfMatchSignalCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_endOfMatchSignalCoroutine);
				_endOfMatchSignalCoroutine = null;
			}
			if (_matchScreenshotSignalCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_matchScreenshotSignalCoroutine);
				_matchScreenshotSignalCoroutine = null;
			}
			IsRankedTriggered = false;
			_isQueueing = false;
			_webStatus = "IDLE";
			_currentQueueId = "";
			_currentSession = null;
			_isHost = false;
			_hasAccepted = false;
			_hostRulesetSelection = "ranked";
			_queueStartTime = null;
			_hostLobbyStarted = false;
			_hostServerWasActive = false;
			_hostCancelSent = false;
			_matchStatsSubmitted = false;
			_proSeriesSkipLogged = false;
			_matchStartTime = null;
			_syncTickCount = 0;
			_lobbyCreatedEventCount = 0;
			_steamLinkUploadAttempts = 0;
			_steamLinkUploadSuccesses = 0;
			_steamLinkUploadFailures = 0;
			_autoJoinAttempts = 0;
			_autoJoinSuccesses = 0;
			_autoJoinFailures = 0;
			_lastLobbyCreatedAt = null;
			_lastUploadAttemptAt = null;
			_lastUploadSuccessAt = null;
			_lastAutoJoinAttemptAt = null;
			_lastAutoJoinSuccessAt = null;
			_lastGeneratedSteamLink = "-";
			_lastUploadedSteamLink = "-";
			_lastAutoJoinSteamLink = "-";
			_lastUploadError = "-";
			_lastAutoJoinError = "-";
			if (_lobbyMonitorCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_lobbyMonitorCoroutine);
				_lobbyMonitorCoroutine = null;
			}
			_currentMatchId = null;
			_finalizedMatchIds.Clear();
			_playerMatchEntryIds.Clear();
			_matchEntryCreationInProgress.Clear();
			_playerIdsByName.Clear();
			_lastSubmittedScores.Clear();
			_lastSubmittedScoresVsPar.Clear();
			_matchCreationInProgress = false;
			_matchEntriesCreated = false;
			_isInGameplay = false;
			_matchEndedReceived = false;
			ClearPendingMatchScreenshot();
			_matchScreenshotUploadInProgress = false;
			_matchScreenshotUploadCompleted = false;
			_localManualSessionId = null;
			_cachedLeaderboardScores.Clear();
			_cachedLeaderboardScoresVsPar.Clear();
			_finalLeaderboardSnapshot.Clear();
			_lastUploadedPlayerCount = -1;
			_nextEnsureMatchCreateAttemptAt = 0f;
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			CourseManager.MatchStateChanged -= OnCourseManagerMatchStateChanged;
			CourseManager.ForceDisplayScoreboardChanged -= OnCourseManagerForceDisplayScoreboardChanged;
			UnifiedPlugin.ApiConfigChanged -= OnApiConfigChanged;
		}

		private void OnApplicationQuit()
		{
			if (_isHost && _hostLobbyStarted && _hostServerWasActive && _currentSession != null)
			{
				((MonoBehaviour)this).StartCoroutine(CancelSessionAsHost("host_application_quit"));
			}
		}

		private void Log(string msg)
		{
			string item = $"[{DateTime.Now:HH:mm:ss}] {msg}";
			_debugLogs.Add(item);
			if (_debugLogs.Count > 30)
			{
				_debugLogs.RemoveAt(0);
			}
			_logScroll.y = float.MaxValue;
			if (_bepinexLogger != null)
			{
				string text = Regex.Replace(msg, "<[^>]+>", "");
				_bepinexLogger.LogInfo((object)("[MatchmakingAssistant] " + text));
			}
		}

		private bool TryUseSharedProfile(string logContext)
		{
			SharedPlayerProfile playerProfile = UnifiedPlugin.GetPlayerProfile();
			if (playerProfile == null || !UnifiedPlugin.IsPlayerProfileResolved() || string.IsNullOrWhiteSpace(playerProfile.ID))
			{
				return false;
			}
			_userProfile = new PlayerProfile
			{
				id = playerProfile.ID,
				display_name = playerProfile.DisplayName,
				current_mmr = playerProfile.CurrentMMR,
				region = playerProfile.Region,
				state_province = string.Empty
			};
			Log("<color=green>[" + logContext + "] ✓ Using shared profile: " + _userProfile.display_name + " (" + _userProfile.id + ")</color>");
			return true;
		}

		private string TryGetSteamPlayerName()
		{
			try
			{
				if (SteamClient.IsValid)
				{
					return SteamClient.Name;
				}
			}
			catch
			{
			}
			return string.Empty;
		}

		[IteratorStateMachine(typeof(<EnsureUserProfileResolved>d__178))]
		private IEnumerator EnsureUserProfileResolved(string logContext, float maxWaitSeconds = 0f)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnsureUserProfileResolved>d__178(0)
			{
				<>4__this = this,
				logContext = logContext,
				maxWaitSeconds = maxWaitSeconds
			};
		}

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

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

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

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

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

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

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

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

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

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

		private void StoreMatchConfigurationInPlayerPrefs(MatchmakingSession session)
		{
			try
			{
				if (session == null)
				{
					Log("<color=yellow>[Config] Session is null, cannot store configuration</color>");
					return;
				}
				string matchType = session.match_type ?? string.Empty;
				bool flag = IsCasualMatchType(matchType);
				bool flag2 = IsProSeriesMatchType(matchType);
				string text = (flag ? "casual" : (flag2 ? "pro_series_season_1" : "ranked_season_1"));
				int num = ((!flag) ? ((session.season <= 0) ? 1 : session.season) : 0);
				string text2 = (flag ? "casual" : (flag2 ? "pro_series" : "ranked"));
				if (flag)
				{
					string text3 = ((!string.IsNullOrWhiteSpace(session.selected_course)) ? session.selected_course : PlayerPrefs.GetString("SelectedCourse", ""));
					PlayerPrefs.SetString("MatchType", text);
					if (!string.IsNullOrWhiteSpace(text3))
					{
						PlayerPrefs.SetString("SelectedCourse", text3);
					}
					PlayerPrefs.SetInt("Season", num);
					PlayerPrefs.SetString("HostRuleset", text2);
					PlayerPrefs.Save();
					Log(string.Format("<color=cyan>[Config] Stored casual match configuration: Type={0}, Course={1}, Season={2}</color>", text, string.IsNullOrWhiteSpace(text3) ? "manual" : text3, num));
					return;
				}
				try
				{
					RuleSetManager.SetLogger(_bepinexLogger);
					string text4 = ((!string.IsNullOrEmpty(session.selected_course) && RuleSetManager.ValidateCourseForRanked(session.selected_course)) ? session.selected_course : MapPoolConfig.GetRandomApprovedCourse().Name);
					PlayerPrefs.SetString("MatchType", text);
					PlayerPrefs.SetString("SelectedCourse", text4);
					PlayerPrefs.SetInt("Season", num);
					PlayerPrefs.SetString("HostRuleset", text2);
					PlayerPrefs.Save();
					Log($"<color=cyan>[Config] Stored match configuration: Type={text}, Course={text4}, Season={num}</color>");
					RuleSetManager.LogMatchConfiguration(text, text4, num);
				}
				catch (Exception ex)
				{
					Log("<color=yellow>[Config] Error during rule validation, storing fallback config: " + ex.Message + "</color>");
					PlayerPrefs.SetString("MatchType", text);
					PlayerPrefs.SetString("SelectedCourse", string.IsNullOrEmpty(session.selected_course) ? MapPoolConfig.GetRandomApprovedCourse().Name : session.selected_course);
					PlayerPrefs.SetInt("Season", num);
					PlayerPrefs.SetString("HostRuleset", text2);
					PlayerPrefs.Save();
				}
			}
			catch (Exception ex2)
			{
				Log("<color=red>[Config] Exception storing match configuration: " + ex2.Message + " | StackTrace: " + ex2.StackTrace + "</color>");
			}
		}

		private void ClearMatchConfigurationFromPlayerPrefs()
		{
			PlayerPrefs.DeleteKey("MatchType");
			PlayerPrefs.DeleteKey("SelectedCourse");
			PlayerPrefs.DeleteKey("Season");
			PlayerPrefs.Save();
			Log("[Config] Cleared match configuration from PlayerPrefs");
		}

		private void InitiateHostSequence()
		{
			if (_currentSession == null)
			{
				return;
			}
			if (!_hasAccepted)
			{
				Log("<color=yellow>[Host] Must accept match first before initializing lobby</color>");
				((MonoBehaviour)this).StartCoroutine(AcceptMatch());
				return;
			}
			string @string = PlayerPrefs.GetString("HostRuleset", "");
			if (string.Equals(@string, "pro_series", StringComparison.OrdinalIgnoreCase))
			{
				_hostRulesetSelection = "pro_series";
			}
			else if (string.Equals(@string, "casual", StringComparison.OrdinalIgnoreCase))
			{
				_hostRulesetSelection = "casual";
			}
			else
			{
				_hostRulesetSelection = "ranked";
			}
			MainMenu val = Object.FindAnyObjectByType<MainMenu>();
			if ((Object)(object)val != (Object)null)
			{
				IsRankedTriggered = true;
				_hostLobbyStarted = true;
				_hostServerWasActive = false;
				_hostCancelSent = false;
				_matchStartTime = DateTime.UtcNow;
				_matchStatsSubmitted = false;
				PlayerPrefs.SetString("LobbyName", _currentSession.lobby_name);
				PlayerPrefs.SetString("LobbyPassword", _currentSession.lobby_password);
				PlayerPrefs.SetString("HostRuleset", _hostRulesetSelection);
				PlayerPrefs.Save();
				Log("Host ruleset stored: " + _hostRulesetSelection);
				val.StartHost();
				Log("Host lobby initiated. Waiting for Steamworks lobby creation callback...");
				((MonoBehaviour)this).StartCoroutine(UpdateSessionStatus("in_progress"));
			}
		}

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

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

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

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

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

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

		[IteratorStateMachine(typeof(<UpdateMatchEntry>d__198))]
		private IEnumerator UpdateMatchEntry(string entryId, string playerId, string playerName, int gamePoints, int scoreVsPar, int finishPosition = 0, string postMatchMmr = null, string preMatchMmr = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateMatchEntry>d__198(0)
			{
				<>4__this = this,
				entryId = entryId,
				playerId = playerId,
				playerName = playerName,
				gamePoints = gamePoints,
				scoreVsPar = scoreVsPar,
				finishPosition = finishPosition,
				postMatchMmr = postMatchMmr,
				preMatchMmr = preMatchMmr
			};
		}

		private int GetPlayerFinishPosition(string playerName, List<LiveLeaderboardPlugin.SBGLPlayer> finalLeaderboard)
		{
			if (string.IsNullOrEmpty(playerName) || finalLeaderboard == null || finalLeaderboard.Count == 0)
			{
				return 0;
			}
			Dictionary<string, int> dictionary = BuildFinishPositionMap(finalLeaderboard);
			if (dictionary.TryGetValue(playerName, out var value))
			{
				return value;
			}
			return 0;
		}

		private int GetPlayerFinishPosition(string playerName, List<CachedLeaderboardPlayer> finalLeaderboard)
		{
			if (string.IsNullOrEmpty(playerName) || finalLeaderboard == null || finalLeaderboard.Count == 0)
			{
				return 0;
			}
			for (int i = 0; i < finalLeaderboard.Count; i++)
			{
				if (finalLeaderboard[i] != null && string.Equals(finalLeaderboard[i].Name, playerName, StringComparison.OrdinalIgnoreCase))
				{
					return i + 1;
				}
			}
			return 0;
		}

		private bool TryGetPlayerIdForName(string playerName, out string playerId)
		{
			playerId = null;
			if (string.IsNullOrWhiteSpace(playerName))
			{
				return false;
			}
			string text = playerName.Trim();
			if (_playerIdsByName.TryGetValue(text, out var value) && !string.IsNullOrWhiteSpace(value))
			{
				playerId = value;
				return true;
			}
			if (_userProfile != null && string.Equals(text, _userProfile.display_name, StringComparison.OrdinalIgnoreCase))
			{
				playerId = _userProfile.id;
				return !string.IsNullOrWhiteSpace(playerId);
			}
			return false;
		}

		[IteratorStateMachine(typeof(<ResolvePlayerIdByNameFromApi>d__202))]
		private IEnumerator ResolvePlayerIdByNameFromApi(string playerName, Action<string> onResolved)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ResolvePlayerIdByNameFromApi>d__202(0)
			{
				<>4__this = this,
				playerName = playerName,
				onResolved = onResolved
			};
		}

		[IteratorStateMachine(typeof(<UpdateMatchPlayerCountIfNeeded>d__203))]
		private IEnumerator UpdateMatchPlayerCountIfNeeded(int actualPlayerCount, string source)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateMatchPlayerCountIfNeeded>d__203(0)
			{
				<>4__this = this,
				actualPlayerCount = actualPlayerCount,
				source = source
			};
		}

		private void CacheLeaderboardSnapshot(List<LiveLeaderboardPlugin.SBGLPlayer> players, string source)
		{
			if (players == null || players.Count == 0)
			{
				return;
			}
			List<CachedLeaderboardPlayer> list = (from player in players
				where player != null && !string.IsNullOrWhiteSpace(player.Name)
				select new CachedLeaderboardPlayer
				{
					Name = player.Name.Trim(),
					BaseScore = player.BaseScore,
					RawStrokes = (player.RawStrokes ?? string.Empty),
					MMR = player.MMR,
					ProjectedDelta = ParseProjectedMmrDelta(player.ProjectedDisplay)
				}).ToList();
			if (list.Count != 0)
			{
				bool flag = SnapshotHasMeaningfulScores(list);
				bool flag2 = SnapshotHasMeaningfulScores(_finalLeaderboardSnapshot);
				if (!flag && flag2)
				{
					Log("<color=yellow>[Match Snapshot] Ignoring zeroed " + source + " snapshot and keeping last in-game results</color>");
				}
				else
				{
					_finalLeaderboardSnapshot = list;
				}
			}
		}

		private bool SnapshotHasMeaningfulScores(List<CachedLeaderboardPlayer> snapshot)
		{
			if (snapshot == null || snapshot.Count == 0)
			{
				return false;
			}
			foreach (CachedLeaderboardPlayer item in snapshot)
			{
				if (item != null)
				{
					if (item.BaseScore != 0)
					{
						return true;
					}
					if (ParseScoreVsPar(item.RawStrokes) != 0)
					{
						return true;
					}
				}
			}
			return false;
		}

		private int ParseScoreVsPar(string rawStrokes)
		{
			if (string.IsNullOrWhiteSpace(rawStrokes))
			{
				return 0;
			}
			string s = rawStrokes.Replace("±", "").Trim();
			int.TryParse(s, out var result);
			return result;
		}

		private int ParseProjectedMmrDelta(string projectedDisplay)
		{
			if (string.IsNullOrWhiteSpace(projectedDisplay))
			{
				return 0;
			}
			Match match = Regex.Match(projectedDisplay, "\\(([+-]?\\d+)\\)");
			if (match.Success && int.TryParse(match.Groups[1].Value, out var result))
			{
				return result;
			}
			return 0;
		}

		private Dictionary<string, int> BuildFinishPositionMap(List<LiveLeaderboardPlugin.SBGLPlayer> leaderboard)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			if (leaderboard == null || leaderboard.Count == 0)
			{
				return dictionary;
			}
			var list = (from p in leaderboard
				where p != null && !string.IsNullOrWhiteSpace(p.Name)
				select new
				{
					Player = p,
					Stroke = ParseScoreVsPar(p.RawStrokes)
				} into x
				orderby x.Player.AdjustedPoints descending, x.Player.BaseScore descending, x.Stroke
				select x).ThenBy(x => x.Player.Name, StringComparer.OrdinalIgnoreCase).ToList();
			int num = 1;
			foreach (var item in list)
			{
				if (!dictionary.ContainsKey(item.Player.Name))
				{
					dictionary[item.Player.Name] = num++;
				}
			}
			return dictionary;
		}

		private Dictionary<string, int> BuildFinishPositionMap(List<CachedLeaderboardPlayer> leaderboard)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			if (leaderboard == null || leaderboard.Count == 0)
			{
				return dictionary;
			}
			var list = (from p in leaderboard
				where p != null && !string.IsNullOrWhiteSpace(p.Name)
				select new
				{
					Player = p,
					Stroke = ParseScoreVsPar(p.RawStrokes),
					Adjusted = p.BaseScore + ParseScoreVsPar(p.RawStrokes) * -10
				} into x
				orderby x.Adjusted descending, x.Player.BaseScore descending, x.Stroke
				select x).ThenBy(x => x.Player.Name, StringComparer.OrdinalIgnoreCase).ToList();
			int num = 1;
			foreach (var item in list)
			{
				if (!dictionary.ContainsKey(item.Player.Name))
				{
					dictionary[item.Player.Name] = num++;
				}
			}
			return dictionary;
		}

		[IteratorStateMachine(typeof(<EnrichPlayerIdsFromLeaderboard>d__210))]
		private IEnumerator EnrichPlayerIdsFromLeaderboard(List<LiveLeaderboardPlugin.SBGLPlayer> startingLeaderboard, List<string> playerIds)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnrichPlayerIdsFromLeaderboard>d__210(0)
			{
				<>4__this = this,
				startingLeaderboard = startingLeaderboard,
				playerIds = playerIds
			};
		}

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

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

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

		private MatchStats CollectMatchStats(float duration)
		{
			try
			{
				string text = ((_currentSession != null) ? _currentSession.id : (_localManualSessionId ?? "local-manual-session"));
				return new MatchStats
				{
					matchmaking_session_id = text,
					match_id = text,
					player_id = _userProfile.id,
					player_name = _userProfile.display_name,
					match_date = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
					duration_seconds = (int)duration,
					is_host = _isHost,
					status = "completed"
				};
			}
			catch (Exception ex)
			{
				Log("<color=red>[Match Stats] Error collecting stats: " + ex.Message + "</color>");
				return null;
			}
		}

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

		[IteratorStateMachine(typeof(<SubmitMatchEntry>d__216))]
		private IEnumerator SubmitMatchEntry(MatchStats stats, Action<string> onMatchIdReceived)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SubmitMatchEntry>d__216(0)
			{
				<>4__this = this,
				stats = stats,
				onMatchIdReceived = onMatchIdReceived
			};
		}

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

		private void OnGUI()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_00c0: Expected O, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: 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_06fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0774: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_074a: 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_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a56: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ad2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2c: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d61: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d8d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d93: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dbd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08de: Unknown result type (might be due to invalid IL or missing references)
			//IL_090d: Unknown result type (might be due to invalid IL or missing references)
			//IL_094c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0981: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Unknown result type (might be due to invalid IL or missing references)
			//IL_0de2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_0655: Unknown result type (might be due to invalid IL or missing references)
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			//IL_052e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c01: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c5b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cb5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cfc: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				bool flag = ((Scene)(ref activeScene)).name.ToLower().Contains("menu");
				DrawUploadNotification();
				DrawLiveUploadDebugOverlay();
				if (!flag)
				{
					return;
				}
				if (_centerLabelStyle == null)
				{
					_centerLabelStyle = (((Object)(object)GUI.skin != (Object)null) ? new GUIStyle(GUI.skin.label)
					{
						alignment = (TextAnchor)4
					} : new GUIStyle
					{
						alignment = (TextAnchor)4
					});
				}
				if (_debugLineStyle == null)
				{
					_debugLineStyle = (((Object)(object)GUI.skin != (Object)null) ? new GUIStyle(GUI.skin.label) : new GUIStyle());
					_debugLineStyle.alignment = (TextAnchor)3;
					_debugLineStyle.fontSize = 10;
					_debugLineStyle.wordWrap = false;
					_debugLineStyle.clipping = (TextClipping)1;
					_debugLineStyle.richText = false;
				}
				float num = 350f;
				float num2 = (float)Screen.width - num - 30f;
				ConfigEntry<bool> showLogsConfig = _showLogsConfig;
				float num3 = ((showLogsConfig != null && showLogsConfig.Value) ? 340f : 230f);
				ConfigEntry<bool> showFlowDebugConfig = _showFlowDebugConfig;
				if (showFlowDebugConfig != null && showFlowDebugConfig.Value)
				{
					num3 += 145f;
				}
				GUI.DrawTexture(new Rect(num2, 20f, num, num3), (Texture)(object)_solidBgTex);
				GUI.Box(new Rect(num2, 20f, num, num3), "<b>SBGL MATCH MAKING ASSISTANT</b>");
				if (_currentSession != null)
				{
					if (_currentSession.status == "pending_accept")
					{
						GUI.backgroundColor = (_hasAccepted ? Color.gray : Color.yellow);
						if (GUI.Button(new Rect(num2 + 10f, 50f, num - 20f, 50f), _hasAccepted ? "WAITING FOR OTHERS..." : "ACCEPT MATCH") && !_hasAccepted)
						{
							((MonoBehaviour)this).StartCoroutine(AcceptMatch());
						}
					}
					else if (_currentSession.status == "ready")
					{
						if (_isHost)
						{
							GUI.backgroundColor = Color.cyan;
							if (GUI.Button(new Rect(num2 + 10f, 50f, num - 20f, 50f), "INITIALIZE HOST"))
							{
								InitiateHostSequence();
							}
						}
						else if (_hasAccepted && !string.IsNullOrEmpty(_currentSession.steam_lobby_link))
						{
							GUI.backgroundColor = Color.green;
							GUI.enabled = false;
							GUI.Button(new Rect(num2 + 10f, 50f, num - 20f, 50f), "AUTO-JOINING...");
							GUI.enabled = true;
						}
						else if (!_hasAccepted)
						{
							GUI.backgroundColor = Color.yellow;
							if (GUI.Button(new Rect(num2 + 10f, 50f, num - 20f, 50f), "ACCEPT & JOIN"))
							{
								((MonoBehaviour)this).StartCoroutine(AcceptMatch());
							}
						}
						else
						{
							GUI.backgroundColor = Color.gray;
							GUI.enabled = false;
							GUI.Button(new Rect(num2 + 10f, 50f, num - 20f, 50f), "JOINING...");
							GUI.enabled = true;
						}
					}
				}
				else
				{
					bool enabled = !_isInitializing && _userProfile != null;
					if (_isQueueing)
					{
						GUI.enabled = enabled;
						GUI.backgroundColor = new Color(0.8f, 0.1f, 0.1f, 1f);
						if (GUI.Button(new Rect(num2 + 10f, 50f, num - 20f, 50f), "LEAVE QUEUE"))
						{
							((MonoBehaviour)this).StartCoroutine(LeaveQueue());
						}
						GUI.enabled = true;
					}
					else
					{
						bool flag2 = (Object)(object)UnifiedPlugin.Instance != (Object)null && string.Equals(UnifiedPlugin.Instance.API_Environment?.Value, "PreProd", StringComparison.OrdinalIgnoreCase);
						if (!flag2)
						{
							_queueTypeSelection = "ranked";
						}
						float num4 = (num - 22f) / 2f;
						bool flag3 = _queueTypeSelection != "casual";
						GUI.enabled = enabled;
						if (flag2)
						{
							GUI.backgroundColor = (Color)(flag3 ? new Color(0.1f, 0.4f, 0.9f, 1f) : Color.gray);
							if (GUI.Button(new Rect(num2 + 10f, 50f, num4, 23f), "RANKED"))
							{
								_queueTypeSelection = "ranked";
							}
							GUI.backgroundColor = (Color)((!flag3) ? new Color(0.6f, 0.3f, 0.8f, 1f) : Color.gray);
							if (GUI.Button(new Rect(num2 + 12f + num4, 50f, num4, 23f), "CASUAL"))
							{
								_queueTypeSelection = "casual";
							}
						}
						else
						{
							GUI.backgroundColor = new Color(0.1f, 0.4f, 0.9f, 1f);
							if (GUI.Button(new Rect(num2 + 10f, 50f, num - 20f, 23f), "RANKED"))
							{
								_queueTypeSelection = "ranked";
							}
						}
						string text = (_isInitializing ? "SYNCING WITH SERVER..." : ((_userProfile != null) ? "JOIN QUEUE" : "RESOLVING PROFILE..."));
						GUI.backgroundColor = new Color(0.1f, 0.6f, 0.1f, 1f);
						if (GUI.Button(new Rect(num2 + 10f, 76f, num - 20f, 32f), text))
						{
							if (_queueTypeSelection == "casual")
							{
								PlayerPrefs.SetString("MatchType", "casual");
								PlayerPrefs.SetString("HostRuleset", "casual");
							}
							else
							{
								PlayerPrefs.SetString("MatchType", "ranked_season_1");
								PlayerPrefs.SetString("HostRuleset", "ranked");
							}
							((MonoBehaviour)this).StartCoroutine(MatchmakingLoop());
						}
						GUI.enabled = true;
					}
				}
				float num5 = 0f;
				GUI.Box(new Rect(num2 + 10f, 110f + num5, num - 20f, 100f), "");
				if (_userProfile != null)
				{
					if (Object.op_Implicit((Object)(object)_profileTexture))
					{
						GUI.DrawTexture(new Rect(num2 + 20f, 120f + num5, 40f, 40f), (Texture)(object)_profileTexture);
					}
					GUI.Label(new Rect(num2 + 70f, 120f + num5, 240f, 20f), "User: <b>" + _userProfile.display_name + "</b>");
					GUI.Label(new Rect(num2 + 70f, 135f + num5, 240f, 20f), "<color=#FFA500><size=10>" + _webStatus + "</size></color>");
					float num6 = 160f + num5;
					float num7 = (num - 40f) / 4f;
					GUI.Label(new Rect(num2 + 20f, num6, num7, 20f), "<color=#FFFFFF><size=10><b>TIME</b></size></color>", _centerLabelStyle);
					string text2 = "00:00";
					if (_isQueueing && _queueStartTime.HasValue)
					{
						TimeSpan timeSpan = DateTime.UtcNow - _queueStartTime.Value.ToUniversalTime();
						text2 = ((timeSpan.TotalSeconds < 0.0) ? "00:00" : $"{timeSpan.Minutes:00}:{timeSpan.Seconds:00}");
					}
					GUI.Label(new Rect(num2 + 20f, num6 + 15f, num7, 25f), "<color=#00FFCC><size=16><b>" + text2 + "</b></size></color>", _centerLabelStyle);
					GUI.Label(new Rect(num2 + 20f + num7, num6, num7, 20f), "<color=#FFFFFF><size=10><b>QUEUED</b></size></color>", _centerLabelStyle);
					GUI.Label(new Rect(num2 + 20f + num7, num6 + 15f, num7, 25f), $"<color=#00FFCC><size=16><b>{_queuedCount}</b></size></color>", _centerLabelStyle);
					GUI.Label(new Rect(num2 + 20f + num7 * 2f, num6, num7, 20f), "<color=#FFFFFF><size=10><b>MATCHED</b></size></color>", _centerLabelStyle);
					GUI.Label(new Rect(num2 + 20f + num7 * 2f, num6 + 15f, num7, 25f), $"<color=#FFD700><size=16><b>{_matchedCount}</b></size></color>", _centerLabelStyle);
					GUI.Label(new Rect(num2 + 20f + num7 * 3f, num6, num7, 20f), "<color=#FFFFFF><size=10><b>YOUR MMR</b></size></color>", _centerLabelStyle);
					GUI.Label(new Rect(num2 + 20f + num7 * 3f, num6 + 15f, num7, 25f), $"<color=#FFFFFF><size=16><b>{_userProfile.current_mmr}</b></size></color>", _centerLabelStyle);
				}
				float num8 = 215f + num5;
				ConfigEntry<bool> showFlowDebugConfig2 = _showFlowDebugConfig;
				if (showFlowDebugConfig2 != null && showFlowDebugConfig2.Value)
				{
					GUI.Label(new Rect(num2 + 15f, num8, num, 20f), "<b>FLOW DIAGNOSTICS (TEMP)</b>");
					num8 += 18f;
					float num9 = 14f;
					float num10 = 6f;
					int num11 = 7;
					float num12 = num10 + (float)num11 * num9 + 6f;
					GUI.Box(new Rect(num2 + 10f, num8, num - 20f, num12), "");
					GUI.Label(new Rect(num2 + 16f, num8 + num10 + 0f * num9, num - 30f, num9), $"sync_tick={_syncTickCount} host={_isHost} accepted={_hasAccepted}", _debugLineStyle);
					GUI.Label(new Rect(num2 + 16f, num8 + num10 + 1f * num9, num - 30f, num9), "session=" + ((_currentSession != null) ? _currentSession.id : "none") + " status=" + ((_currentSession != null) ? _currentSession.status : "none"), _debugLineStyle);
					GUI.Label(new Rect(num2 + 16f, num8 + num10 + 2f * num9, num - 30f, num9), $"lobby_events={_lobbyCreatedEventCount} link_present={!string.IsNullOrEmpty(_currentSession?.steam_lobby_link)}", _debugLineStyle);
					GUI.Label(new Rect(num2 + 16f, num8 + num10 + 3f * num9, num - 30f, num9), $"upload a/s/f={_steamLinkUploadAttempts}/{_steamLinkUploadSuccesses}/{_steamLinkUploadFailures}", _debugLineStyle);
					GUI.Label(new Rect(num2 + 16f, num8 + num10 + 4f * num9, num - 30f, num9), $"autojoin a/s/f={_autoJoinAttempts}/{_autoJoinSuccesses}/{_autoJoinFailures}", _debugLineStyle);
					GUI.Label(new Rect(num2 + 16f, num8 + num10 + 5f * num9, num - 30f, num9), "last_upload_err=" + Truncate(_lastUploadError, 42), _debugLineStyle);
					GUI.Label(new Rect(num2 + 16f, num8 + num10 + 6f * num9, num - 30f, num9), "last_join_err=" + Truncate(_lastAutoJoinError, 42), _debugLineStyle);
					num8 += num12 + 5f;
				}
				if (_showLogsConfig.Value)
				{
					float num13 = num8 + 5f;
					GUI.Label(new Rect(num2 + 15f, num13, num, 25f), "<b>SYSTEM LOGS:</b>");
					_logScroll = GUI.BeginScrollView(new Rect(num2 + 10f, num13 + 25f, num - 20f, 70f), _logScroll, new Rect(0f, 0f, num - 40f, (float)(_debugLogs.Count * 20)));
					for (int i = 0; i < _debugLogs.Count; i++)
					{
						GUI.Label(new Rect(5f, (float)(i * 20), 300f, 20f), "<size=10>" + _debugLogs[i] + "</size>");
					}
					GUI.EndScrollView();
				}
			}
			catch (Exception ex)
			{
				Log("<color=red>[CRITICAL] Exception in OnGUI: " + ex.Message + " | StackTrace: " + ex.StackTrace + "</color>");
			}
		}

		private void DrawUploadNotification()
		{
			//IL_00c1: 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)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(_uploadNotification))
			{
				return;
			}
			float num = (float)(DateTime.UtcNow - _uploadNotificationTime).TotalSeconds;
			if (num >= 4f)
			{
				_uploadNotification = "";
				return;
			}
			float num2 = 1f;
			if (num > 3f)
			{
				num2 = Mathf.Lerp(1f, 0f, (num - 3f) / 1f);
			}
			float num3 = 500f;
			float num4 = 50f;
			float num5 = ((float)Screen.width - num3) / 2f;
			float num6 = (float)Screen.height - 100f;
			GUI.color = new Color(1f, 1f, 1f, num2);
			GUI.Box(new Rect(num5, num6, num3, num4), "");
			GUIStyle val = (((Object)(object)GUI.skin != (Object)null) ? new GUIStyle(GUI.skin.label) : new GUIStyle());
			val.alignment = (TextAnchor)4;
			val.fontSize = 14;
			val.richText = true;
			string text = ColorUtility.ToHtmlStringRGB(_uploadNotificationColor);
			GUI.Label(new Rect(num5, num6 + 10f, num3, 30f), "<color=#" + text + "><b>" + _uploadNotification + "</b></color>", val);
			GUI.color = Color.white;
		}

		private void DrawLiveUploadDebugOverlay()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<bool> showFlowDebugConfig = _showFlowDebugConfig;
			if (showFlowDebugConfig != null && showFlowDebugConfig.Value)
			{
				float num = 860f;
				float num2 = 62f;
				float num3 = ((float)Screen.width - num) / 2f;
				float num4 = (float)Screen.height - 170f;
				GUIStyle val = (((Object)(object)GUI.skin != (Object)null) ? new GUIStyle(GUI.skin.label) : new GUIStyle());
				val.alignment = (TextAnchor)3;
				val.fontSize = 11;
				val.richText = true;
				GUI.Box(new Rect(num3, num4, num, num2), "");
				string text = "LobbySources s='" + Truncate(_debugLobbySessionSource, 24) + "' p='" + Truncate(_debugLobbyPrefsSource, 24) + "' c='" + Truncate(_debugLobbyCapturedSource, 24) + "'";
				string text2 = "LobbyResolved '" + Truncate(_debugLobbyResolved, 40) + "' via=" + _debugLobbyResolvedBy + " | SessionType='" + Truncate(_currentSession?.match_type ?? "", 24) + "' MatchType='" + Truncate(PlayerPrefs.GetString("MatchType", ""), 24) + "' HostRuleset='" + Truncate(PlayerPrefs.GetString("HostRuleset", ""), 14) + "'";
				GUI.Label(new Rect(num3 + 10f, num4 + 7f, num - 20f, 20f), text, val);
				GUI.Label(new Rect(num3 + 10f, num4 + 29f, num - 20f, 20f), text2, val);
			}
		}

		public async void JoinBySteamLink(string steamLink, string password)
		{
			if (string.IsNullOrEmpty(steamLink))
			{
				return;
			}
			PlayerPrefs.SetString("LobbyPassword", password);
			PlayerPrefs.Save();
			Log("Password '" + password + "' cached for join.");
			try
			{
				string[] parts = steamLink.Split('/');
				if (parts.Length < 5 || !ulong.TryParse(parts[4], out var lobbyId))
				{
					Log("<color=red>Invalid Steam Link</color>");
					return;
				}
				Log($"Joining Steam Lobby: {lobbyId}...");
				Lobby lobby = new Lobby(SteamId.op_Implicit(lobbyId));
				RoomEnter result = await ((Lobby)(ref lobby)).Join();
				if ((int)result == 1)
				{
					NetworkManager manager = NetworkManager.singleton;
					manager.networkAddress = lobbyId.ToString();
					await Task.Delay(200);
					manager.StartClient();
					_autoJoinSuccesses++;
					_lastAutoJoinSuccessAt = DateTime.Now;
					_lastAutoJoinError = "-";
					Log("Client started via Steam Link.");
				}
				else
				{
					_autoJoinFailures++;
					_lastAutoJoinError = $"Steam room enter failure: {result}";
					Log($"<color=red>Steam Join Failed: {result}</color>");
				}
			}
			catch (Exception ex)
			{
				_autoJoinFailures++;
				_lastAutoJoinError = ex.Message;
				Log("Join Error: " + ex.Message);
			}
		}

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

		[IteratorStateMachine(typeof(<CallAPI>d__223))]
		private IEnumerator CallAPI(string endpoint, string method, string json, Action<string> onSuccess)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CallAPI>d__223(0)
			{
				<>4__this = this,
				endpoint = endpoint,
				method = method,
				json = json,
				onSuccess = onSuccess
			};
		}

		private void ApplyApiHeaders(UnityWebRequest req)
		{
			if (req != null)
			{
				req.SetRequestHeader("Content-Type", "application/json");
				req.SetRequestHeader("api_key", GetAuthToken());
				req.SetRequestHeader("X-App-Id", GetAppId());
			}
		}

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

		private List<JObject> ParseApiObjectList(string rawJson)
		{
			if (string.IsNullOrEmpty(rawJson))
			{
				return new List<JObject>();
			}
			try
			{
				JToken val = JToken.Parse(rawJson);
				JArray val2 = (JArray)(object)((val is JArray) ? val : null);
				if (val2 != null)
				{
					return ((IEnumerable)val2).OfType<JObject>().ToList();
				}
				JObject val3 = (JObject)(object)((val is JObject) ? val : null);
				if (val3 != null)
				{
					return new List<JObject> { val3 };
				}
			}
			catch (Exception ex)
			{
				Log("<color=orange>JSON parse warning (list): " + ex.Message + "</color>");
			}
			return new List<JObject>();
		}

		private JObject ParseApiSingleObject(string rawJson)
		{
			if (string.IsNullOrEmpty(rawJson))
			{
				return null;
			}
			try
			{
				JToken val = JToken.Parse(rawJson);
				JObject val2 = (JObject)(object)((val is JObject) ? val : null);
				if (val2 != null)
				{
					return val2;
				}
				JArray val3 = (JArray)(object)((val is JArray) ? val : null);
				if (val3 != null)
				{
					return ((IEnumerable)val3).OfType<JObject>().FirstOrDefault();
				}
			}
			catch (Exception ex)
			{
				Log("<color=orange>JSON parse warning (single): " + ex.Message + "</color>");
			}
			return null;
		}

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

		private void PlayMatchFoundAlert()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RuntimeManager.PlayOneShot(GameManager.AudioSettings.AnnouncerMainMenuTitle, default(Vector3));
				Log("<color=yellow>[Alert] ♪ Match found alert played via FMOD AnnouncerMainMenuTitle</color>");
			}
			catch (Exception ex)
			{
				Log("<color=orange>[Alert] Could not play match alert: " + ex.Message + "</color>");
			}
		}

		private string Truncate(string value, int maxLength)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "-";
			}
			return (value.Length <= maxLength) ? value : (value.Substring(0, maxLength) + "...");
		}

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

		private void ShowUploadNotification(string message, string level = "info")
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if (_showUploadNoticesConfig == null || _showUploadNoticesConfig.Value)
			{
				_uploadNotification = message;
				_uploadNotificationTime = DateTime.UtcNow;
				switch (level)
				{
				case "success":
					_uploadNotificationColor = new Color(0.3f, 0.95f, 0.4f);
					break;
				case "failure":
					_uploadNotificationColor = new Color(1f, 0.45f, 0.45f);
					break;
				case "warning":
					_uploadNotificationColor = new Color(1f, 0.75f, 0.35f);
					break;
				default:
					_uploadNotificationColor = new Color(0.2f, 0.85f, 1f);
					break;
				}
				Log("<color=cyan>[Upload Notification] " + message + "</color>");
			}
		}

		private string ResolveCurrentLobbyName()
		{
			string text = NormalizeLobbyName(_currentSession?.lobby_name);
			string text2 = NormalizeLobbyName(PlayerPrefs.GetString("LobbyName", ""));
			string text3 = NormalizeLobbyName(CompetitivePluginCheck._currentLobbyName);
			_debugLobbySessionSource = text;
			_debugLobbyPrefsSource = text2;
			_debugLobbyCapturedSource = text3;
			Log("<color=cyan>[LobbyName] Sources: session='" + text + "', prefs='" + text2 + "', captured='" + text3 + "'</color>");
			if (IsSbglLobbyName(text3))
			{
				_debugLobbyResolved = text3;
				_debugLobbyResolvedBy = "captured(sbgl)";
				return text3;
			}
			if (IsSbglLobbyName(text))
			{
				_debugLobbyResolved = text;
				_debugLobbyResolvedBy = "session(sbgl)";
				return text;
			}
			if (IsSbglLobbyName(text2))
			{
				_debugLobbyResolved = text2;
				_debugLobbyResolvedBy = "prefs(sbgl)";
				return text2;
			}
			if (!string.IsNullOrEmpty(text3))
			{
				_debugLobbyResolved = text3;
				_debugLobbyResolvedBy = "captured";
				return text3;
			}
			if (!string.IsNullOrEmpty(text))
			{
				_debugLobbyResolved = text;
				_debugLobbyResolvedBy = "session";
				return text;
			}
			if (!string.IsNullOrEmpty(text2))
			{
				_debugLobbyResolved = text2;
				_debugLobbyResolvedBy = "prefs";
				return text2;
			}
			_debugLobbyResolved = "";
			_debugLobbyResolvedBy = "none";
			return "";
		}

		private static string NormalizeLobbyName(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return string.Empty;
			}
			return Regex.Replace(value, "<.*?>", string.Empty).Replace("\u200b", string.Empty).Trim();
		}

		private static bool IsSbglLobbyName(string lobbyName)
		{
			return !string.IsNullOrEmpty(lobbyName) && lobbyName.StartsWith("SBGL-", StringComparison.OrdinalIgnoreCase);
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class LobbyPatch
	{
		public static void Prefix(ref string value)
		{
			if (SBGLPlugin.IsRankedTriggered)
			{
				string @string = PlayerPrefs.GetString("LobbyName");
				if (!string.IsNullOrEmpty(@string))
				{
					value = @string;
				}
			}
		}
	}
	public class MatchResultSubmissionService
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass25_0
		{
			public string resolvedId;

			public MatchResultSubmissionService <>4__this;

			public string normalizedName;

			internal void <ResolvePlayerIdByName>b__0(string res)
			{
				if (string.IsNullOrWhiteSpace(res))
				{
					return;
				}
				try
				{
					JToken val = JToken.Parse(res);
					JArray val2 = (JArray)(object)((val is JArray) ? val : null);
					JObject val3 = (JObject)((val2 != null) ? ((object)((IEnumerable)val2).OfType<JObject>().FirstOrDefault()) : ((object)((val is JObject) ? val : null)));
					if (val3 != null)
					{
						resolvedId = (string)val3["id"];
					}
				}
				catch (Exception ex)
				{
					<>4__this.Log("<color=yellow>[Casual] Could not resolve player '" + normalizedName + "': " + ex.Message + "</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass26_0
		{
			public string playerId;

			public string resolvedDisplayName;

			public int casualMatchesPlayed;

			public bool updated;

			public MatchResultSubmissionService <>4__this;

			internal void <IncrementCasualMatchesPlayedForLeaderboard>b__2(string id)
			{
				playerId = id;
			}

			internal void <IncrementCasualMatchesPlayedForLeaderboard>b__3(string res)
			{
				JObject val = <>4__this._parseApiSingleObject(res);
				if (val != null)
				{
					resolvedDisplayName = ((string)val["display_name"]) ?? resolvedDisplayName;
					int.TryParse(((object)val["casual_matches_played"])?.ToString() ?? "0", out casualMatchesPlayed);
				}
			}

			internal void <IncrementCasualMatchesPlayedForLeaderboard>b__4(string res)
			{
				if (<>4__this._parseApiSingleObject(res) != null)
				{
					updated = true;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass29_0
		{
			public string matchId;

			public MatchResultSubmissionService <>4__this;

			internal void <CreateMatchAndEntries>b__2(string id)
			{
				matchId = id;
			}

			internal void <CreateMatchAndEntries>b__0(string id)
			{
				matchId = id;
			}

			internal void <CreateMatchAndEntries>b__1(string res)
			{
				try
				{
					JObject val = <>4__this._parseApiSingleObject(res);
					if (val != null)
					{
						<>4__this.Log("<color=green>[Match Creation] ✓ MatchmakingSession " + <>4__this._currentSession.id + " linked to match: " + matchId + "</color>");
					}
					else
					{
						<>4__this.Log("<color=yellow>[Match Creation] Could not confirm MatchmakingSession update</color>");
					}
				}
				catch (Exception ex)
				{
					<>4__this.Log("<color=yellow>[Match Creation] Error updating MatchmakingSession: " + ex.Message + "</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass29_1
		{
			public string playerId;

			public <>c__DisplayClass29_0 CS$<>8__locals1;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass29_2
		{
			public string playerName;

			public string preMatchMmr;

			public string entryId;

			public <>c__DisplayClass29_1 CS$<>8__locals2;

			internal void <CreateMatchAndEntries>b__3(string res)
			{
				try
				{
					JObject val = CS$<>8__locals2.CS$<>8__locals1.<>4__this._parseApiSingleObject(res);
					if (val != null)
					{
						playerName = (string)val["display_name"];
						if (string.IsNullOrEmpty(playerName))
						{
							CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Player " + CS$<>8__locals2.playerId + " has no display_name, using ID</color>");
							playerName = CS$<>8__locals2.playerId;
						}
						object obj = val["current_mmr"];
						if (obj != null)
						{
							preMatchMmr = obj.ToString();
						}
						CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=cyan>[Match Creation] Fetched player: " + playerName + " (MMR: " + preMatchMmr + ")</color>");
					}
					else
					{
						CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Failed to fetch Player " + CS$<>8__locals2.playerId + " - response null</color>");
						playerName = CS$<>8__locals2.playerId;
					}
				}
				catch (Exception ex)
				{
					CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Error fetching Player " + CS$<>8__locals2.playerId + ": " + ex.Message + "</color>");
					playerName = CS$<>8__locals2.playerId;
				}
			}

			internal void <CreateMatchAndEntries>b__4(string res)
			{
				try
				{
					JObject val = CS$<>8__locals2.CS$<>8__locals1.<>4__this._parseApiSingleObject(res);
					if (val != null)
					{
						entryId = (string)val["id"];
						CS$<>8__locals2.CS$<>8__locals1.<>4__this._playerMatchEntryIds[CS$<>8__locals2.playerId] = entryId;
						CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=green>[Match Creation] ✓ MatchEntry created for " + playerName + ": " + entryId + "</color>");
					}
				}
				catch (Exception ex)
				{
					CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Could not parse MatchEntry: " + ex.Message + "</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass32_0
		{
			public MatchResultSubmissionService <>4__this;

			public string playerName;

			internal void <UpdateMatchEntry>b__0(string res)
			{
				try
				{
					JObject val = <>4__this._parseApiSingleObject(res);
					if (val != null)
					{
						<>4__this.Log("<color=green>[Score Update] ✓ MatchEntry updated for " + playerName + "</color>");
					}
				}
				catch (Exception ex)
				{
					<>4__this.Log("<color=yellow>[Score Update] Could not update MatchEntry: " + ex.Message + "</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass33_0
		{
			public MatchResultSubmissionService <>4__this;

			public Action<string> onMatchIdReceived;

			internal void <SubmitMatchEntry>b__0(string res)
			{
				JObject val = <>4__this._parseApiSingleObject(res);
				if (val != null)
				{
					string text = ((string)val["id"]) ?? "unknown";
					<>4__this.Log("<color=green>[Match Stats] ✓ Match entry created (ID: " + text + ")</color>");
					onMatchIdReceived?.Invoke(text);
				}
				else
				{
					<>4__this.Log("<color=yellow>[Match Stats] Response received but could not parse ID</color>");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <CreateMatchAndEntries>d__29 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<LiveLeaderboardPlugin.SBGLPlayer> startingLeaderboard;

			public List<string> playerIds;

			public MatchResultSubmissionService <>4__this;

			private <>c__DisplayClass29_0 <>8__1;

			private string <currentMatchType>5__2;

			private string <courseName>5__3;

			private string <matchType>5__4;

			private int <season>5__5;

			private SBGLPlugin.MatchStats <matchStats>5__6;

			private float <waitEnd>5__7;

			private List<string>.Enumerator <>s__8;

			private <>c__DisplayClass29_1 <>8__9;

			private <>c__DisplayClass29_2 <>8__10;

			private int <gamePoints>5__11;

			private int <scoreVsPar>5__12;

			private int <startingPosition>5__13;

			private int <adjustedScore>5__14;

			private string <mmrField>5__15;

			private string <posField>5__16;

			private string <modVer>5__17;

			private string <json>5__18;

			private int <score>5__19;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 6) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<currentMatchType>5__2 = null;
				<courseName>5__3 = null;
				<matchType>5__4 = null;
				<matchStats>5__6 = null;
				<>s__8 = default(List<string>.Enumerator);
				<>8__9 = null;
				<>8__10 = null;
				<mmrField>5__15 = null;
				<posField>5__16 = null;
				<modVer>5__17 = null;
				<json>5__18 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					UnifiedPlugin instance;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass29_0();
						<>8__1.<>4__this = <>4__this;
						<>4__this.Log("<color=cyan>[Match Creation] Starting new match for session " + <>4__this._currentSession.id + "</color>");
						<>4__this._matchStartTime = DateTime.UtcNow;
						<currentMatchType>5__2 = <>4__this._currentSession?.match_type ?? PlayerPrefs.GetString("MatchType", "");
						if (IsProSeriesMatchType(<currentMatchType>5__2))
						{
							<>4__this.Log("<color=yellow>[Match] Pro Series match — automated upload skipped</color>");
							<>4__this._matchEntriesCreated = true;
							return false;
						}
						if (IsCasualMatchType(<currentMatchType>5__2))
						{
							<>4__this.Log("<color=cyan>[Casual] Casual match detected - skipping Match/MatchEntry upload and incrementing player stats instead</color>");
							<>2__current = <>4__this.IncrementCasualMatchesPlayedForLeaderboard(startingLeaderboard);
							<>1__state = 1;
							return true;
						}
						<courseName>5__3 = PlayerPrefs.GetString("SelectedCourse", "Unknown");
						<matchType>5__4 = PlayerPrefs.GetString("MatchType", "unranked");
						<season>5__5 = PlayerPrefs.GetInt("Season", 1);
						<matchStats>5__6 = new SBGLPlugin.MatchStats
						{
							matchmaking_session_id = <>4__this._currentSession.id,
							match_id = <>4__this._currentSession.id,
							player_id = <>4__this._userProfile.id,
							player_name = <>4__this._userProfile.display_name,
							match_date = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffZ"),
							duration_seconds = 0,
							is_host = false,
							status = "completed",
							course_name = <courseName>5__3,
							match_type = <matchType>5__4,
							season = <season>5__5
						};
						<>4__this.Log($"<color=cyan>[Match Creation] Match configuration - Course: {<courseName>5__3}, Type: {<matchType>5__4}, Season: {<season>5__5}</color>");
						<>8__1.matchId = null;
						if (CompetitivePluginCheck.HasHigherVersionPeer())
						{
							<>4__this.Log("<color=cyan>[Match Creation] Higher-version peer detected — deferring Match creation to them, waiting for their Match ID...</color>");
							ReceivedP2PMatchId = null;
							<waitEnd>5__7 = Time.realtimeSinceStartup + 15f;
							goto IL_02f9;
						}
						<>2__current = <>4__this.SubmitMatchEntry(<matchStats>5__6, delegate(string id)
						{
							<>8__1.matchId = id;
						});
						<>1__state = 4;
						return true;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -1;
						goto IL_02f9;
					case 3:
						<>1__state = -1;
						goto IL_0400;
					case 4:
						<>1__state = -1;
						goto IL_0400;
					case 5:
						<>1__state = -1;
						<>4__this._playerMatchEntryIds.Clear();
						<>4__this._lastSubmittedScores.Clear();
						<>4__this._lastSubmittedScoresVsPar.Clear();
						<>s__8 = playerIds.GetEnumerator();
						<>1__state = -3;
						goto IL_09f3;
					case 6:
						<>1__state = -3;
						goto IL_06c2;
					case 7:
						{
							<>1__state = -3;
							<>8__10 = null;
							<mmrField>5__15 = null;
							<posField>5__16 = null;
							<modVer>5__17 = null;
							<json>5__18 = null;
							<>8__9 = null;
							goto IL_09f3;
						}
						IL_09f3:
						if (<>s__8.MoveNext())
						{
							<>8__9 = new <>c__DisplayClass29_1();
							<>8__9.CS$<>8__locals1 = <>8__1;
							<>8__9.playerId = <>s__8.Current;
							<>8__10 = new <>c__DisplayClass29_2();
							<>8__10.CS$<>8__locals2 = <>8__9;
							<>8__10.playerName = null;
							<>8__10.preMatchMmr = null;
							<gamePoints>5__11 = 0;
							<scoreVsPar>5__12 = 0;
							if (<>8__10.CS$<>8__locals2.playerId == <>4__this._userProfile.id)
							{
								<>8__10.playerName = <>4__this._userProfile.display_name;
								<>8__10.preMatchMmr = <>4__this._userProfile.current_mmr.ToString();
								<>4__this.Log("<color=cyan>[Match Creation] Current player: " + <>8__10.playerName + " (MMR: " + <>8__10.preMatchMmr + ")</color>");
								goto IL_06c2;
							}
							<>2__current = <>4__this._callApi("/Player/" + <>8__10.CS$<>8__locals2.playerId, "GET", "", delegate(string res)
							{
								try
								{
									JObject val3 = <>8__10.CS$<>8__locals2.CS$<>8__locals1.<>4__this._parseApiSingleObject(res);
									if (val3 != null)
									{
										<>8__10.playerName = (string)val3["display_name"];
										if (string.IsNullOrEmpty(<>8__10.playerName))
										{
											<>8__10.CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Player " + <>8__10.CS$<>8__locals2.playerId + " has no display_name, using ID</color>");
											<>8__10.playerName = <>8__10.CS$<>8__locals2.playerId;
										}
										object obj = val3["current_mmr"];
										if (obj != null)
										{
											<>8__10.preMatchMmr = obj.ToString();
										}
										<>8__10.CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=cyan>[Match Creation] Fetched player: " + <>8__10.playerName + " (MMR: " + <>8__10.preMatchMmr + ")</color>");
									}
									else
									{
										<>8__10.CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Failed to fetch Player " + <>8__10.CS$<>8__locals2.playerId + " - response null</color>");
										<>8__10.playerName = <>8__10.CS$<>8__locals2.playerId;
									}
								}
								catch (Exception ex3)
								{
									<>8__10.CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Error fetching Player " + <>8__10.CS$<>8__locals2.playerId + ": " + ex3.Message + "</color>");
									<>8__10.playerName = <>8__10.CS$<>8__locals2.playerId;
								}
							});
							<>1__state = 6;
							return true;
						}
						<>m__Finally1();
						<>s__8 = default(List<string>.Enumerator);
						<>4__this._matchEntriesCreated = true;
						<>4__this.Log("<color=green>[Match Creation] ✓ Match and entries initialized. Starting score monitoring...</color>");
						<>4__this._isInGameplay = true;
						<>4__this._startCoroutine?.Invoke(<>4__this.MonitorAndUpdateScores());
						return false;
						IL_0400:
						if (string.IsNullOrEmpty(<>8__1.matchId))
						{
							<>4__this.Log("<color=red>[Match Creation] Failed to create Match record</color>");
							return false;
						}
						<>4__this._currentMatchId = <>8__1.matchId;
						<>4__this.Log("<color=green>[Match Creation] ✓ Match created: " + <>8__1.matchId + "</color>");
						<>2__current = <>4__this._callApi("/MatchmakingSession/" + <>4__this._currentSession.id, "PUT", "{\"match_id\":\"" + <>8__1.matchId + "\"}", delegate(string res)
						{
							try
							{
								JObject val2 = <>8__1.<>4__this._parseApiSingleObject(res);
								if (val2 != null)
								{
									<>8__1.<>4__this.Log("<color=green>[Match Creation] ✓ MatchmakingSession " + <>8__1.<>4__this._currentSession.id + " linked to match: " + <>8__1.matchId + "</color>");
								}
								else
								{
									<>8__1.<>4__this.Log("<color=yellow>[Match Creation] Could not confirm MatchmakingSession update</color>");
								}
							}
							catch (Exception ex2)
							{
								<>8__1.<>4__this.Log("<color=yellow>[Match Creation] Error updating MatchmakingSession: " + ex2.Message + "</color>");
							}
						});
						<>1__state = 5;
						return true;
						IL_02f9:
						if (string.IsNullOrEmpty(ReceivedP2PMatchId) && Time.realtimeSinceStartup < <waitEnd>5__7)
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						<>8__1.matchId = ReceivedP2PMatchId;
						if (!string.IsNullOrEmpty(<>8__1.matchId))
						{
							<>4__this.Log("<color=green>[Match Creation] ✓ Adopted Match ID from higher-version peer: " + <>8__1.matchId + "</color>");
							goto IL_0400;
						}
						<>4__this.Log("<color=yellow>[Match Creation] No Match ID received from higher-version peer within 15s — submitting own Match record</color>");
						<>2__current = <>4__this.SubmitMatchEntry(<matchStats>5__6, delegate(string id)
						{
							<>8__1.matchId = id;
						});
						<>1__state = 3;
						return true;
						IL_06c2:
						if (!string.IsNullOrEmpty(<>8__10.playerName))
						{
							if (<>4__this._cachedLeaderboardScores.TryGetValue(<>8__10.playerName, out <score>5__19))
							{
								<gamePoints>5__11 = <score>5__19;
								<>4__this._cachedLeaderboardScoresVsPar.TryGetValue(<>8__10.playerName, out <scoreVsPar>5__12);
							}
							<>4__this._lastSubmittedScores[<>8__10.playerName] = <gamePoints>5__11;
							<>4__this._lastSubmittedScoresVsPar[<>8__10.playerName] = <scoreVsPar>5__12;
						}
						<startingPosition>5__13 = <>4__this.GetPlayerFinishPosition(<>8__10.playerName, startingLeaderboard);
						<adjustedScore>5__14 = <gamePoints>5__11 + <scoreVsPar>5__12 * -10;
						<mmrField>5__15 = ((!string.IsNullOrEmpty(<>8__10.preMatchMmr)) ? (",\"pre_match_mmr\":" + <>8__10.preMatchMmr) : "");
						<posField>5__16 = ((<startingPosition>5__13 > 0) ? $",\"finish_position\":{<startingPosition>5__13}" : "");
						instance = UnifiedPlugin.Instance;
						<modVer>5__17 = ((instance == null) ? null : ((BaseUnityPlugin)instance).Info.Metadata.Version?.ToString()) ?? "unknown";
						<json>5__18 = "{\"match_id\":\"" + <>8__10.CS$<>8__locals2.CS$<>8__locals1.matchId + "\",\"player_id\":\"" + <>8__10.CS$<>8__locals2.playerId + "\",\"player_name\":\"" + (<>8__10.playerName ?? "Unknown") + "\"," + $"\"game_points\":{<gamePoints>5__11}," + $"\"over_under\":{<scoreVsPar>5__12}," + $"\"score_vs_par\":{<scoreVsPar>5__12}," + $"\"adjusted_match_score\":{<adjustedScore>5__14}" + <mmrField>5__15 + <posField>5__16 + ",\"notes\":\"Progressive match tracking - created at round start (Mod v" + <modVer>5__17 + ")\"}";
						<>4__this.Log("<color=cyan>[Match Creation] JSON: " + <json>5__18 + "</color>");
						<>8__10.entryId = null;
						<>2__current = <>4__this._callApi("/MatchEntry", "POST", <json>5__18, delegate(string res)
						{
							try
							{
								JObject val = <>8__10.CS$<>8__locals2.CS$<>8__locals1.<>4__this._parseApiSingleObject(res);
								if (val != null)
								{
									<>8__10.entryId = (string)val["id"];
									<>8__10.CS$<>8__locals2.CS$<>8__locals1.<>4__this._playerMatchEntryIds[<>8__10.CS$<>8__locals2.playerId] = <>8__10.entryId;
									<>8__10.CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=green>[Match Creation] ✓ MatchEntry created for " + <>8__10.playerName + ": " + <>8__10.entryId + "</color>");
								}
							}
							catch (Exception ex)
							{
								<>8__10.CS$<>8__locals2.CS$<>8__locals1.<>4__this.Log("<color=yellow>[Match Creation] Could not parse MatchEntry: " + ex.Message + "</color>");
							}
						});
						<>1__state = 7;
						return true;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__8).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <FinalizeMatchStats>d__30 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<LiveLeaderboardPlugin.SBGLPlayer> finalLeaderboard;

			public MatchResultSubmissionService <>4__this;

			private string <currentMatchType>5__1;

			private List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator <>s__2;

			private LiveLeaderboardPlugin.SBGLPlayer <player>5__3;

			private int <finalGamePoints>5__4;

			private int <finalScoreVsPar>5__5;

			private int <finishPosition>5__6;

			private string <playerId>5__7;

			private string <entryId>5__8;

			private string <strokeStr>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<currentMatchType>5__1 = null;
				<>s__2 = default(List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator);
				<player>5__3 = null;
				<playerId>5__7 = null;
				<entryId>5__8 = null;
				<strokeStr>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<currentMatchType>5__1 = <>4__this._currentSession?.match_type ?? PlayerPrefs.GetString("MatchType", "");
						if (IsProSeriesMatchType(<currentMatchType>5__1) || IsCasualMatchType(<currentMatchType>5__1))
						{
							<>4__this._matchStatsSubmitted = true;
							return false;
						}
						<>2__current = (object)new WaitForSeconds(1.5f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>4__this.Log("<color=cyan>[Match Finalize] Performing final score update...</color>");
						if (finalLeaderboard == null || finalLeaderboard.Count == 0)
						{
							<>4__this.Log("<color=yellow>[Match Finalize] No leaderboard data available</color>");
							<>4__this._matchStatsSubmitted = true;
							return false;
						}
						<>4__this.Log($"<color=cyan>[Match Finalize] Using final snapshot with {finalLeaderboard.Count} players</color>");
						<>s__2 = finalLeaderboard.GetEnumerator();
						<>1__state = -3;
						goto IL_0349;
					case 2:
						{
							<>1__state = -3;
							goto IL_0333;
						}
						IL_0349:
						do
						{
							if (<>s__2.MoveNext())
							{
								<player>5__3 = <>s__2.Current;
								continue;
							}
							<>m__Finally1();
							<>s__2 = default(List<LiveLeaderboardPlugin.SBGLPlayer>.Enumerator);
							<>4__this._matchStatsSubmitted = true;
							<>4__this.Log("<color=green>[Match Finalize] ✓ Match stats finalized</color>");
							return false;
						}
						while (<player>5__3 == null);
						<finalGamePoints>5__4 = <player>5__3.BaseScore;
						<finalScoreVsPar>5__5 = 0;
						<finishPosition>5__6 = <>4__this.GetPlayerFinishPosition(<player>5__3.Name, finalLeaderboard);
						if (!string.IsNullOrEmpty(<player>5__3.RawStrokes))
						{
							<strokeStr>5__9 = <player>5__3.RawStrokes.Replace("±", "").Trim();
							int.TryParse(<strokeStr>5__9, out <finalScoreVsPar>5__5);
							<strokeStr>5__9 = null;
						}
						<playerId>5__7 = null;
						<entryId>5__8 = null;
						if (<player>5__3.Name == <>4__this._userProfile.display_name)
						{
							<playerId>5__7 = <>4__this._userProfile.id;
						}
						if (!string.IsNullOrEmpty(<playerId>5__7) && <>4__this._playerMatchEntryIds.TryGetValue(<playerId>5__7, out <entryId>5__8))
						{
							<>4__this.Log($"<color=cyan>[Match Finalize] Final update for {<player>5__3.Name}: {<finalGamePoints>5__4} pts, {<finalScoreVsPar>5__5} vs par, Position: {<finishPosition>5__6}</color>");
							<>2__current = <>4__this.UpdateMatchEntry(<entryId>5__8, <playerId>5__7, <player>5__3.Name, <finalGamePoints>5__4, <finalScoreVsPar>5__5, <finishPosition>5__6);
							<>1__state = 2;
							return true;
						}
						goto IL_0333;
						IL_0333:
						<playerId>5__7 = null;
						<entryId>5__8 = null;
						<player>5__3 = null;
						goto IL_0349;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__2).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <IncrementCasualMatchesPlayedForLeaderboard>d__26 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<LiveLeaderboardPlugin.SBGLPlayer> leaderboardPlayers;

			public MatchResultSubmissionService <>4__this;

			private List<string> <leaderboardNames>5__1;

			private int <updatedPlayers>5__2;

			private List<string>.Enumerator <>s__3;

			private string <leaderboardName>5__4;

			private <>c__DisplayClass26_0 <>8__5;

			private int <updatedCount>5__6;

			private string <json>5__7;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 2u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<leaderboardNames>5__1 = null;
				<>s__3 = default(List<string>.Enumerator);
				<leaderboardName>5__4 = null;
				<>8__5 = null;
				<json>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<leaderboardNames>5__1 = (from player in leaderboardPlayers?.Where((LiveLeaderboardPlugin.SBGLPlayer player) => player != null && !string.IsNullOrWhiteSpace(player.Name))
							select player.Name.Trim()).Distinct<string>(StringComparer.OrdinalIgnoreCase).ToList() ?? new List<string>();
						if (<leaderboardNames>5__1.Count == 0)
						{
							<>4__this.Log("<color=yellow>[Casual] No active leaderboard names found - skipping casual stat increment</color>");
							return false;
						}
						<updatedPlayers>5__2 = 0;
						<>s__3 = <leaderboardNames>5__1.GetEnumerator();
						<>1__state = -3;
						goto IL_0409;
					case 1:
						<>1__state = -3;
						goto IL_01f1;
					case 2:
						<>1__state = -3;
						<updatedCount>5__6 = <>8__5.casualMatchesPlayed + 1;
						<json>5__7 = "{" + $"\"casual_matches_played\":{<updatedCount>5__6}" + "}";
						<>8__5.updated = false;
						<>2__current = <>4__this._callApi("/Player/" + <>8__5.playerId, "PUT", <json>5__7, delegate(string res)
						{
							if (<>8__5.<>4__this._parseApiSingleObject(res) != null)
							{
								<>8__5.updated = true;
							}
						});
						<>1__state = 3;
						return true;
					case 3:
						{
							<>1__state = -3;
							if (!<>8__5.updated)
							{
								<>4__this.Log("<color=yellow>[Casual] Failed to update casual_matches_played for " + <leaderboardName>5__4 + "</color>");
							}
							else
							{
								<updatedPlayers>5__2++;
								<>4__this.Log($"<color=green>[Casual] ✓ Updated {<>8__5.resolvedDisplayName} ({<>8__5.playerId}) casual_matches_played: {<>8__5.casualMatchesPlayed} -> {<updatedCount>5__6}</color>");
								<>8__5 = null;
								<json>5__7 = null;
								<leaderboardName>5__4 = null;
							}
							goto IL_0409;
						}
						IL_01f1:
						if (string.IsNullOrWhiteSpace(<>8__5.playerId))
						{
							<>4__this.Log("<color=yellow>[Casual] Could not resolve player ID for '" + <leaderboardName>5__4 + "' - skipping casual stat update</color>");
							goto IL_0409;
						}
						<>8__5.casualMatchesPlayed = 0;
						<>8__5.resolvedDisplayName = <leaderboardName>5__4;
						<>2__current = <>4__this._callApi("/Player/" + <>8__5.playerId, "GET", "", delegate(string res)
						{
							JObject val = <>8__5.<>4__this._parseApiSingleObject(res);
							if (val != null)
							{
								<>8__5.resolvedDisplayName = ((string)val["display_name"]) ?? <>8__5.resolvedDisplayName;
								int.TryParse(((object)val["casual_matches_played"])?.ToString() ?? "0", out <>8__5.casualMatchesPlayed);
							}
						});
						<>1__state = 2;
						return true;
						IL_0409:
						if (<>s__3.MoveNext())
						{
							<leaderboardName>5__4 = <>s__3.Current;
							<>8__5 = new <>c__DisplayClass26_0();
							<>8__5.<>4__this = <>4__this;
							<>8__5.playerId = null;
							if (!string.IsNullOrWhiteSpace(<>4__this._userProfile?.id) && string.Equals(<leaderboardName>5__4, <>4__this._userProfile.display_name, StringComparison.OrdinalIgnoreCase))
							{
								<>8__5.playerId = <>4__this._userProfile.id;
							}
							if (string.IsNullOrWhiteSpace(<>8__5.playerId))
							{
								<>2__current = <>4__this.ResolvePlayerIdByName(<leaderboardName>5__4, delegate(string id)
								{
									<>8__5.playerId = id;
								});
								<>1__state = 1;
								return true;
							}
							goto IL_01f1;
						}
						<>m__Finally1();
						<>s__3 = default(List<string>.Enumerator);
						<>4__this._matchEntriesCreated = true;
						<>4__this._matchStatsSubmitted = true;
						<>4__this.Log($"<color=cyan>[Casual] Casual match handling complete - updated {<updatedPlayers>5__2}/{<leaderboardNames>5__1.Count} players</color>");
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__3).Dispose();
			}

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

		[CompilerGenerated]
		private sealed class <MonitorAndUpdateScores>d__31 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MatchResultSubmissionService <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.Log("<color=cyan>[Match Monitor] Starting score monitoring for gameplay</color>");
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<>4__this._isInGameplay && <>4__this._currentMatchId != null)
				{
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				}
				<>4__this.Log("<color=cyan>[Match Monitor] Score monitoring ended</color>");
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <ResolvePlayerIdByName>d__25 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string playerName;

			public Action<string> onResolved;

			public MatchResultSubmissionService <>4__this;

			private <>c__DisplayClass25_0 <>8__1;

			private string <escapedName>5__2;

			private string <query>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<escapedName>5__2 = null;
				<query>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass25_0();
					<>8__1.<>4__this = <>4__this;
					if (onResolved == null)
					{
						return false;
					}
					if (string.IsNullOrWhiteSpace(playerName))
					{
						onResolved(null);
						return false;
					}
					<>8__1.normalizedName = playerName.Trim();
					<escapedName>5__2 = <>8__1.normalizedName.Replace("\\", "\\\\").Replace("\"", "\\\"");
					<query>5__3 = "{\"$or\":[{\"display_name\":\"" + <escapedName>5__2 + "\"},{\"ign\":\"" + <escapedName>5__2 + "\"}]}";
					<>8__1.resolvedId = null;
					<>2__current = <>4__this._callApi("/Player?q=" + UnityWebRequest.EscapeURL(<query>5__3) + "&limit=1", "GET", "", delegate(string res)
					{
						if (string.IsNullOrWhiteSpace(res))
						{
							return;
						}
						try
						{
							JToken val = JToken.Parse(res);
							JArray val2 = (JArray)(object)((val is JArray) ? val : null);
							JObject val3 = (JObject)((val2 != null) ? ((object)((IEnumerable)val2).OfType<JObject>().FirstOrDefault()) : ((object)((val is JObject) ? val : null)));
							if (val3 != null)
							{
								<>8__1.resolvedId = (string)val3["id"];
							}
						}
						catch (Exception ex)
						{
							<>8__1.<>4__this.Log("<color=yellow>[Casual] Could not resolve player '" + <>8__1.normalizedName + "': " + ex.Message + "</color>");
						}
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					onResolved(<>8__1.resolvedId);
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <SubmitMatchEntry>d__33 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin.MatchStats stats;

			public Action<string> onMatchIdReceived;

			public MatchResultSubmissionService <>4__this;

			private <>c__DisplayClass33_0 <>8__1;

			private string <seasonId>5__2;

			private bool <isProSeries>5__3;

			private string <apiMatchType>5__4;

			private string <mode>5__5;

			private JObject <payload>5__6;

			private string <json>5__7;

			private int <proSeriesWeek>5__8;

			private string <proSeriesEventName>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<seasonId>5__2 = null;
				<apiMatchType>5__4 = null;
				<mode>5__5 = null;
				<payload>5__6 = null;
				<json>5__7 = null;
				<proSeriesEventName>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: 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_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0163: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: 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_01fc: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass33_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.onMatchIdReceived = onMatchIdReceived;
					if (stats == null || <>4__this._currentSession == null)
					{
						return false;
					}
					<seasonId>5__2 = "69de6bf4fb103cb0d5eb00c5";
					<isProSeries>5__3 = IsProSeriesMatchType(stats.match_type);
					<apiMatchType>5__4 = (<isProSeries>5__3 ? "pro_series" : "mmr");
					<mode>5__5 = (<isProSeries>5__3 ? "Pro Series" : "Ranked");
					JObject val = new JObject
					{
						["matchmaking_session_id"] = JToken.op_Implicit(<>4__this._currentSession.id),
						["season_id"] = JToken.op_Implicit(<seasonId>5__2),
						["match_date"] = JToken.op_Implicit(stats.match_date),
						["match_type"] = JToken.op_Implicit(<apiMatchType>5__4),
						["course_name"] = JToken.op_Implicit(stats.course_name),
						["player_count"] = JToken.op_Implicit(2),
						["status"] = JToken.op_Implicit("Pending"),
						["submitted_by_name"] = JToken.op_Implicit(stats.player_name),
						["mode"] = JToken.op_Implicit(<mode>5__5)
					};
					UnifiedPlugin instance = UnifiedPlugin.Instance;
					val["notes"] = JToken.op_Implicit("Auto-submitted via SBGL Unified Mod v" + (((instance == null) ? null : ((BaseUnityPlugin)instance).Info.Metadata.Version?.ToString()) ?? "unknown"));
					<payload>5__6 = val;
					if (<isProSeries>5__3)
					{
						<payload>5__6["pro_series_season_id"] = JToken.op_Implicit("69b59af135403a1cb7b113c8");
						<proSeriesWeek>5__8 = PlayerPrefs.GetInt("ProSeriesWeek", 0);
						if (<proSeriesWeek>5__8 > 0)
						{
							<payload>5__6["pro_series_week"] = JToken.op_Implicit(<proSeriesWeek>5__8);
						}
						<proSeriesEventName>5__9 = PlayerPrefs.GetString("ProSeriesEventName", "");
						if (!string.IsNullOrWhiteSpace(<proSeriesEventName>5__9))
						{
							<payload>5__6["pro_series_event_name"] = JToken.op_Implicit(<proSeriesEventName>5__9);
						}
						<proSeriesEventName>5__9 = null;
					}
					<json>5__7 = ((JToken)<payload>5__6).ToString((Formatting)0, Array.Empty<JsonConverter>());
					<>4__this.Log("<color=cyan>[Match Stats] Submitting Match entry to API</color>");
					<>4__this.Log("<color=cyan>[Match Stats] Full URL: " + <>4__this._getBaseApiUrl() + "/Match</color>");
					<>4__this.Log("<color=cyan>[Match Stats] Payload: " + <json>5__7 + "</color>");
					<>2__current = <>4__this._callApi("/Match", "POST", <json>5__7, delegate(string res)
					{
						JObject val2 = <>8__1.<>4__this._parseApiSingleObject(res);
						if (val2 != null)
						{
							string text = ((string)val2["id"]) ?? "unknown";
							<>8__1.<>4__this.Log("<color=green>[Match Stats] ✓ Match entry created (ID: " + text + ")</color>");
							<>8__1.onMatchIdReceived?.Invoke(text);
						}
						else
						{
							<>8__1.<>4__this.Log("<color=yellow>[Match Stats] Response received but could not parse ID</color>");
						}
					});
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <UpdateMatchEntry>d__32 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string entryId;

			public string playerId;

			public string playerName;

			public int gamePoints;

			public int scoreVsPar;

			public int finishPosition;

			public MatchResultSubmissionService <>4__this;

			private <>c__DisplayClass32_0 <>8__1;

			private int <adjustedScore>5__2;

			private string <modVer>5__3;

			private string <json>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<modVer>5__3 = null;
				<json>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass32_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.playerName = playerName;
					<>4__this.Log($"<color=cyan>[Score Update] Hole completed for {<>8__1.playerName}: {gamePoints} pts, {scoreVsPar} vs par</color>");
					<adjustedScore>5__2 = gamePoints + scoreVsPar * -10;
					UnifiedPlugin instance = UnifiedPlugin.Instance;
					<modVer>5__3 = ((instance == null) ? null : ((BaseUnityPlugin)instance).Info.Metadata.Version?.ToString()) ?? "unknown";
					<json>5__4 = "{" + $"\"game_points\":{gamePoints}," + $"\"over_under\":{scoreVsPar}," + $"\"score_vs_par\":{scoreVsPar}," + $"\"adjusted_match_score\":{<adjustedScore>5__2}," + $"\"finish_position\":{finishPosition}," + "\"notes\":\"Updated after hole completion (Mod v" + <modVer>5__3 + ")\"}";
					<>2__current = <>4__this._callApi("/MatchEntry/" + entryId, "PUT", <json>5__4, delegate(string res)
					{
						try
						{
							JObject val = <>8__1.<>4__this._parseApiSingleObject(res);
							if (val != null)
							{
								<>8__1.<>4__this.Log("<color=green>[Score Update] ✓ MatchEntry updated for " + <>8__1.playerName + "</color>");
							}
						}
						catch (Exception ex)
						{
							<>8__1.<>4__this.Log("<color=yellow>[Score Update] Could not update MatchEntry: " + ex.Message + "</color>");
						}
					});
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		private const int SBGL_NET_CHANNEL = 2622;

		internal static string ReceivedP2PMatchId;

		private SBGLPlugin.MatchmakingSession _currentSession;

		private SBGLPlugin.PlayerProfile _userProfile;

		private string _currentMatchId;

		private Dictionary<string, string> _playerMatchEntryIds = new Dictionary<string, string>();

		private Dictionary<string, int> _lastSubmittedScores = new Dictionary<string, int>();

		private Dictionary<string, int> _lastSubmittedScoresVsPar = new Dictionary<string, int>();

		private Dictionary<string, int> _cachedLeaderboardScores = new Dictionary<string, int>();

		private Dictionary<string, int> _cachedLeaderboardScoresVsPar = new Dictionary<string, int>();

		private bool _matchEntriesCreated = false;

		private bool _isInGameplay = false;

		private DateTime? _matchStartTime = null;

		private bool _matchStatsSubmitted = false;

		private Func<string> _getBaseApiUrl;

		private Action<string> _logger;

		private Func<string, string, string, Action<string>, IEnumerator> _callApi;

		private Func<string, JObject> _parseApiSingleObject;

		private Action<IEnumerator> _startCoroutine;

		internal static void HandleIncomingMatchIdBroadcast(string matchId)
		{
			if (!string.IsNullOrEmpty(matchId))
			{
				ReceivedP2PMatchId = matchId;
			}
		}

		internal static void BroadcastMatchId(string matchId, IEnumerable<ulong> peers)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (!SteamClient.IsValid || string.IsNullOrEmpty(matchId))
			{
				return;
			}
			try
			{
				byte[] bytes = Encoding.UTF8.GetBytes("SBGL_MATCH_ID:" + matchId);
				int num = 0;
				foreach (ulong peer in peers)
				{
					try
					{
						SteamNetworking.SendP2PPacket(SteamId.op_Implicit(peer), bytes, -1, 2622, (P2PSend)2);
						num++;
					}
					catch
					{
					}
				}
				Debug.Log((object)$"[SBGL-MatchResult] Broadcast Match ID {matchId} to {num} peers");
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[SBGL-MatchResult] BroadcastMatchId error: " + ex.Message));
			}
		}

		public MatchResultSubmissionService(Func<string> getBaseApiUrl, Action<string> logger, Func<string, string, string, Action<string>, IEnumerator> callApi, Func<string, JObject> parseApiSingleObject, Action<IEnumerator> startCoroutine)
		{
			_getBaseApiUrl = getBaseApiUrl;
			_logger = logger;
			_callApi = callApi;
			_parseApiSingleObject = parseApiSingleObject;
			_startCoroutine = startCoroutine;
		}

		private void Log(string message)
		{
			_logger?.Invoke(message);
		}

		private static bool IsProSeriesMatchType(string matchType)
		{
			return !string.IsNullOrWhiteSpace(matchType) && matchType.IndexOf("pro_series", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static bool IsCasualMatchType(string matchType)
		{
			return !string.IsNullOrWhiteSpace(matchType) && matchType.IndexOf("casual", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		[IteratorStateMachine(typeof(<ResolvePlayerIdByName>d__25))]
		private IEnumerator ResolvePlayerIdByName(string playerName, Action<string> onResolved)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ResolvePlayerIdByName>d__25(0)
			{
				<>4__this = this,
				playerName = playerName,
				onResolved = onResolved
			};
		}

		[IteratorStateMachine(typeof(<IncrementCasualMatchesPlayedForLeaderboard>d__26))]
		private IEnumerator IncrementCasualMatchesPlayedForLeaderboard(List<LiveLeaderboardPlugin.SBGLPlayer> leaderboardPlayers)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <IncrementCasualMatchesPlayedForLeaderboard>d__26(0)
			{
				<>4__this = this,
				leaderboardPlayers = leaderboardPlayers
			};
		}

		public void Initialize(SBGLPlugin.MatchmakingSession session, SBGLPlugin.PlayerProfile profile)
		{
			_currentSession = session;
			_userProfile = profile;
			_playerMatchEntryIds.Clear();
			_lastSubmittedScores.Clear();
			_lastSubmittedScoresVsPar.Clear();
			_matchEntriesCreated = false;
			_matchStatsSubmitted = false;
		}

		public void SetCachedScores(Dictionary<string, int> scores, Dictionary<string, int> scoresVsPar)
		{
			_cachedLeaderboardScores = new Dictionary<string, int>(scores ?? new Dictionary<string, int>());
			_cachedLeaderboardScoresVsPar = new Dictionary<string, int>(scoresVsPar ?? new Dictionary<string, int>());
		}

		[IteratorStateMachine(typeof(<CreateMatchAndEntries>d__29))]
		public IEnumerator CreateMatchAndEntries(List<LiveLeaderboardPlugin.SBGLPlayer> startingLeaderboard, List<string> playerIds)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CreateMatchAndEntries>d__29(0)
			{
				<>4__this = this,
				startingLeaderboard = startingLeaderboard,
				playerIds = playerIds
			};
		}

		[IteratorStateMachine(typeof(<FinalizeMatchStats>d__30))]
		public IEnumerator FinalizeMatchStats(List<LiveLeaderboardPlugin.SBGLPlayer> finalLeaderboard)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FinalizeMatchStats>d__30(0)
			{
				<>4__this = this,
				finalLeaderboard = finalLeaderboard
			};
		}

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

		[IteratorStateMachine(typeof(<UpdateMatchEntry>d__32))]
		private IEnumerator UpdateMatchEntry(string entryId, string playerId, string playerName, int gamePoints, int scoreVsPar, int finishPosition = 0)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateMatchEntry>d__32(0)
			{
				<>4__this = this,
				entryId = entryId,
				playerId = playerId,
				playerName = playerName,
				gamePoints = gamePoints,
				scoreVsPar = scoreVsPar,
				finishPosition = finishPosition
			};
		}

		[IteratorStateMachine(typeof(<SubmitMatchEntry>d__33))]
		private IEnumerator SubmitMatchEntry(SBGLPlugin.MatchStats stats, Action<string> onMatchIdReceived)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SubmitMatchEntry>d__33(0)
			{
				<>4__this = this,
				stats = stats,
				onMatchIdReceived = onMatchIdReceived
			};
		}

		private int GetPlayerFinishPosition(string playerName, List<LiveLeaderboardPlugin.SBGLPlayer> leaderboard)
		{
			if (string.IsNullOrEmpty(playerName) || leaderboard == null || leaderboard.Count == 0)
			{
				return 0;
			}
			Dictionary<string, int> dictionary = BuildFinishPositionMap(leaderboard);
			if (dictionary.TryGetValue(playerName, out var value))
			{
				return value;
			}
			return 0;
		}

		private int ParseScoreVsPar(string rawStrokes)
		{
			if (string.IsNullOrWhiteSpace(rawStrokes))
			{
				return 0;
			}
			string s = rawStrokes.Replace("±", "").Trim();
			int.TryParse(s, out var result);
			return result;
		}

		private Dictionary<string, int> BuildFinishPositionMap(List<LiveLeaderboardPlugin.SBGLPlayer> leaderboard)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			if (leaderboard == null || leaderboard.Count == 0)
			{
				return dictionary;
			}
			var list = (from p in leaderboard
				where p != null && !string.IsNullOrWhiteSpace(p.Name)
				select new
				{
					Player = p,
					Stroke = ParseScoreVsPar(p.RawStrokes)
				} into x
				orderby x.Player.AdjustedPoints descending, x.Player.BaseScore descending, x.Stroke
				select x).ThenBy(x => x.Player.Name, StringComparer.OrdinalIgnoreCase).ToList();
			int num = 1;
			foreach (var item in list)
			{
				if (!dictionary.ContainsKey(item.Player.Name))
				{
					dictionary[item.Player.Name] = num++;
				}
			}
			return dictionary;
		}
	}
}
namespace SBGLLiveLeaderboard
{
	public class LiveLeaderboardPlugin : MonoBehaviour
	{
		public class SBGLPlayer
		{
			public string Name;

			public int BaseScore;

			public int AdjustedPoints;

			public string RawStrokes;

			public string MMR = "...";

			public string ProjectedDisplay = "...";
		}

		[CompilerGenerated]
		private sealed class <GetMMRForPlayer>d__50 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string originalName;

			public LiveLeaderboardPlugin <>4__this;

			private string <query>5__1;

			private string <url>5__2;

			private bool <needsFallback>5__3;

			private UnityWebRequest <r>5__4;

			private JArray <res>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<query>5__1 = null;
				<url>5__2 = null;
				<r>5__4 = null;
				<res>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (<>4__this._pendingRequests.Contains(originalName))
						{
							return false;
						}
						<>4__this._pendingRequests.Add(originalName);
						<query>5__1 = "{\"display_name\":{\"$regex\":\"^" + originalName + "$\",\"$options\":\"i\"}}";
						<url>5__2 = UnifiedPlugin.GetCurrentPlayerApi() + "?q=" + UnityWebRequest.EscapeURL(<query>5__1);
						<needsFallback>5__3 = false;
						<r>5__4 = UnityWebRequest.Get(<url>5__2);
						<>1__state = -3;
						<r>5__4.SetRequestHeader("X-App-Id", UnifiedPlugin.GetCurrentAppId());
						<r>5__4.SetRequestHeader("api_key", UnifiedPlugin.GetCurrentAuthToken());
						<>2__current = <r>5__4.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<r>5__4.result == 1)
						{
							<res>5__5 = JArray.Parse(<r>5__4.downloadHandler.text);
							if (((JContainer)<res>5__5).Count > 0)
							{
								<>4__this._mmrCache[originalName] = (((object)<res>5__5[0][(object)"current_mmr"])?.ToString() ?? "--", Time.time);
							}
							else
							{
								<needsFallback>5__3 = true;
							}
							<res>5__5 = null;
						}
						else
						{
							<needsFallback>5__3 = true;
						}
						<>m__Finally1();
						<r>5__4 = null;
						if (<needsFallback>5__3)
						{
							<>2__current = <>4__this.GetMMRFuzzyFallback(originalName);
							<>1__state = 2;
							return true;
						}
						break;
					case 2:
						<>1__state = -1;
						break;
					}
					<>4__this._pendingRequests.Remove(originalName);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<r>5__4 != null)
				{
					((IDisposable)<r>5__4).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <GetMMRFuzzyFallback>d__51 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string originalName;

			public LiveLeaderboardPlugin <>4__this;

			private string <query>5__1;

			private string <url>5__2;

			private UnityWebRequest <r>5__3;

			private string <val>5__4;

			private JArray <res>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<query>5__1 = null;
				<url>5__2 = null;
				<r>5__3 = null;
				<val>5__4 = null;
				<res>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<query>5__1 = "{\"display_name\":{\"$regex\":\"" + originalName + "\",\"$options\":\"i\"}}";
						<url>5__2 = UnifiedPlugin.GetCurrentPlayerApi() + "?q=" + UnityWebRequest.EscapeURL(<query>5__1);
						<r>5__3 = UnityWebRequest.Get(<url>5__2);
						<>1__state = -3;
						<r>5__3.SetRequestHeader("X-App-Id", UnifiedPlugin.GetCurrentAppId());
						<r>5__3.SetRequestHeader("api_key", UnifiedPlugin.GetCurrentAuthToken());
						<>2__current = <r>5__3.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						<val>5__4 = "--";
						if ((int)<r>5__3.result == 1)
						{
							<res>5__5 = JArray.Parse(<r>5__3.downloadHandler.text);
							if (((JContainer)<res>5__5).Count > 0)
							{
								<val>5__4 = ((object)<res>5__5[0][(object)"current_mmr"])?.ToString() ?? "--";
							}
							<res>5__5 = null;
						}
						<>4__this._mmrCache[originalName] = (<val>5__4, Time.time);
						<val>5__4 = null;
						<>m__Finally1();
						<r>5__3 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<r>5__3 != null)
				{
					((IDisposable)<r>5__3).Dispose();
				}
			}

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

		private ConfigEntry<float> _configWidth;

		private ConfigEntry<float> _configMaxHeight;

		private ConfigEntry<float> _configPosX;

		private ConfigEntry<float> _configPosY;

		private ConfigEntry<float> _configOpacity;

		private ConfigEntry<int> _configMaxPlayers;

		private const float K_FACTOR = 24f;

		private bool _showWindow = true;

		private float _updateInterval = 2f;

		private float _nextUpdateTime = 0f;

		private float _lastOpacity = -1f;

		private List<SBGLPlayer> _persistentLeaderboard = new List<SBGLPlayer>();

		private List<SBGLPlayer> _finalLeaderboardSnapshot = new List<SBGLPlayer>();

		private bool _showFinalSnapshot = false;

		private readonly Dictionary<string, SBGLPlayer> _lastKnownRoundPlayers = new Dictionary<string, SBGLPlayer>(StringComparer.OrdinalIgnoreCase);

		private bool _roundCacheActive = false;

		private Dictionary<string, (string mmr, float lastFetchTime)> _mmrCache = new Dictionary<string, (string, float)>();

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

		private FieldInfo _entriesField;

		private Scoreboard _cachedScoreboard;

		private GUIStyle _windowStyle;

		private GUIStyle _centeredStyle;

		private GUIStyle _headerStyle;

		private GUIStyle _nameStyle;

		private GUIStyle _posStyle;

		private GUIStyle _negStyle;

		private Texture2D _blackTexture;

		private float ConfigWidth => _configWidth?.Value ?? PlayerPrefs.GetFloat("LL_Width", 350f);

		private float ConfigMaxHeight => _configMaxHeight?.Value ?? PlayerPrefs.GetFloat("LL_MaxHeight", 999f);

		private float ConfigPosX => _configPosX?.Value ?? PlayerPrefs.GetFloat("LL_PosX", 5f);

		private float ConfigPosY => _configPosY?.Value ?? PlayerPrefs.GetFloat("LL_PosY", 200f);

		private float ConfigOpacity => _configOpacity?.Value ?? PlayerPrefs.GetFloat("LL_Opacity", 0.85f);

		private int ConfigMaxPlayers => _configMaxPlayers?.Value ?? PlayerPrefs.GetInt("LL_MaxPlayers", 16);

		private Key ToggleKey => (Key)101;

		public void SetConfig(ConfigEntry<float> width, ConfigEntry<float> maxHeight, ConfigEntry<float> posX, ConfigEntry<float> posY, ConfigEntry<float> opacity, ConfigEntry<int> maxPlayers)
		{
			_configWidth = width;
			_configMaxHeight = maxHeight;
			_configPosX = posX;
			_configPosY = posY;
			_configOpacity = opacity;
			_configMaxPlayers = maxPlayers;
		}

		private void Awake()
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			if (!PlayerPrefs.HasKey("LL_Width"))
			{
				PlayerPrefs.SetFloat("LL_Width", 350f);
			}
			if (!PlayerPrefs.HasKey("LL_MaxHeight"))
			{
				PlayerPrefs.SetFloat("LL_MaxHeight", 999f);
			}
			if (!PlayerPrefs.HasKey("LL_PosX"))
			{
				PlayerPrefs.SetFloat("LL_PosX", 5f);
			}
			if (!PlayerPrefs.HasKey("LL_PosY"))
			{
				PlayerPrefs.SetFloat("LL_PosY", 200f);
			}
			if (!PlayerPrefs.HasKey("LL_Opacity"))
			{
				PlayerPrefs.SetFloat("LL_Opacity", 0.85f);
			}
			if (!PlayerPrefs.HasKey("LL_MaxPlayers"))
			{
				PlayerPrefs.SetInt("LL_MaxPlayers", 16);
			}
			_entriesField = typeof(Scoreboard).GetField("entries", BindingFlags.Instance | BindingFlags.NonPublic);
			_blackTexture = new Texture2D(1, 1);
			UnifiedPlugin.ApiConfigChanged += OnApiConfigChanged;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		private void OnApiConfigChanged()
		{
			_mmrCache.Clear();
			_pendingRequests.Clear();
			_nextUpdateTime = Time.time;
		}

		private void Update()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (Keyboard.current != null && ((ButtonControl)Keyboard.current[ToggleKey]).wasPressedThisFrame)
			{
				_showWindow = !_showWindow;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			string text = ((Scene)(ref activeScene)).name ?? string.Empty;
			bool flag = text.Contains("Driving") || text.Contains("Range");
			bool flag2 = text.ToLowerInvariant().Contains("menu");
			if (flag)
			{
				_showFinalSnapshot = true;
			}
			else
			{
				_showFinalSnapshot = false;
			}
			if (flag2)
			{
				ResetForMainMenu();
			}
			if (Time.time >= _nextUpdateTime)
			{
				ScrapeData();
				_nextUpdateTime = Time.time + _updateInterval;
			}
		}

		private void OnGUI()
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_0124: Expected O, but got Unknown
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01cc: 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)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Expected O, but got Unknown
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Expected O, but got Unknown
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Expected O, but got Unknown
			//IL_03bb: 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_03d5: Expected O, but got Unknown
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0528: Unknown result type (might be due to invalid IL or missing references)
			//IL_054c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0570: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Expected O, but got Unknown
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0616: Unknown result type (might be due to invalid IL or missing references)
			//IL_061b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0621: Unknown result type (might be due to invalid IL or missing references)
			//IL_062e: Expected O, but got Unknown
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0679: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0706: Expected O, but got Unknown
			//IL_0701: Unknown result type (might be due to invalid IL or missing references)
			//IL_0706: Unknown result type (might be due to invalid IL or missing references)
			//IL_0710: Unknown result type (might be due to invalid IL or missing references)
			//IL_071a: Expected O, but got Unknown
			//IL_0715: Unknown result type (might be due to invalid IL or missing references)
			//IL_071a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0725: Unknown result type (might be due to invalid IL or missing references)
			//IL_0735: Unknown result type (might be due to invalid IL or missing references)
			//IL_0763: Unknown result type (might be due to invalid IL or missing references)
			//IL_076c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0817: Unknown result type (might be due to invalid IL or missing references)
			//IL_083e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c6: Unknown result type (might be due to invalid IL or missing references)
			List<SBGLPlayer> list = ((_showFinalSnapshot && _finalLeaderboardSnapshot.Count > 0) ? _finalLeaderboardSnapshot : _persistentLeaderboard);
			if (!_showWindow || (!_showFinalSnapshot && list.Count == 0))
			{
				return;
			}
			float num = (float)Screen.height / 1080f;
			float num2 = 4f * num;
			float num3 = 26f * num;
			float num4 = 22f * num;
			if (_windowStyle == null || Mathf.Abs(_lastOpacity - ConfigOpacity) > 0.01f)
			{
				_lastOpacity = ConfigOpacity;
				_blackTexture.SetPixel(0, 0, new Color(0f, 0f, 0f, _lastOpacity));
				_blackTexture.Apply();
				GUIStyle val = new GUIStyle(GUI.skin.window);
				val.normal.background = _blackTexture;
				val.border = new RectOffset(0, 0, 0, 0);
				_windowStyle = val;
				_centeredStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = Mathf.RoundToInt(11f * num),
					alignment = (TextAnchor)4,
					richText = true,
					wordWrap = false
				};
				_headerStyle = new GUIStyle(_centeredStyle)
				{
					fontStyle = (FontStyle)1,
					wordWrap = false
				};
				_nameStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					richText = true,
					wordWrap = false,
					fontSize = Mathf.RoundToInt(12f * num)
				};
				GUIStyle val2 = new GUIStyle(_centeredStyle);
				val2.normal.textColor = Color.green;
				_posStyle = val2;
				GUIStyle val3 = new GUIStyle(_centeredStyle);
				val3.normal.textColor = new Color(1f, 0.45f, 0.45f);
				_negStyle = val3;
			}
			float num5 = 0.08f;
			float num6 = 0.35f;
			float num7 = 0.26f;
			float num8 = 0.12f;
			float num9 = 0.09f;
			float num10 = 0.1f;
			float num11 = ConfigWidth * num;
			float num12 = num11 - num2 * 2f;
			float num13 = num12 * num5;
			float num14 = num12 * num6;
			float num15 = num12 * num7;
			float num16 = num12 * num8;
			float num17 = num12 * num9;
			float num18 = num12 * num10;
			float num19 = num2 * 2f + num3 * 2f + (float)list.Count * num4;
			if (!string.IsNullOrWhiteSpace(SBGLPlugin.CurrentMatchId))
			{
				num19 += num3 * 0.7f;
			}
			float num20 = Mathf.Min(num19, ConfigMaxHeight * num);
			float num21 = Mathf.Clamp(ConfigPosX * num, 0f, (float)Screen.width - num11);
			float num22 = Mathf.Clamp(ConfigPosY * num, 0f, (float)Screen.height - num20);
			Rect val4 = default(Rect);
			((Rect)(ref val4))..ctor(num21, num22, num11, num20);
			if (num21 != ConfigPosX * num)
			{
				_configPosX.Value = num21 / num;
			}
			if (num22 != ConfigPosY * num)
			{
				_configPosY.Value = num22 / num;
			}
			GUI.Box(val4, "", _windowStyle);
			GUILayout.BeginArea(val4);
			float num23 = num2;
			GUIStyle val5 = new GUIStyle(_centeredStyle);
			val5.normal.textColor = new Color(1f, 0.85f, 0f);
			val5.fontStyle = (FontStyle)1;
			GUIStyle val6 = val5;
			GUIStyle val7 = new GUIStyle(_headerStyle)
			{
				fontSize = Mathf.RoundToInt(10f * num)
			};
			if (_showFinalSnapshot)
			{
				val7.normal.textColor = new Color(1f, 0.65f, 0.2f);
			}
			else
			{
				val7.normal.textColor = new Color(0.4f, 1f, 0.4f);
			}
			string text = (_showFinalSnapshot ? "FINAL SCORE" : "LIVE");
			GUI.Label(new Rect(num2, num23, num11 - num2 * 2f, num3), text, val7);
			num23 += num3;
			string currentMatchId = SBGLPlugin.CurrentMatchId;
			if (!string.IsNullOrWhiteSpace(currentMatchId))
			{
				GUIStyle val8 = new GUIStyle(val7)
				{
					fontStyle = (FontStyle)0,
					fontSize = Mathf.RoundToInt(8f * num)
				};
				val8.normal.textColor = new Color(0.6f, 0.6f, 0.6f);
				string text2 = ((currentMatchId.Length > 12) ? currentMatchId.Substring(currentMatchId.Length - 12) : currentMatchId);
				GUI.Label(new Rect(num2, num23, num11 - num2 * 2f, num3 * 0.7f), "ID: " + text2, val8);
				num23 += num3 * 0.7f;
			}
			float num24 = num2;
			GUI.Label(new Rect(num24, num23, num13, num3), "#", _headerStyle);
			num24 += num13;
			GUI.Label(new Rect(num24, num23, num14, num3), "PLAYER", _headerStyle);
			num24 += num14;
			GUI.Label(new Rect(num24, num23, num15, num3), "MMR", _headerStyle);
			num24 += num15;
			GUI.Label(new Rect(num24, num23, num16, num3), "PTS", _headerStyle);
			num24 += num16;
			GUI.Label(new Rect(num24, num23, num17, num3), "+/-", _headerStyle);
			num24 += num17;
			GUI.Label(new Rect(num24, num23, num18, num3), "BASE", _headerStyle);
			num23 += num3;
			if (list.Count == 0 && _showFinalSnapshot)
			{
				GUIStyle val9 = new GUIStyle(_centeredStyle);
				val9.normal.textColor = Color.gray;
				GUIStyle val10 = val9;
				GUI.Label(new Rect(num2, num23, num11 - num2 * 2f, num4), "Loading final scores...", val10);
			}
			else
			{
				foreach (SBGLPlayer item in list)
				{
					float num25 = num2;
					GUI.Label(new Rect(num25, num23, num13, num4), $"{list.IndexOf(item) + 1}.", _centeredStyle);
					num25 += num13;
					GUI.Label(new Rect(num25, num23, num14, num4), item.Name, _nameStyle);
					num25 += num14;
					string mMR = item.MMR;
					string text3 = item.ProjectedDisplay.Replace(mMR, "").Trim();
					Vector2 val11 = _centeredStyle.CalcSize(new GUIContent(mMR));
					Vector2 val12 = _centeredStyle.CalcSize(new GUIContent(text3));
					float num26 = 3f * num;
					float num27 = val11.x + (string.IsNullOrEmpty(text3) ? 0f : (val12.x + num26));
					float num28 = num25 + num15 / 2f - num27 / 2f;
					GUI.Label(new Rect(num28, num23, val11.x, num4), mMR, _centeredStyle);
					if (!string.IsNullOrEmpty(text3))
					{
						GUIStyle val13 = (text3.Contains("+") ? _posStyle : _negStyle);
						GUI.Label(new Rect(num28 + val11.x + num26, num23, val12.x, num4), text3, val13);
					}
					num25 += num15;
					GUI.Label(new Rect(num25, num23, num16, num4), $"{item.AdjustedPoints}", val6);
					num25 += num16;
					GUI.Label(new Rect(num25, num23, num17, num4), item.RawStrokes, _centeredStyle);
					num25 += num17;
					GUI.Label(new Rect(num25, num23, num18, num4), $"{item.BaseScore}", _centeredStyle);
					num23 += num4;
					if (num23 > num20 - num2)
					{
						break;
					}
				}
			}
			GUILayout.EndArea();
		}

		private void ScrapeData()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			if (name.Contains("Driving") || name.Contains("Range"))
			{
				_roundCacheActive = false;
				return;
			}
			if (!_roundCacheActive)
			{
				_lastKnownRoundPlayers.Clear();
				_roundCacheActive = true;
			}
			if ((Object)(object)_cachedScoreboard == (Object)null)
			{
				_cachedScoreboard = Object.FindAnyObjectByType<Scoreboard>((FindObjectsInactive)1);
			}
			if ((Object)(object)_cachedScoreboard == (Object)null || _entriesField == null || !(_entriesField.GetValue(_cachedScoreboard) is List<ScoreboardEntry> list) || list.Count == 0)
			{
				return;
			}
			List<SBGLPlayer> list2 = new List<SBGLPlayer>();
			foreach (ScoreboardEntry item in list)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				TextMeshProUGUI name2 = item.name;
				string text = CleanTMP((name2 != null) ? ((TMP_Text)name2).text : null);
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				string text2 = text.ToLowerInvariant();
				if (text == "Name" || text2.Contains("spectator") || text2.Contains("observer") || text2.Contains("spectating") || text2.Contains("spec "))
				{
					continue;
				}
				TextMeshProUGUI strokes = item.strokes;
				string text3 = CleanTMP((strokes != null) ? ((TMP_Text)strokes).text : null);
				TextMeshProUGUI courseScore = item.courseScore;
				string text4 = CleanTMP((courseScore != null) ? ((TMP_Text)courseScore).text : null);
				if (!string.IsNullOrEmpty(text3) && text3.ToUpper().Contains("SPEC"))
				{
					continue;
				}
				bool flag = Regex.IsMatch(text3 ?? string.Empty, "\\d");
				bool flag2 = Regex.IsMatch(text4 ?? string.Empty, "\\d");
				bool flag3 = !string.IsNullOrEmpty(text3) && Regex.IsMatch(text3, "^[\\-\\u2013\\u2014\\s]+$");
				if (!flag && !flag2 && flag3)
				{
					continue;
				}
				int.TryParse(text4, out var result);
				int.TryParse(text3.Replace("±", "").Replace("+", "").Trim(), out var result2);
				string text5 = "...";
				if (_mmrCache.TryGetValue(text, out (string, float) value))
				{
					(text5, _) = value;
					if (Time.time - value.Item2 > 300f && !_pendingRequests.Contains(text))
					{
						((MonoBehaviour)this).StartCoroutine(GetMMRForPlayer(text));
					}
				}
				else if (!_pendingRequests.Contains(text))
				{
					((MonoBehaviour)this).StartCoroutine(GetMMRForPlayer(text));
				}
				list2.Add(new SBGLPlayer
				{
					Name = text,
					BaseScore = result,
					RawStrokes = text3,
					AdjustedPoints = result + result2 * -10,
					MMR = text5,
					ProjectedDisplay = text5
				});
			}
			HashSet<string> hashSet = new HashSet<string>(list2.Select((SBGLPlayer p) => p.Name), StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, SBGLPlayer> lastKnownRoundPlayer in _lastKnownRoundPlayers)
			{
				if (!hashSet.Contains(lastKnownRoundPlayer.Key) && lastKnownRoundPlayer.Value != null)
				{
					list2.Add(ClonePlayer(lastKnownRoundPlayer.Value));
				}
			}
			if (list2.Count > 1)
			{
				CalculateProjectedMMR(list2);
			}
			_persistentLeaderboard = list2.OrderByDescending((SBGLPlayer p) => p.AdjustedPoints).Take(ConfigMaxPlayers).ToList();
			_lastKnownRoundPlayers.Clear();
			foreach (SBGLPlayer item2 in _persistentLeaderboard)
			{
				if (item2 != null && !string.IsNullOrEmpty(item2.Name))
				{
					_lastKnownRoundPlayers[item2.Name] = ClonePlayer(item2);
				}
			}
		}

		private SBGLPlayer ClonePlayer(SBGLPlayer source)
		{
			if (source == null)
			{
				return null;
			}
			return new SBGLPlayer
			{
				Name = source.Name,
				BaseScore = source.BaseScore,
				AdjustedPoints = source.AdjustedPoints,
				RawStrokes = source.RawStrokes,
				MMR = source.MMR,
				ProjectedDisplay = source.ProjectedDisplay
			};
		}

		private void CalculateProjectedMMR(List<SBGLPlayer> players)
		{
			Dictionary<string, float> dictionary = new Dictionary<string, float>();
			foreach (SBGLPlayer player in players)
			{
				dictionary[player.Name] = 0f;
			}
			for (int i = 0; i < players.Count; i++)
			{
				for (int j = i + 1; j < players.Count; j++)
				{
					SBGLPlayer sBGLPlayer = players[i];
					SBGLPlayer sBGLPlayer2 = players[j];
					if (float.TryParse(sBGLPlayer.MMR, out var result) && float.TryParse(sBGLPlayer2.MMR, out var result2))
					{
						float num = 1f / (1f + Mathf.Pow(10f, (result2 - result) / 400f));
						float num2 = ((sBGLPlayer.AdjustedPoints > sBGLPlayer2.AdjustedPoints) ? 1f : ((sBGLPlayer.AdjustedPoints < sBGLPlayer2.AdjustedPoints) ? 0f : 0.5f));
						float num3 = 24f * (num2 - num);
						dictionary[sBGLPlayer.Name] += num3;
						dictionary[sBGLPlayer2.Name] -= num3;
					}
				}
			}
			foreach (SBGLPlayer player2 in players)
			{
				if (float.TryParse(player2.MMR, out var _))
				{
					int num4 = Mathf.RoundToInt(dictionary[player2.Name]);
					player2.ProjectedDisplay = string.Format("{0} ({1}{2})", player2.MMR, (num4 >= 0) ? "+" : "", num4);
				}
			}
		}

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

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

		private string CleanTMP(string input)
		{
			return string.IsNullOrEmpty(input) ? "" : Regex.Replace(input, "<.*?>", string.Empty).Trim();
		}

		public SBGLPlayer GetPlayerLeaderboardData(string playerName)
		{
			return _persistentLeaderboard.FirstOrDefault((SBGLPlayer p) => p.Name.Equals(playerName, StringComparison.OrdinalIgnoreCase));
		}

		public List<SBGLPlayer> GetCurrentLeaderboard()
		{
			return new List<SBGLPlayer>(_persistentLeaderboard);
		}

		private void ResetForMainMenu()
		{
			if (_persistentLeaderboard.Count != 0 || _finalLeaderboardSnapshot.Count != 0 || _mmrCache.Count != 0)
			{
				_persistentLeaderboard.Clear();
				_finalLeaderboardSnapshot.Clear();
				_showFinalSnapshot = false;
				_lastKnownRoundPlayers.Clear();
				_roundCacheActive = false;
				_mmrCache.Clear();
				_pendingRequests.Clear();
				_cachedScoreboard = null;
				_nextUpdateTime = Time.time + _updateInterval;
				Debug.Log((object)"[LiveLeaderboard] Reset leaderboard state on main menu");
			}
		}

		public void CaptureLeaderboardSnapshot()
		{
			_finalLeaderboardSnapshot = (from p in _persistentLeaderboard.Select(ClonePlayer)
				where p != null
				select p).ToList();
			Debug.Log((object)$"[LiveLeaderboard] Captured final snapshot: {_finalLeaderboardSnapshot.Count} players");
		}

		public List<SBGLPlayer> GetFinalLeaderboardSnapshot()
		{
			if (_finalLeaderboardSnapshot.Count > 0)
			{
				return (from p in _finalLeaderboardSnapshot.Select(ClonePlayer)
					where p != null
					select p).ToList();
			}
			return (from p in _persistentLeaderboard.Select(ClonePlayer)
				where p != null
				select p).ToList();
		}
	}
}
namespace SBGL.UnifiedMod
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "SBGL.UnifiedMod";

		public const string PLUGIN_NAME = "Super Battle Golf League Unified Mod";

		public const string PLUGIN_VERSION = "0.0.1";
	}
}
namespace SBGL.UnifiedMod.Utils
{
	public class BypassCertificate : CertificateHandler
	{
		protected override bool ValidateCertificate(byte[] certificateData)
		{
			return true;
		}
	}
	public static class ApiUtilities
	{
		[CompilerGenerated]
		private sealed class <MakeApiRequest>d__0 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string url;

			public Dictionary<string, string> headers;

			public Action<bool, string> onComplete;

			public ManualLogSource logger;

			private UnityWebRequest <req>5__1;

			private Dictionary<string, string>.Enumerator <>s__2;

			private KeyValuePair<string, string> <kvp>5__3;

			private string <errorMsg>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<req>5__1 = null;
				<>s__2 = default(Dictionary<string, string>.Enumerator);
				<kvp>5__3 = default(KeyValuePair<string, string>);
				<errorMsg>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<req>5__1 = UnityWebRequest.Get(url);
						<>1__state = -3;
						<req>5__1.certificateHandler = (CertificateHandler)(object)new BypassCertificate();
						if (headers != null)
						{
							<>s__2 = headers.GetEnumerator();
							try
							{
								while (<>s__2.MoveNext())
								{
									<kvp>5__3 = <>s__2.Current;
									<req>5__1.SetRequestHeader(<kvp>5__3.Key, <kvp>5__3.Value);
									<kvp>5__3 = default(KeyValuePair<string, string>);
								}
							}
							finally
							{
								((IDisposable)<>s__2).Dispose();
							}
							<>s__2 = default(Dictionary<string, string>.Enumerator);
						}
						<>2__current = <req>5__1.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<req>5__1.result == 1)
						{
							onComplete?.Invoke(arg1: true, <req>5__1.downloadHandler.text);
						}
						else
						{
							<errorMsg>5__4 = $"HTTP {<req>5__1.responseCode}: {<req>5__1.error}";
							DownloadHandler downloadHandler = <req>5__1.downloadHandler;
							if (!string.IsNullOrEmpty((downloadHandler != null) ? downloadHandler.text : null))
							{
								<errorMsg>5__4 = <errorMsg>5__4 + " | Response: " + <req>5__1.downloadHandler.text;
							}
							ManualLogSource obj = logger;
							if (obj != null)
							{
								obj.LogWarning((object)("[API] Request failed: " + <errorMsg>5__4));
							}
							onComplete?.Invoke(arg1: false, <errorMsg>5__4);
							<errorMsg>5__4 = null;
						}
						<>m__Finally1();
						<req>5__1 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<req>5__1 != null)
				{
					((IDisposable)<req>5__1).Dispose();
				}
			}

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

		[IteratorStateMachine(typeof(<MakeApiRequest>d__0))]
		public static IEnumerator MakeApiRequest(string url, Dictionary<string, string> headers, Action<bool, string> onComplete, ManualLogSource logger = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MakeApiRequest>d__0(0)
			{
				url = url,
				headers = headers,
				onComplete = onComplete,
				logger = logger
			};
		}

		public static JObject ParseJsonResponse(string json)
		{
			try
			{
				return JObject.Parse(json);
			}
			catch (Exception ex)
			{
				throw new InvalidOperationException("Failed to parse JSON response: " + ex.Message);
			}
		}

		public static JArray ParseJsonArrayResponse(string json)
		{
			try
			{
				return JArray.Parse(json);
			}
			catch (Exception ex)
			{
				throw new InvalidOperationException("Failed to parse JSON array response: " + ex.Message);
			}
		}
	}
	public static class PlayerProfileFetcher
	{
		public class PlayerProfile
		{
			public string ID;

			public string DisplayName;

			public float CurrentMMR;

			public string Region;

			public string ProfilePicUrl;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass1_0
		{
			public PlayerProfile profile;

			public bool found;

			public ManualLogSource logger;

			public string playerIdOrName;

			internal void <FetchPlayerProfile>b__0(bool success, string response)
			{
				if (success)
				{
					try
					{
						JArray val = ApiUtilities.ParseJsonArrayResponse(response);
						if (((JContainer)val).Count > 0)
						{
							profile = new PlayerProfile
							{
								ID = (((object)val[0][(object)"id"])?.ToString() ?? ""),
								DisplayName = (((object)val[0][(object)"display_name"])?.ToString() ?? ""),
								Region = (((object)val[0][(object)"region"])?.ToString() ?? "US"),
								ProfilePicUrl = ((object)val[0][(object)"profile_pic_url"])?.ToString(),
								CurrentMMR = (float.TryParse(((object)val[0][(object)"current_mmr"])?.ToString() ?? "0", out var result) ? result : 0f)
							};
							found = true;
							ManualLogSource obj = logger;
							if (obj != null)
							{
								obj.LogInfo((object)("[PlayerProfileFetcher] ✓ Found profile: " + profile.DisplayName + " (ID: " + profile.ID + ")"));
							}
						}
						else
						{
							ManualLogSource obj2 = logger;
							if (obj2 != null)
							{
								obj2.LogWarning((object)("[PlayerProfileFetcher] No results for: " + playerIdOrName));
							}
						}
						return;
					}
					catch (Exception ex)
					{
						ManualLogSource obj3 = logger;
						if (obj3 != null)
						{
							obj3.LogError((object)("[PlayerProfileFetcher] Parse error: " + ex.Message));
						}
						return;
					}
				}
				ManualLogSource obj4 = logger;
				if (obj4 != null)
				{
					obj4.LogError((object)("[PlayerProfileFetcher] Request failed: " + response));
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass2_0
		{
			public PlayerProfile profile;

			public bool found;

			public ManualLogSource logger;

			public string playerName;

			internal void <FuzzySearchPlayer>b__0(bool success, string response)
			{
				if (success)
				{
					try
					{
						JArray val = ApiUtilities.ParseJsonArrayResponse(response);
						if (((JContainer)val).Count > 0)
						{
							profile = new PlayerProfile
							{
								ID = (((object)val[0][(object)"id"])?.ToString() ?? ""),
								DisplayName = (((object)val[0][(object)"display_name"])?.ToString() ?? ""),
								Region = (((object)val[0][(object)"region"])?.ToString() ?? "US"),
								ProfilePicUrl = ((object)val[0][(object)"profile_pic_url"])?.ToString(),
								CurrentMMR = (float.TryParse(((object)val[0][(object)"current_mmr"])?.ToString() ?? "0", out var result) ? result : 0f)
							};
							found = true;
							ManualLogSource obj = logger;
							if (obj != null)
							{
								obj.LogInfo((object)("[PlayerProfileFetcher] ✓ Fuzzy match: " + profile.DisplayName));
							}
						}
						else
						{
							ManualLogSource obj2 = logger;
							if (obj2 != null)
							{
								obj2.LogWarning((object)("[PlayerProfileFetcher] No fuzzy matches for: " + playerName));
							}
						}
						return;
					}
					catch (Exception ex)
					{
						ManualLogSource obj3 = logger;
						if (obj3 != null)
						{
							obj3.LogError((object)("[PlayerProfileFetcher] Fuzzy parse error: " + ex.Message));
						}
						return;
					}
				}
				ManualLogSource obj4 = logger;
				if (obj4 != null)
				{
					obj4.LogError((object)("[PlayerProfileFetcher] Fuzzy request failed: " + response));
				}
			}
		}

		[CompilerGenerated]
		private sealed class <FetchPlayerProfile>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string playerIdOrName;

			public string playerApiUrl;

			public string appId;

			public string authToken;

			public Action<bool, PlayerProfile> onComplete;

			public ManualLogSource logger;

			private <>c__DisplayClass1_0 <>8__1;

			private string <query>5__2;

			private string <url>5__3;

			private Dictionary<string, string> <headers>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<query>5__2 = null;
				<url>5__3 = null;
				<headers>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass1_0();
					<>8__1.logger = logger;
					<>8__1.playerIdOrName = playerIdOrName;
					if (string.IsNullOrEmpty(<>8__1.playerIdOrName))
					{
						onComplete?.Invoke(arg1: false, null);
						return false;
					}
					<query>5__2 = (<>8__1.playerIdOrName.All(char.IsDigit) ? ("{\"id\":\"" + <>8__1.playerIdOrName + "\"}") : ("{\"display_name\":{\"$regex\":\"^" + <>8__1.playerIdOrName + "$\",\"$options\":\"i\"}}"));
					<url>5__3 = playerApiUrl + "?q=" + UnityWebRequest.EscapeURL(<query>5__2);
					<headers>5__4 = new Dictionary<string, string>
					{
						{ "X-App-Id", appId },
						{ "api_key", authToken }
					};
					<>8__1.found = false;
					<>8__1.profile = null;
					<>2__current = ApiUtilities.MakeApiRequest(<url>5__3, <headers>5__4, delegate(bool success, string response)
					{
						if (success)
						{
							try
							{
								JArray val = ApiUtilities.ParseJsonArrayResponse(response);
								if (((JContainer)val).Count > 0)
								{
									<>8__1.profile = new PlayerProfile
									{
										ID = (((object)val[0][(object)"id"])?.ToString() ?? ""),
										DisplayName = (((object)val[0][(object)"display_name"])?.ToString() ?? ""),
										Region = (((object)val[0][(object)"region"])?.ToString() ?? "US"),
										ProfilePicUrl = ((object)val[0][(object)"profile_pic_url"])?.ToString(),
										CurrentMMR = (float.TryParse(((object)val[0][(object)"current_mmr"])?.ToString() ?? "0", out var result) ? result : 0f)
									};
									<>8__1.found = true;
									ManualLogSource obj = <>8__1.logger;
									if (obj != null)
									{
										obj.LogInfo((object)("[PlayerProfileFetcher] ✓ Found profile: " + <>8__1.profile.DisplayName + " (ID: " + <>8__1.profile.ID + ")"));
									}
								}
								else
								{
									ManualLogSource obj2 = <>8__1.logger;
									if (obj2 != null)
									{
										obj2.LogWarning((object)("[PlayerProfileFetcher] No results for: " + <>8__1.playerIdOrName));
									}
								}
								return;
							}
							catch (Exception ex)
							{
								ManualLogSource obj3 = <>8__1.logger;
								if (obj3 != null)
								{
									obj3.LogError((object)("[PlayerProfileFetcher] Parse error: " + ex.Message));
								}
								return;
							}
						}
						ManualLogSource obj4 = <>8__1.logger;
						if (obj4 != null)
						{
							obj4.LogError((object)("[PlayerProfileFetcher] Request failed: " + response));
						}
					}, <>8__1.logger);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					onComplete?.Invoke(<>8__1.found, <>8__1.profile);
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <FuzzySearchPlayer>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string playerName;

			public string playerApiUrl;

			public string appId;

			public string authToken;

			public Action<bool, PlayerProfile> onComplete;

			public ManualLogSource logger;

			private <>c__DisplayClass2_0 <>8__1;

			private string <query>5__2;

			private string <url>5__3;

			private Dictionary<string, string> <headers>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<query>5__2 = null;
				<url>5__3 = null;
				<headers>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass2_0();
					<>8__1.logger = logger;
					<>8__1.playerName = playerName;
					<query>5__2 = "{\"display_name\":{\"$regex\":\"" + <>8__1.playerName + "\",\"$options\":\"i\"}}";
					<url>5__3 = playerApiUrl + "?q=" + UnityWebRequest.EscapeURL(<query>5__2);
					<headers>5__4 = new Dictionary<string, string>
					{
						{ "X-App-Id", appId },
						{ "api_key", authToken }
					};
					<>8__1.found = false;
					<>8__1.profile = null;
					<>2__current = ApiUtilities.MakeApiRequest(<url>5__3, <headers>5__4, delegate(bool success, string response)
					{
						if (success)
						{
							try
							{
								JArray val = ApiUtilities.ParseJsonArrayResponse(response);
								if (((JContainer)val).Count > 0)
								{
									<>8__1.profile = new PlayerProfile
									{
										ID = (((object)val[0][(object)"id"])?.ToString() ?? ""),
										DisplayName = (((object)val[0][(object)"display_name"])?.ToString() ?? ""),
										Region = (((object)val[0][(object)"region"])?.ToString() ?? "US"),
										ProfilePicUrl = ((object)val[0][(object)"profile_pic_url"])?.ToString(),
										CurrentMMR = (float.TryParse(((object)val[0][(object)"current_mmr"])?.ToString() ?? "0", out var result) ? result : 0f)
									};
									<>8__1.found = true;
									ManualLogSource obj = <>8__1.logger;
									if (obj != null)
									{
										obj.LogInfo((object)("[PlayerProfileFetcher] ✓ Fuzzy match: " + <>8__1.profile.DisplayName));
									}
								}
								else
								{
									ManualLogSource obj2 = <>8__1.logger;
									if (obj2 != null)
									{
										obj2.LogWarning((object)("[PlayerProfileFetcher] No fuzzy matches for: " + <>8__1.playerName));
									}
								}
								return;
							}
							catch (Exception ex)
							{
								ManualLogSource obj3 = <>8__1.logger;
								if (obj3 != null)
								{
									obj3.LogError((object)("[PlayerProfileFetcher] Fuzzy parse error: " + ex.Message));
								}
								return;
							}
						}
						ManualLogSource obj4 = <>8__1.logger;
						if (obj4 != null)
						{
							obj4.LogError((object)("[PlayerProfileFetcher] Fuzzy request failed: " + response));
						}
					}, <>8__1.logger);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					onComplete?.Invoke(<>8__1.found, <>8__1.profile);
					return false;
				}
			}

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

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

		[IteratorStateMachine(typeof(<FetchPlayerProfile>d__1))]
		public static IEnumerator FetchPlayerProfile(string playerIdOrName, string playerApiUrl, string appId, string authToken, Action<bool, PlayerProfile> onComplete, ManualLogSource logger = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FetchPlayerProfile>d__1(0)
			{
				playerIdOrName = playerIdOrName,
				playerApiUrl = playerApiUrl,
				appId = appId,
				authToken = authToken,
				onComplete = onComplete,
				logger = logger
			};
		}

		[IteratorStateMachine(typeof(<FuzzySearchPlayer>d__2))]
		public static IEnumerator FuzzySearchPlayer(string playerName, string playerApiUrl, string appId, string authToken, Action<bool, PlayerProfile> onComplete, ManualLogSource logger = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FuzzySearchPlayer>d__2(0)
			{
				playerName = playerName,
				playerApiUrl = playerApiUrl,
				appId = appId,
				authToken = authToken,
				onComplete = onComplete,
				logger = logger
			};
		}
	}
}
namespace SBGL.UnifiedMod.Patches
{
	[HarmonyPatch]
	public static class RulePatches
	{
		private static ManualLogSource _logger;

		private static ConfigEntry<bool> _applyRulesets;

		public static void SetLogger(ManualLogSource logger)
		{
			_logger = logger;
		}

		public static void SetApplyRulesetsConfig(ConfigEntry<bool> applyRulesets)
		{
			_applyRulesets = applyRulesets;
		}

		private static void Log(string message)
		{
			if (_logger != null)
			{
				_logger.LogInfo((object)("[RulePatches] " + message));
			}
		}

		private static void LogError(string message)
		{
			if (_logger != null)
			{
				_logger.LogError((object)("[RulePatches] " + message));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MatchSetupMenu), "OnStartClient")]
		public static void PatchMatchSetupMenuOnStartClient(MatchSetupMenu __instance)
		{
			try
			{
				if (!((NetworkBehaviour)__instance).isServer)
				{
					return;
				}
				ConfigEntry<bool> applyRulesets = _applyRulesets;
				if (applyRulesets != null && !applyRulesets.Value)
				{
					Log("ApplyRulesets is disabled in config — skipping rule enforcement");
					return;
				}
				string @string = PlayerPrefs.GetString("MatchType", "");
				bool flag = !string.IsNullOrEmpty(@string) && @string.Contains("season");
				bool flag2 = string.Equals(@string, "casual", StringComparison.OrdinalIgnoreCase);
				if (!flag && !flag2)
				{
					Log("Not a managed ruleset match (MatchType='" + @string + "'), skipping");
					return;
				}
				MatchSetupRules rules = __instance.rules;
				if ((Object)(object)rules == (Object)null)
				{
					LogError("__instance.rules is null");
					return;
				}
				Log("=== APPLYING SEASON 1 RULES (OnStartClient) ===");
				Log("  Match Type: " + @string);
				Log("  Host Ruleset: " + PlayerPrefs.GetString("HostRuleset", "ranked"));
				ApplyRulesToMatchSetup(rules);
				ApplyCourseSelection(__instance);
				Log("============================");
			}
			catch (Exception ex)
			{
				LogError("Exception in PatchMatchSetupMenuOnStartClient: " + ex.Message);
			}
		}

		public static void ApplyRulesToMatchSetup(MatchSetupRules matchSetup)
		{
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Invalid comparison between Unknown and I4
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: 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_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			string @string = PlayerPrefs.GetString("HostRuleset", "ranked");
			bool flag = @string == "pro_series";
			bool flag2 = @string == "casual";
			matchSetup.SetPreset((Preset)0);
			Log("✓ Reset to Classic preset");
			if (flag2)
			{
				Log("✓ Casual selected - leaving Classic preset defaults intact");
				return;
			}
			if (flag)
			{
				Dictionary<Rule, float> proSeriesRulesSettings = Season1RuleSet.GetProSeriesRulesSettings();
				int num = 0;
				foreach (KeyValuePair<Rule, float> item in proSeriesRulesSettings)
				{
					try
					{
						matchSetup.SetValue(item.Key, item.Value);
						SliderOption value2;
						if (matchSetup.onOffDropdownLookup.TryGetValue(item.Key, out var value))
						{
							value.SetValue((!matchSetup.GetValueAsBoolInternal(item.Key)) ? 1 : 0);
						}
						else if (matchSetup.sliderLookup.TryGetValue(item.Key, out value2))
						{
							value2.SetValue(matchSetup.GetValueInternal(item.Key));
						}
						matchSetup.UpdateRule(item.Key);
						Log($"  ✓ Set {item.Key} = {item.Value}");
						num++;
					}
					catch (Exception ex)
					{
						LogError($"  ✗ Failed to set {item.Key}: {ex.Message}");
					}
				}
				Log($"✓ Applied {num}/{proSeriesRulesSettings.Count} Pro Series rules (item weights at game defaults)");
				matchSetup.SetPreset((Preset)2);
				Log("✓ Set Preset to Custom");
				return;
			}
			Dictionary<Rule, float> rulesSettings = Season1RuleSet.GetRulesSettings();
			int num2 = 0;
			foreach (KeyValuePair<Rule, float> item2 in rulesSettings)
			{
				try
				{
					matchSetup.SetValue(item2.Key, item2.Value);
					SliderOption value4;
					if (matchSetup.onOffDropdownLookup.TryGetValue(item2.Key, out var value3))
					{
						value3.SetValue((!matchSetup.GetValueAsBoolInternal(item2.Key)) ? 1 : 0);
					}
					else if (matchSetup.sliderLookup.TryGetValue(item2.Key, out value4))
					{
						value4.SetValue(matchSetup.GetValueInternal(item2.Key));
					}
					matchSetup.UpdateRule(item2.Key);
					if ((int)item2.Key == 11)
					{
						matchSetup.CheckAndShowCheatsWarning();
					}
					Log($"  ✓ Set {item2.Key} = {item2.Value}");
					num2++;
				}
				catch (Exception ex2)
				{
					LogError($"  ✗ Failed to set {item2.Key}: {ex2.Message}");
				}
			}
			Log($"✓ Applied {num2}/{rulesSettings.Count} rules");
			Dictionary<ItemPoolId, float> itemSpawnWeights = Season1RuleSet.GetItemSpawnWeights();
			foreach (KeyValuePair<ItemPoolId, float> item3 in itemSpawnWeights)
			{
				matchSetup.SetSpawnChance(item3.Key.itemPoolIndex, item3.Key.itemType, item3.Value);
			}
			HashSet<int> hashSet = new HashSet<int>();
			foreach (ItemPoolId key in itemSpawnWeights.Keys)
			{
				if (hashSet.Add(key.itemPoolIndex))
				{
					matchSetup.ServerUpdateSpawnChanceValue(key);
				}
			}
			Log($"✓ Applied Season 1 item weights for {hashSet.Count} pools ({itemSpawnWeights.Count} entries)");
			matchSetup.SetPreset((Preset)2);
			Log("✓ Set Preset to Custom");
		}

		public static void ApplyCourseSelection(MatchSetupMenu menu)
		{
			string @string = PlayerPrefs.GetString("HostRuleset", "ranked");
			bool flag = @string == "pro_series";
			bool flag2 = @string == "casual";
			if (flag)
			{
				Log("  Pro Series: skipping course selection (maps set manually)");
				return;
			}
			if (flag2)
			{
				Log("  Casual: skipping course selection (maps set manually)");
				return;
			}
			List<HoleData> allHoles = GameManager.AllCourses.allHoles;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (MapPoolConfig.Course approvedCourse in MapPoolConfig.GetApprovedCourses())
			{
				hashSet.Add(approvedCourse.Name);
			}
			List<HoleData> list = new List<HoleData>();
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (HoleData item in allHoles)
			{
				if (hashSet.Contains(((Object)item).name))
				{
					list.Add(item);
					hashSet2.Add(((Object)item).name);
				}
			}
			foreach (string item2 in hashSet)
			{
				if (!hashSet2.Contains(item2))
				{
					LogError("  [UNMATCHED] Approved name '" + item2 + "' not found in allHoles — check MapPoolConfig spelling");
				}
			}
			if (list.Count == 0)
			{
				LogError("  No eligible holes found — aborting course selection");
				return;
			}
			MatchSetupMenu.CustomCourseData.OverrideHoles(list.ToArray());
			menu.SetCourse(-1, false);
			menu.NetworkrandomEnabled = true;
			menu.courseRandomToggle.isOn = true;
			menu.NetworkrandomCupNumHoles = 18;
			menu.numberOfHolesSlider.value = 18f;
			Log($"  ✓ Set {list.Count} eligible holes, random order ON, 18 holes");
		}
	}
}
namespace SBGL.UnifiedMod.Features
{
	public class PseudoDedicatedServer : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ClaimThenAccept>d__19 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SBGLPlugin plugin;

			public PseudoDedicatedServer <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = plugin.ClaimHostRoleCoroutine();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (plugin.CurrentSession != null && plugin.CurrentSession.status == "pending_accept" && !<>4__this._hasAcceptedThisCycle && !plugin.HasAccepted)
					{
						<>4__this._hasAcceptedThisCycle = true;
						<>4__this.Log("[PDS] Claimed host — auto-accepting match...");
						<>2__current = plugin.AcceptMatchCoroutine();
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <TryAutoQueueAfterDelay>d__20 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float delay;

			public PseudoDedicatedServer <>4__this;

			private SBGLPlugin <plugin>5__1;

			private float <waited>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!<>4__this.IsEnabled() || !<>4__this._inMainMenu || <>4__this._hasQueuedThisCycle)
					{
						return false;
					}
					<plugin>5__1 = <>4__this.GetMatchmakingPlugin();
					if ((Object)(object)<plugin>5__1 == (Object)null)
					{
						<>4__this.Log("[PDS] SBGLPlugin not found — cannot auto-queue.");
						return false;
					}
					if (<plugin>5__1.IsQueueing || <plugin>5__1.CurrentSession != null)
					{
						<>4__this.Log("[PDS] Already queuing or in session — skipping auto-queue.");
						<>4__this._hasQueuedThisCycle = true;
						return false;
					}
					if (<plugin>5__1.UserProfile != null)
					{
						break;
					}
					<>4__this.Log("[PDS] Profile not yet resolved — waiting up to 15s...");
					<waited>5__2 = 0f;
					goto IL_015e;
				case 2:
					{
						<>1__state = -1;
						<waited>5__2 += 1f;
						goto IL_015e;
					}
					IL_015e:
					if (<plugin>5__1.UserProfile == null && <waited>5__2 < 15f)
					{
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 2;
						return true;
					}
					if (<plugin>5__1.UserProfile == null)
					{
						<>4__this.Log("[PDS] Profile still unresolved — aborting auto-queue.");
						return false;
					}
					break;
				}
				<>4__this._hasQueuedThisCycle = true;
				<>4__this.Log("[PDS] Auto-joining queue...");
				((MonoBehaviour)<>4__this).StartCoroutine(<plugin>5__1.MatchmakingLoopCoroutine());
				return false;
			}

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

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

		private ConfigEntry<bool> _enabled;

		private ConfigEntry<float> _requeueDelay;

		private ConfigEntry<string> _defaultRuleset;

		private ManualLogSource _logger;

		private bool _inMainMenu = false;

		private bool _inDrivingRange = false;

		private bool _hasQueuedThisCycle = false;

		private bool _hasClaimedHostRole = false;

		private bool _hasAcceptedThisCycle = false;

		private bool _hasHostedThisCycle = false;

		private bool _waitingToReturnToMenu = false;

		private float _returnToMenuAt = 0f;

		private SBGLPlugin _matchmakingPlugin;

		public void SetConfig(ConfigEntry<bool> enabled, ConfigEntry<float> requeueDelay, ConfigEntry<string> defaultRuleset, ManualLogSource logger)
		{
			_enabled = enabled;
			_requeueDelay = requeueDelay;
			_defaultRuleset = defaultRuleset;
			_logger = logger;
		}

		private void Awake()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
			Log("[PDS] Pseudo Dedicated Server component loaded.");
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			string text = ((Scene)(ref scene)).name.ToLower();
			_inMainMenu = text.Contains("menu");
			_inDrivingRange = text.Contains("drivingrange") || text.Contains("driving range");
			if (!IsEnabled())
			{
				return;
			}
			if (_inMainMenu)
			{
				Log("[PDS] Entered main menu — resetting cycle state.");
				_hasQueuedThisCycle = false;
				_hasClaimedHostRole = false;
				_hasAcceptedThisCycle = false;
				_hasHostedThisCycle = false;
				_waitingToReturnToMenu = false;
				((MonoBehaviour)this).StartCoroutine(TryAutoQueueAfterDelay(2.5f));
			}
			else if (_inDrivingRange)
			{
				Log("[PDS] Entered driving range.");
				if (!_waitingToReturnToMenu)
				{
					_waitingToReturnToMenu = true;
					float num = _requeueDelay?.Value ?? 10f;
					_returnToMenuAt = Time.time + num;
					Log($"[PDS] Will return to main menu in {num}s to requeue.");
				}
			}
			else
			{
				_waitingToReturnToMenu = false;
			}
		}

		private void Update()
		{
			if (IsEnabled())
			{
				if (_inDrivingRange && _waitingToReturnToMenu && Time.time >= _returnToMenuAt)
				{
					_waitingToReturnToMenu = false;
					Log("[PDS] Requeue delay elapsed — returning to main menu.");
					ReturnToMainMenu();
				}
				else if (_inMainMenu)
				{
					PollSessionActions();
				}
			}
		}

		private void PollSessionActions()
		{
			SBGLPlugin matchmakingPlugin = GetMatchmakingPlugin();
			if ((Object)(object)matchmakingPlugin == (Object)null)
			{
				return;
			}
			SBGLPlugin.MatchmakingSession currentSession = matchmakingPlugin.CurrentSession;
			if (currentSession == null)
			{
				return;
			}
			if (!_hasClaimedHostRole && !matchmakingPlugin.IsHost && (currentSession.status == "pending_accept" || currentSession.status == "ready"))
			{
				_hasClaimedHostRole = true;
				Log("[PDS] Claiming host role (PATCHing host_player_id)...");
				((MonoBehaviour)this).StartCoroutine(ClaimThenAccept(matchmakingPlugin));
				return;
			}
			if (_hasClaimedHostRole && !_hasAcceptedThisCycle && !matchmakingPlugin.HasAccepted && currentSession.status == "pending_accept")
			{
				_hasAcceptedThisCycle = true;
				Log("[PDS] Auto-accepting match...");
				((MonoBehaviour)this).StartCoroutine(matchmakingPlugin.AcceptMatchCoroutine());
			}
			if (currentSession.status == "ready" && matchmakingPlugin.IsHost && matchmakingPlugin.HasAccepted && !_hasHostedThisCycle)
			{
				_hasHostedThisCycle = true;
				Log("[PDS] Auto-initializing host lobby (ruleset: " + GetRuleset() + ")...");
				PlayerPrefs.SetString("HostRuleset", GetRuleset());
				PlayerPrefs.Save();
				matchmakingPlugin.InitiateHostSequencePublic();
			}
		}

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

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

		private void ReturnToMainMenu()
		{
			Log("[PDS] Loading MainMenu scene...");
			try
			{
				SceneManager.LoadScene("MainMenu");
			}
			catch (Exception ex)
			{
				Log("[PDS] LoadScene('MainMenu') failed (" + ex.Message + ") — trying scene index 0.");
				try
				{
					SceneManager.LoadScene(0);
				}
				catch (Exception ex2)
				{
					Log("[PDS] Fallback LoadScene(0) also failed: " + ex2.Message);
				}
			}
		}

		private bool IsEnabled()
		{
			return _enabled?.Value ?? false;
		}

		private string GetRuleset()
		{
			return _defaultRuleset?.Value ?? "ranked";
		}

		private SBGLPlugin GetMatchmakingPlugin()
		{
			if ((Object)(object)_matchmakingPlugin != (Object)null)
			{
				return _matchmakingPlugin;
			}
			_matchmakingPlugin = Object.FindAnyObjectByType<SBGLPlugin>();
			return _matchmakingPlugin;
		}

		private void Log(string msg)
		{
			if (_logger != null)
			{
				_logger.LogInfo((object)msg);
			}
			else
			{
				Debug.Log((object)msg);
			}
		}
	}
	public class RuleSetDisplayManager : MonoBehaviour
	{
		private ConfigEntry<float> _posX;

		private ConfigEntry<float> _posY;

		private ConfigEntry<bool> _showDetails;

		private ConfigEntry<bool> _applyRulesets;

		private GUIStyle _labelStyle;

		private GUIStyle _smallBtnStyle;

		private GUIStyle _tooltipStyle;

		private Texture2D _bgTexture;

		private Texture2D _tooltipBgTexture;

		private string _tooltipRanked = null;

		private string _tooltipPro = null;

		private string _tooltipCasual = null;

		private string _noRulesetTooltip = "<b>Applies Classic preset only.</b>\n<color=#AAFFAA>No Season 1 rules or item bans enforced.</color>";

		private string _lastSceneName = string.Empty;

		private bool _defaultAppliedForScene = false;

		public void SetConfig(ConfigEntry<float> posX, ConfigEntry<float> posY, ConfigEntry<bool> showDetails, ConfigEntry<bool> applyRulesets = null)
		{
			_posX = posX;
			_posY = posY;
			_showDetails = showDetails;
			_applyRulesets = applyRulesets;
		}

		public void Awake()
		{
			Debug.Log((object)"[RuleSetDisplayManager] Awake - Feature loaded");
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			string text = ((Scene)(ref scene)).name.ToLower();
			if (text.Contains("menu"))
			{
				PlayerPrefs.SetString("HostRuleset", "ranked");
				PlayerPrefs.SetString("MatchType", "ranked_season_1");
				PlayerPrefs.SetInt("Season", 1);
				PlayerPrefs.Save();
				Debug.Log((object)"[RuleSetDisplayManager] Returned to main menu — ruleset reset to ranked");
			}
		}

		public void OnGUI()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				string text = ((Scene)(ref activeScene)).name.ToLower();
				if (!string.Equals(text, _lastSceneName, StringComparison.Ordinal))
				{
					_lastSceneName = text;
					_defaultAppliedForScene = false;
				}
				if ((text.Contains("drivingrange") || text.Contains("driving range")) && NetworkServer.active)
				{
					EnsureDefaultRankedForScene();
					RenderPanel();
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[RuleSetDisplayManager] OnGUI error: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void EnsureDefaultRankedForScene()
		{
			if (!_defaultAppliedForScene)
			{
				_defaultAppliedForScene = true;
				PlayerPrefs.SetString("HostRuleset", "ranked");
				PlayerPrefs.SetString("MatchType", "ranked_season_1");
				PlayerPrefs.SetInt("Season", 1);
				string @string = PlayerPrefs.GetString("SelectedCourse", "");
				if (string.IsNullOrWhiteSpace(@string))
				{
					MapPoolConfig.Course randomApprovedCourse = MapPoolConfig.GetRandomApprovedCourse();
					PlayerPrefs.SetString("SelectedCourse", randomApprovedCourse.Name);
				}
				PlayerPrefs.Save();
				Debug.Log((object)"[RuleSetDisplayManager] Defaulted ruleset to ranked for this driving-range session");
			}
		}

		private void RenderPanel()
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0027: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			//IL_01b8: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Expected O, but got Unknown
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Expected O, but got Unknown
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Expected O, but got Unknown
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Expected O, but got Unknown
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0515: Unknown result type (might be due to invalid IL or missing references)
			//IL_0562: Unknown result type (might be due to invalid IL or missing references)
			//IL_055b: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c8: Invalid comparison between Unknown and I4
			//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05de: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_077c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_081e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0617: Unknown result type (might be due to invalid IL or missing references)
			//IL_0630: Unknown result type (might be due to invalid IL or missing references)
			//IL_0662: Unknown result type (might be due to invalid IL or missing references)
			//IL_0669: Expected O, but got Unknown
			//IL_067a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0689: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ab: 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_06d0: Unknown result type (might be due to invalid IL or missing references)
			if (_labelStyle == null)
			{
				GUISkin skin = GUI.skin;
				_labelStyle = new GUIStyle((GUIStyle)(((object)((skin != null) ? skin.label : null)) ?? ((object)new GUIStyle())))
				{
					alignment = (TextAnchor)3,
					fontSize = 14,
					fontStyle = (FontStyle)1,
					richText = true
				};
			}
			if (_smallBtnStyle == null)
			{
				GUISkin skin2 = GUI.skin;
				_smallBtnStyle = new GUIStyle((GUIStyle)(((object)((skin2 != null) ? skin2.button : null)) ?? ((object)new GUIStyle())))
				{
					fontSize = 10,
					fontStyle = (FontStyle)1,
					richText = true
				};
			}
			if ((Object)(object)_bgTexture == (Object)null)
			{
				_bgTexture = new Texture2D(1, 1);
				_bgTexture.SetPixel(0, 0, new Color(0.1f, 0.1f, 0.1f, 0.8f));
				_bgTexture.Apply();
			}
			if ((Object)(object)_tooltipBgTexture == (Object)null)
			{
				_tooltipBgTexture = new Texture2D(1, 1);
				_tooltipBgTexture.SetPixel(0, 0, new Color(0.05f, 0.05f, 0.05f, 0.95f));
				_tooltipBgTexture.Apply();
			}
			if (_tooltipStyle == null)
			{
				GUISkin skin3 = GUI.skin;
				_tooltipStyle = new GUIStyle((GUIStyle)(((object)((skin3 != null) ? skin3.box : null)) ?? ((object)new GUIStyle())))
				{
					alignment = (TextAnchor)0,
					fontSize = 14,
					wordWrap = true,
					richText = true,
					padding = new RectOffset(8, 8, 6, 6)
				};
				_tooltipStyle.normal.background = _tooltipBgTexture;
				_tooltipStyle.normal.textColor = Color.white;
			}
			bool flag = _showDetails?.Value ?? false;
			ConfigEntry<bool> applyRulesets = _applyRulesets;
			string text = ((applyRulesets == null || applyRulesets.Value) ? PlayerPrefs.GetString("HostRuleset", "ranked") : "none");
			float num = 450f;
			float num2 = 40f;
			float num3 = (flag ? 110f : 0f);
			float num4 = 30f + num2 + num3 + 10f;
			float num5 = _posX?.Value ?? (-1f);
			float num6 = ((num5 < 0f) ? ((float)Screen.width - num - 20f) : num5);
			float num7 = _posY?.Value ?? 20f;
			GUI.DrawTexture(new Rect(num6, num7, num, num4), (Texture)(object)_bgTexture);
			GUI.Box(new Rect(num6, num7, num, num4), "<b>APPLY RULESET</b>");
			float num8 = num7 + 28f;
			float num9 = (num - 50f) / 4f;
			float num10 = num6 + 10f;
			float num11 = num10 + num9 + 10f;
			float num12 = num11 + num9 + 10f;
			float num13 = num12 + num9 + 10f;
			if (_tooltipRanked == null)
			{
				int count = MapPoolConfig.GetApprovedCourses().Count;
				_tooltipRanked = Season1RuleSet.BuildRulesDescription(Season1RuleSet.GetRulesSettings()) + "\n<b>Banned Items:</b> <color=#AAFFAA>" + Season1RuleSet.BuildBannedItemsDescription() + "</color>" + $"\n<b>Courses:</b> <color=#AAFFAA>Random ({count} approved)</color>";
			}
			if (_tooltipPro == null)
			{
				_tooltipPro = Season1RuleSet.BuildRulesDescription(Season1RuleSet.GetProSeriesRulesSettings()) + "\n<b>Items:</b> <color=#AAFFAA>Game defaults (all enabled)</color>\n<b>Courses:</b> <color=#AAFFAA>Manual selection</color>";
			}
			if (_tooltipCasual == null)
			{
				_tooltipCasual = "<b>Applies Classic preset only.</b>\n<b>Items:</b> <color=#AAFFAA>Game defaults (all enabled)</color>\n<b>Courses:</b> <color=#AAFFAA>Manual selection</color>\n<color=#FFFFAA>No MMR impact. Only casual matches played is tracked.</color>";
			}
			GUIContent val = new GUIContent("<b>RANKED</b>");
			GUIContent val2 = new GUIContent("<b>PRO SERIES</b>");
			GUIContent val3 = new GUIContent("<b>CASUAL</b>");
			GUIContent val4 = new GUIContent("<b>NO RULESET</b>");
			Rect val5 = default(Rect);
			((Rect)(ref val5))..ctor(num10, num8, num9, num2);
			Rect val6 = default(Rect);
			((Rect)(ref val6))..ctor(num11, num8, num9, num2);
			Rect val7 = default(Rect);
			((Rect)(ref val7))..ctor(num12, num8, num9, num2);
			Rect val8 = default(Rect);
			((Rect)(ref val8))..ctor(num13, num8, num9, num2);
			GUI.backgroundColor = ((text == "ranked") ? Color.green : Color.grey);
			if (GUI.Button(val5, val))
			{
				if (_applyRulesets != null)
				{
					_applyRulesets.Value = true;
				}
				ApplyRuleset("ranked");
			}
			GUI.backgroundColor = ((text == "pro_series") ? Color.magenta : Color.grey);
			if (GUI.Button(val6, val2))
			{
				if (_applyRulesets != null)
				{
					_applyRulesets.Value = true;
				}
				ApplyRuleset("pro_series");
			}
			GUI.backgroundColor = (Color)((text == "casual") ? new Color(0.2f, 0.75f, 1f) : Color.grey);
			if (GUI.Button(val7, val3))
			{
				if (_applyRulesets != null)
				{
					_applyRulesets.Value = true;
				}
				ApplyRuleset("casual");
			}
			GUI.backgroundColor = ((text == "none") ? Color.yellow : Color.grey);
			if (GUI.Button(val8, val4, _smallBtnStyle))
			{
				if (_applyRulesets != null)
				{
					_applyRulesets.Value = false;
				}
				ResetToClassicPreset();
				Debug.Log((object)"[RuleSetDisplayManager] Ruleset enforcement disabled via No Ruleset button");
			}
			GUI.backgroundColor = Color.white;
			if ((int)Event.current.type == 7)
			{
				Vector2 mousePosition = Event.current.mousePosition;
				string text2 = null;
				if (((Rect)(ref val5)).Contains(mousePosition))
				{
					text2 = _tooltipRanked;
				}
				else if (((Rect)(ref val6)).Contains(mousePosition))
				{
					text2 = _tooltipPro;
				}
				else if (((Rect)(ref val7)).Contains(mousePosition))
				{
					text2 = _tooltipCasual;
				}
				else if (((Rect)(ref val8)).Contains(mousePosition))
				{
					text2 = _noRulesetTooltip;
				}
				if (!string.IsNullOrEmpty(text2))
				{
					float num14 = 280f;
					GUIContent val9 = new GUIContent(text2);
					float num15 = _tooltipStyle.CalcHeight(val9, num14);
					float num16 = mousePosition.x + 14f;
					float num17 = mousePosition.y + 14f;
					if (num16 + num14 > (float)Screen.width)
					{
						num16 = mousePosition.x - num14 - 6f;
					}
					if (num17 + num15 > (float)Screen.height)
					{
						num17 = mousePosition.y - num15 - 6f;
					}
					GUI.Box(new Rect(num16, num17, num14, num15), val9, _tooltipStyle);
				}
			}
			if (flag)
			{
				string @string = PlayerPrefs.GetString("MatchType", "—");
				string string2 = PlayerPrefs.GetString("SelectedCourse", "—");
				int @int = PlayerPrefs.GetInt("Season", 0);
				string string3 = PlayerPrefs.GetString("HostRuleset", "—");
				float num18 = num6 + 10f;
				float num19 = num8 + num2 + 8f;
				float num20 = 20f;
				float num21 = 22f;
				GUI.Label(new Rect(num18, num19, num - 20f, num20), "<color=#00FF00>Type: " + @string + "</color>", _labelStyle);
				GUI.Label(new Rect(num18, num19 + num21, num - 20f, num20), "<color=#00FF00>Course: " + string2 + "</color>", _labelStyle);
				GUI.Label(new Rect(num18, num19 + num21 * 2f, num - 20f, num20), $"<color=#00FF00>Season: {@int}</color>", _labelStyle);
				GUI.Label(new Rect(num18, num19 + num21 * 3f, num - 20f, num20), "<color=#00FF00>Ruleset: " + string3 + "</color>", _labelStyle);
			}
		}

		private void ApplyRuleset(string rulesetName)
		{
			Debug.Log((object)("[RuleSetDisplayManager] Applying ruleset: " + rulesetName));
			PlayerPrefs.SetString("HostRuleset", rulesetName);
			int num = 1;
			switch (rulesetName)
			{
			case "ranked":
				PlayerPrefs.SetString("MatchType", "ranked_season_1");
				break;
			case "pro_series":
				PlayerPrefs.SetString("MatchType", "pro_series_season_1");
				break;
			case "casual":
				PlayerPrefs.SetString("MatchType", "casual");
				num = 0;
				break;
			}
			PlayerPrefs.SetInt("Season", num);
			if (rulesetName == "ranked")
			{
				MapPoolConfig.Course randomApprovedCourse = MapPoolConfig.GetRandomApprovedCourse();
				PlayerPrefs.SetString("SelectedCourse", randomApprovedCourse.Name);
				PlayerPrefs.Save();
				Debug.Log((object)$"[RuleSetDisplayManager] ✓ Ruleset {rulesetName} applied. Season={num}, Course={randomApprovedCourse.Name}. Stored in PlayerPrefs");
			}
			else
			{
				PlayerPrefs.Save();
				Debug.Log((object)$"[RuleSetDisplayManager] ✓ Ruleset {rulesetName} applied. Season={num}. Course preserved (manual selection mode). Stored in PlayerPrefs");
			}
			ApplyRulesToExistingMatchSetupRules();
		}

		private void ApplyRulesToExistingMatchSetupRules()
		{
			try
			{
				MatchSetupMenu val = Object.FindAnyObjectByType<MatchSetupMenu>();
				if ((Object)(object)val == (Object)null || !((NetworkBehaviour)val).isServer)
				{
					Debug.Log((object)"[RuleSetDisplayManager] Match setup menu not open - rules will be applied automatically when it opens");
					return;
				}
				MatchSetupRules rules = val.rules;
				if ((Object)(object)rules == (Object)null)
				{
					Debug.Log((object)"[RuleSetDisplayManager] MatchSetupMenu.rules is null");
					return;
				}
				Debug.Log((object)"[RuleSetDisplayManager] ✓ Match setup menu is open - applying rules NOW");
				RulePatches.ApplyRulesToMatchSetup(rules);
				RulePatches.ApplyCourseSelection(val);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[RuleSetDisplayManager] Error applying rules: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void ResetToClassicPreset()
		{
			try
			{
				MatchSetupMenu val = Object.FindAnyObjectByType<MatchSetupMenu>();
				if (!((Object)(object)val == (Object)null) && ((NetworkBehaviour)val).isServer)
				{
					MatchSetupRules rules = val.rules;
					if (!((Object)(object)rules == (Object)null))
					{
						rules.SetPreset((Preset)0);
						Debug.Log((object)"[RuleSetDisplayManager] ✓ Reset to Classic preset (No Ruleset)");
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[RuleSetDisplayManager] Error resetting to Classic: " + ex.Message));
			}
		}
	}
}
namespace SBGL.UnifiedMod.Features.CompetitivePluginCheck
{
	public class ProSeriesEvent
	{
		public string name;

		public string event_date;
	}
	public class MatchEntry
	{
		public string match_summary;

		public string match_date;
	}
	public class CompetitivePluginCheck : MonoBehaviour
	{
		private class PlayerComplianceStatus
		{
			public ulong SteamId { get; set; }

			public bool HasReportedMods { get; set; }

			public bool IsCompliant { get; set; }

			public bool HasMelonLoader { get; set; }

			public string ModList { get; set; }

			public float FirstSeenTime { get; set; }
		}

		private class LocalPluginScanResult
		{
			public List<string> MissingModNames { get; } = new List<string>();


			public List<string> TamperedModNames { get; } = new List<string>();


			public List<string> SuspiciousRuntimeAssemblies { get; } = new List<string>();


			public bool HasIllegalMods { get; set; }
		}

		private sealed class AllowedModsSnapshot
		{
			[CompilerGenerated]
			private sealed class <GetMissingModNames>d__13 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private string <>2__current;

				private int <>l__initialThreadId;

				private HashSet<string> installedGuids;

				public HashSet<string> <>3__installedGuids;

				public AllowedModsSnapshot <>4__this;

				private Dictionary<string, string>.Enumerator <>s__1;

				private KeyValuePair<string, string> <entry>5__2;

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

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

				[DebuggerHidden]
				public <GetMissingModNames>d__13(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || num == 1)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<>s__1 = default(Dictionary<string, string>.Enumerator);
					<entry>5__2 = default(KeyValuePair<string, string>);
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<>s__1 = <>4__this._displayNamesByGuid.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							<entry>5__2 = default(KeyValuePair<string, string>);
							break;
						}
						while (<>s__1.MoveNext())
						{
							<entry>5__2 = <>s__1.Current;
							if (ShouldIgnorePluginGuid(<entry>5__2.Key) || installedGuids.Contains(<entry>5__2.Key))
							{
								continue;
							}
							<>2__current = <entry>5__2.Value;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>s__1 = default(Dictionary<string, string>.Enumerator);
						return false;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

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

				private void <>m__Finally1()
				{
					<>1__state = -1;
					((IDisposable)<>s__1).Dispose();
				}

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

				[DebuggerHidden]
				IEnumerator<string> IEnumerable<string>.GetEnumerator()
				{
					<GetMissingModNames>d__13 <GetMissingModNames>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<GetMissingModNames>d__ = this;
					}
					else
					{
						<GetMissingModNames>d__ = new <GetMissingModNames>d__13(0)
						{
							<>4__this = <>4__this
						};
					}
					<GetMissingModNames>d__.installedGuids = <>3__installedGuids;
					return <GetMissingModNames>d__;
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<string>)this).GetEnumerator();
				}
			}

			public static readonly AllowedModsSnapshot Empty = new AllowedModsSnapshot(new HashSet<string>(StringComparer.OrdinalIgnoreCase), new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase), null);

			private readonly HashSet<string> _allowedGuids;

			private readonly Dictionary<string, string> _displayNamesByGuid;

			private readonly Dictionary<string, HashSet<string>> _allowedHashesByGuid;

			public int Count => _displayNamesByGuid.Count;

			public bool HasHashConstraints => _allowedHashesByGuid != null;

			public IEnumerable<string> DisplayNames => _displayNamesByGuid.Values;

			private AllowedModsSnapshot(HashSet<string> allowedGuids, Dictionary<string, string> displayNamesByGuid, Dictionary<string, HashSet<string>> allowedHashesByGuid)
			{
				_allowedGuids = allowedGuids;
				_displayNamesByGuid = displayNamesByGuid;
				_allowedHashesByGuid = allowedHashesByGuid;
			}

			public bool ContainsGuid(string guid)
			{
				return !string.IsNullOrWhiteSpace(guid) && _allowedGuids.Contains(guid);
			}

			public HashSet<string> GetAllowedHashes(string guid)
			{
				if (_allowedHashesByGuid == null || string.IsNullOrWhiteSpace(guid))
				{
					return null;
				}
				_allowedHashesByGuid.TryGetValue(guid, out var value);
				return value;
			}

			[IteratorStateMachine(typeof(<GetMissingModNames>d__13))]
			public IEnumerable<string> GetMissingModNames(HashSet<string> installedGuids)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <GetMissingModNames>d__13(-2)
				{
					<>4__this = this,
					<>3__installedGuids = installedGuids
				};
			}

			public static AllowedModsSnapshot FromJson(string json)
			{
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
				Dictionary<string, HashSet<string>> dictionary2 = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);
				try
				{
					JObject val = JObject.Parse(json);
					JToken obj = val["mods"];
					JArray val2 = (JArray)(object)((obj is JArray) ? obj : null);
					if (val2 == null)
					{
						return Empty;
					}
					foreach (JToken item in val2)
					{
						JToken obj2 = item[(object)"guid"];
						string text = ((obj2 != null) ? Extensions.Value<string>((IEnumerable<JToken>)obj2) : null);
						JToken obj3 = item[(object)"name"];
						string text2 = ((obj3 != null) ? Extensions.Value<string>((IEnumerable<JToken>)obj3) : null);
						if (string.IsNullOrWhiteSpace(text))
						{
							continue;
						}
						hashSet.Add(text);
						dictionary[text] = (string.IsNullOrWhiteSpace(text2) ? text : text2);
						JToken obj4 = item[(object)"assemblies"];
						JArray val3 = (JArray)(object)((obj4 is JArray) ? obj4 : null);
						if (val3 == null || ((JContainer)val3).Count <= 0)
						{
							continue;
						}
						HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
						foreach (JToken item2 in val3)
						{
							JToken obj5 = item2[(object)"sha256"];
							string text3 = ((obj5 != null) ? Extensions.Value<string>((IEnumerable<JToken>)obj5) : null);
							if (!string.IsNullOrWhiteSpace(text3))
							{
								hashSet2.Add(text3);
							}
						}
						if (hashSet2.Count > 0)
						{
							dictionary2[text] = hashSet2;
						}
					}
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)("[CompCheck] Failed to parse approved mods JSON manifest: " + ex.Message));
					return Empty;
				}
				return new AllowedModsSnapshot(hashSet, dictionary, dictionary2);
			}

			public static AllowedModsSnapshot FromText(string rawText)
			{
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
				string[] array = rawText.Split('\n');
				foreach (string text in array)
				{
					if (string.IsNullOrWhiteSpace(text))
					{
						continue;
					}
					string text2;
					string text3;
					if (text.Contains("|"))
					{
						string[] array2 = text.Split('|');
						if (array2.Length < 2)
						{
							continue;
						}
						text2 = array2[0].Trim();
						text3 = array2[1].Trim();
					}
					else
					{
						text3 = text.Trim();
						text2 = text3;
					}
					if (!string.IsNullOrWhiteSpace(text3))
					{
						hashSet.Add(text3);
						dictionary[text3] = (string.IsNullOrWhiteSpace(text2) ? text3 : text2);
					}
				}
				return new AllowedModsSnapshot(hashSet, dictionary, null);
			}

			public static AllowedModsSnapshot Parse(string rawText)
			{
				if (string.IsNullOrWhiteSpace(rawText))
				{
					return Empty;
				}
				string text = rawText.TrimStart();
				return text.StartsWith("{") ? FromJson(text) : FromText(rawText);
			}
		}

		private sealed class KnownVisibleRuntimeAssemblies
		{
			public HashSet<string> ExactAssemblyPaths { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);


			public HashSet<string> AllowedCompanionAssemblyNames { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		}

		[CompilerGenerated]
		private sealed class <AutoUpdateLoop>d__145 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CompetitivePluginCheck <>4__this;

			private float <waitTimeout>5__1;

			private SharedPlayerProfile <profile>5__2;

			private float <timer>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0175: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Expected O, but got Unknown
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<waitTimeout>5__1 = 0f;
					goto IL_0078;
				case 1:
					<>1__state = -1;
					<waitTimeout>5__1 += 0.5f;
					goto IL_0078;
				case 2:
					<>1__state = -1;
					<timer>5__3 = <>4__this._configUpdateInterval.Value * 60f;
					goto IL_01a2;
				case 3:
					{
						<>1__state = -1;
						<timer>5__3 -= 1f;
						goto IL_01a2;
					}
					IL_01a2:
					if (<timer>5__3 > 0f)
					{
						<>4__this._timeUntilNextUpdate = <timer>5__3;
						<>4__this.UpdateUIReport();
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 3;
						return true;
					}
					break;
					IL_0078:
					if (!UnifiedPlugin.IsPlayerProfileResolved() && <waitTimeout>5__1 < 12f)
					{
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 1;
						return true;
					}
					if (UnifiedPlugin.IsPlayerProfileResolved())
					{
						<profile>5__2 = UnifiedPlugin.GetPlayerProfile();
						Debug.Log((object)("[CompetitivePluginCheck] Profile now resolved: " + <profile>5__2.DisplayName + " (ID: " + <profile>5__2.ID + ")"));
						<profile>5__2 = null;
					}
					break;
				}
				<>2__current = <>4__this.TriggerFullSync(<>4__this.ConfigPlayerId?.Trim());
				<>1__state = 2;
				return true;
			}

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

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

		[CompilerGenerated]
		private sealed class <CheckPluginsRoutine>d__154 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CompetitivePluginCheck <>4__this;

			private string <url>5__1;

			private UnityWebRequest <w>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<url>5__1 = null;
				<w>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<url>5__1 = "https://gist.githubusercontent.com/Kingcox22/59765f02af8dd87179ca920409ff3b27/raw/Approved_Mods.json?t=" + DateTime.Now.Ticks;
						<w>5__2 = UnityWebRequest.Get(<url>5__1);
						<>1__state = -3;
						<>2__current = <w>5__2.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<w>5__2.result == 1)
						{
							<>4__this._allowedModsSnapshot = AllowedModsSnapshot.Parse(<w>5__2.downloadHandler.text);
						}
						<>m__Finally1();
						<w>5__2 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<w>5__2 != null)
				{
					((IDisposable)<w>5__2).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <DownloadProfilePic>d__153 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string url;

			public CompetitivePluginCheck <>4__this;

			private UnityWebRequest <request>5__1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<request>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (string.IsNullOrEmpty(url))
						{
							return false;
						}
						if (url.StartsWith("http://"))
						{
							url = url.Replace("http://", "https://");
						}
						<request>5__1 = UnityWebRequestTexture.GetTexture(url);
						<>1__state = -3;
						<>2__current = <request>5__1.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<request>5__1.result == 1)
						{
							<>4__this._profileIcon.texture = (Texture)(object)DownloadHandlerTexture.GetContent(<request>5__1);
							<>4__this._profilePicContainer.SetActive(true);
						}
						<>m__Finally1();
						<request>5__1 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<request>5__1 != null)
				{
					((IDisposable)<request>5__1).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <FetchEvents>d__148 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CompetitivePluginCheck <>4__this;

			private string <appId>5__1;

			private string <authToken>5__2;

			private string <url>5__3;

			private UnityWebRequest <r>5__4;

			private JArray <ja>5__5;

			private DateTime <today>5__6;

			private IEnumerator<JToken> <>s__7;

			private JToken <item>5__8;

			private string <dateStr>5__9;

			private DateTime <dt>5__10;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<appId>5__1 = null;
				<authToken>5__2 = null;
				<url>5__3 = null;
				<r>5__4 = null;
				<ja>5__5 = null;
				<>s__7 = null;
				<item>5__8 = null;
				<dateStr>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<appId>5__1 = UnifiedPlugin.GetCurrentAppId();
						<authToken>5__2 = UnifiedPlugin.GetCurrentAuthToken();
						<url>5__3 = "https://sbgleague.com/api/apps/" + <appId>5__1 + "/entities/ProSeriesEvent?sort=event_date&limit=50";
						<r>5__4 = UnityWebRequest.Get(<url>5__3);
						<>1__state = -3;
						<r>5__4.SetRequestHeader("X-App-Id", <appId>5__1);
						<r>5__4.SetRequestHeader("api_key", <authToken>5__2);
						<r>5__4.certificateHandler = (CertificateHandler)(object)new BypassCertificate();
						<>2__current = <r>5__4.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<r>5__4.result == 1)
						{
							try
							{
								<ja>5__5 = JArray.Parse(<r>5__4.downloadHandler.text);
								<>4__this._upcomingEvents.Clear();
								<today>5__6 = DateTime.Now.Date;
								<>s__7 = <ja>5__5.GetEnumerator();
								try
								{
									while (<>s__7.MoveNext())
									{
										<item>5__8 = <>s__7.Current;
										<dateStr>5__9 = ((object)<item>5__8[(object)"event_date"])?.ToString() ?? "";
										if (DateTime.TryParse(<dateStr>5__9, out <dt>5__10) && <dt>5__10.Date >= <today>5__6)
										{
											<>4__this._upcomingEvents.Add(new ProSeriesEvent
											{
												name = (((object)<item>5__8[(object)"name"])?.ToString() ?? "Tournament"),
												event_date = <dateStr>5__9
											});
											if (<>4__this._upcomingEvents.Count >= 5)
											{
												break;
											}
										}
										<dateStr>5__9 = null;
										<item>5__8 = null;
									}
								}
								finally
								{
									if (<>s__7 != null)
									{
										<>s__7.Dispose();
									}
								}
								<>s__7 = null;
								<ja>5__5 = null;
							}
							catch
							{
							}
						}
						<>m__Finally1();
						<r>5__4 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<r>5__4 != null)
				{
					((IDisposable)<r>5__4).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <FetchLeaderboardRank>d__151 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string id;

			public CompetitivePluginCheck <>4__this;

			private string <filter>5__1;

			private string <appId>5__2;

			private string <authToken>5__3;

			private string <url>5__4;

			private UnityWebRequest <r>5__5;

			private JArray <ps>5__6;

			private int <rank>5__7;

			private IEnumerator<JToken> <>s__8;

			private JToken <p>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<filter>5__1 = null;
				<appId>5__2 = null;
				<authToken>5__3 = null;
				<url>5__4 = null;
				<r>5__5 = null;
				<ps>5__6 = null;
				<>s__8 = null;
				<p>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<filter>5__1 = "%7B%22matches_played%22%3A%7B%22%24gt%22%3A0%7D%7D";
						<appId>5__2 = UnifiedPlugin.GetCurrentAppId();
						<authToken>5__3 = UnifiedPlugin.GetCurrentAuthToken();
						<url>5__4 = "https://sbgleague.com/api/apps/" + <appId>5__2 + "/entities/Player?q=" + <filter>5__1 + "&sort=-current_mmr";
						<r>5__5 = UnityWebRequest.Get(<url>5__4);
						<>1__state = -3;
						<r>5__5.SetRequestHeader("X-App-Id", <appId>5__2);
						<r>5__5.SetRequestHeader("api_key", <authToken>5__3);
						<r>5__5.certificateHandler = (CertificateHandler)(object)new BypassCertificate();
						<>2__current = <r>5__5.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<r>5__5.result == 1)
						{
							try
							{
								<ps>5__6 = JArray.Parse(<r>5__5.downloadHandler.text);
								<>4__this._totalPlayers = ((JContainer)<ps>5__6).Count.ToString();
								<rank>5__7 = 1;
								<>s__8 = <ps>5__6.GetEnumerator();
								try
								{
									while (<>s__8.MoveNext())
									{
										<p>5__9 = <>s__8.Current;
										if (((object)<p>5__9[(object)"id"])?.ToString() == id)
										{
											<>4__this._playerRank = <rank>5__7.ToString();
											break;
										}
										<rank>5__7++;
										<p>5__9 = null;
									}
								}
								finally
								{
									if (<>s__8 != null)
									{
										<>s__8.Dispose();
									}
								}
								<>s__8 = null;
								<ps>5__6 = null;
							}
							catch
							{
							}
						}
						<>m__Finally1();
						<r>5__5 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<r>5__5 != null)
				{
					((IDisposable)<r>5__5).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <FetchPlayerData>d__150 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string id;

			public CompetitivePluginCheck <>4__this;

			private string <appId>5__1;

			private string <authToken>5__2;

			private string <url>5__3;

			private UnityWebRequest <r>5__4;

			private JArray <ja>5__5;

			private JToken <p>5__6;

			private float <avg>5__7;

			private float <w>5__8;

			private float <t>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<appId>5__1 = null;
				<authToken>5__2 = null;
				<url>5__3 = null;
				<r>5__4 = null;
				<ja>5__5 = null;
				<p>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Invalid comparison between Unknown and I4
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<appId>5__1 = UnifiedPlugin.GetCurrentAppId();
						<authToken>5__2 = UnifiedPlugin.GetCurrentAuthToken();
						<url>5__3 = "https://sbgleague.com/api/apps/" + <appId>5__1 + "/entities/Player?q=" + UnityWebRequest.EscapeURL("{\"id\":\"" + id + "\"}");
						<r>5__4 = UnityWebRequest.Get(<url>5__3);
						<>1__state = -3;
						<r>5__4.SetRequestHeader("X-App-Id", <appId>5__1);
						<r>5__4.SetRequestHeader("api_key", <authToken>5__2);
						<r>5__4.certificateHandler = (CertificateHandler)(object)new BypassCertificate();
						<>2__current = <r>5__4.SendWebRequest();
						<>1__state = 1;
						result = true;
						break;
					case 1:
						{
							<>1__state = -3;
							if ((int)<r>5__4.result == 1)
							{
								try
								{
									<ja>5__5 = JArray.Parse(<r>5__4.downloadHandler.text);
									if (((JContainer)<ja>5__5).Count != 0)
									{
										<p>5__6 = <ja>5__5[0];
										<>4__this._activeUsername = ((object)<p>5__6[(object)"display_name"])?.ToString() ?? "Player";
										<>4__this._playerMMR = ((object)<p>5__6[(object)"current_mmr"])?.ToString() ?? "0";
										<>4__this._playerPeak = ((object)<p>5__6[(object)"highest_mmr_ever"])?.ToString() ?? "0";
										<>4__this._matches = ((object)<p>5__6[(object)"matches_played"])?.ToString() ?? "0";
										<>4__this._lastChange = ((object)<p>5__6[(object)"latest_mmr_change"])?.ToString() ?? "0";
										<>4__this._top3s = ((object)<p>5__6[(object)"top_3_finishes"])?.ToString() ?? "0";
										float.TryParse(((object)<p>5__6[(object)"average_score_vs_par"])?.ToString() ?? "0", out <avg>5__7);
										<>4__this._avgScore = <avg>5__7.ToString("F1");
										<w>5__8 = 0f;
										<t>5__9 = 0f;
										float.TryParse(((object)<p>5__6[(object)"wins"])?.ToString(), out <w>5__8);
										float.TryParse(((object)<p>5__6[(object)"matches_played"])?.ToString(), out <t>5__9);
										<>4__this._winRate = ((<t>5__9 > 0f) ? $"{<w>5__8 / <t>5__9 * 100f:F0}%" : "0%");
										if (<p>5__6[(object)"profile_pic_url"] != null && !string.IsNullOrEmpty(((object)<p>5__6[(object)"profile_pic_url"]).ToString()))
										{
											((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.DownloadProfilePic(((object)<p>5__6[(object)"profile_pic_url"]).ToString()));
										}
										<ja>5__5 = null;
										<p>5__6 = null;
										goto IL_0416;
									}
									<>4__this.ResetPlayerData("Invalid ID");
									result = false;
								}
								catch
								{
									<>4__this.ResetPlayerData("Data Error");
									goto IL_0416;
								}
								<>m__Finally1();
								break;
							}
							<>4__this.ResetPlayerData("API Offline");
							goto IL_0416;
						}
						IL_0416:
						<>m__Finally1();
						<r>5__4 = null;
						result = false;
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<r>5__4 != null)
				{
					((IDisposable)<r>5__4).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <FetchRecentMatches>d__147 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string id;

			public CompetitivePluginCheck <>4__this;

			private string <query>5__1;

			private string <appId>5__2;

			private string <authToken>5__3;

			private string <url>5__4;

			private UnityWebRequest <r>5__5;

			private JArray <ja>5__6;

			private IEnumerator<JObject> <>s__7;

			private JObject <item>5__8;

			private int <pos>5__9;

			private int <adj>5__10;

			private int <par>5__11;

			private int <mmr>5__12;

			private int <post>5__13;

			private string <dtRaw>5__14;

			private string <dateStr>5__15;

			private DateTime <dt>5__16;

			private string <posStr>5__17;

			private string <mmrColor>5__18;

			private string <parSign>5__19;

			private string <summary>5__20;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<query>5__1 = null;
				<appId>5__2 = null;
				<authToken>5__3 = null;
				<url>5__4 = null;
				<r>5__5 = null;
				<ja>5__6 = null;
				<>s__7 = null;
				<item>5__8 = null;
				<dtRaw>5__14 = null;
				<dateStr>5__15 = null;
				<posStr>5__17 = null;
				<mmrColor>5__18 = null;
				<parSign>5__19 = null;
				<summary>5__20 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<query>5__1 = "{\"player_id\":\"" + id + "\"}";
						<appId>5__2 = UnifiedPlugin.GetCurrentAppId();
						<authToken>5__3 = UnifiedPlugin.GetCurrentAuthToken();
						<url>5__4 = "https://sbgleague.com/api/apps/" + <appId>5__2 + "/entities/MatchEntry?q=" + UnityWebRequest.EscapeURL(<query>5__1) + "&sort=-match_date&limit=5";
						<r>5__5 = UnityWebRequest.Get(<url>5__4);
						<>1__state = -3;
						<r>5__5.SetRequestHeader("X-App-Id", <appId>5__2);
						<r>5__5.SetRequestHeader("api_key", <authToken>5__3);
						<r>5__5.certificateHandler = (CertificateHandler)(object)new BypassCertificate();
						<>2__current = <r>5__5.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<r>5__5.result == 1)
						{
							try
							{
								<ja>5__6 = JArray.Parse(<r>5__5.downloadHandler.text);
								<>4__this._recentMatches.Clear();
								<>s__7 = ((IEnumerable)<ja>5__6).OfType<JObject>().GetEnumerator();
								try
								{
									while (<>s__7.MoveNext())
									{
										<item>5__8 = <>s__7.Current;
										JToken obj = <item>5__8["finish_position"];
										<pos>5__9 = (int)((obj != null) ? Extensions.Value<float>((IEnumerable<JToken>)obj) : 0f);
										JToken obj2 = <item>5__8["adjusted_match_score"];
										<adj>5__10 = (int)((obj2 != null) ? Extensions.Value<float>((IEnumerable<JToken>)obj2) : 0f);
										JToken obj3 = <item>5__8["score_vs_par"];
										<par>5__11 = (int)((obj3 != null) ? Extensions.Value<float>((IEnumerable<JToken>)obj3) : 0f);
										JToken obj4 = <item>5__8["mmr_change"];
										<mmr>5__12 = (int)((obj4 != null) ? Extensions.Value<float>((IEnumerable<JToken>)obj4) : 0f);
										JToken obj5 = <item>5__8["post_match_mmr"];
										<post>5__13 = (int)((obj5 != null) ? Extensions.Value<float>((IEnumerable<JToken>)obj5) : 0f);
										<dtRaw>5__14 = ((object)<item>5__8["match_date"])?.ToString() ?? "";
										<dateStr>5__15 = (DateTime.TryParse(<dtRaw>5__14, out <dt>5__16) ? <dt>5__16.ToString("MM/dd") : "??/??");
										<posStr>5__17 = <>4__this.GetOrdinal(<pos>5__9);
										<mmrColor>5__18 = ((<mmr>5__12 >= 0) ? "#55FF55" : "#FF5555");
										<parSign>5__19 = ((<par>5__11 > 0) ? "+" : "");
										<summary>5__20 = string.Format("<color=#888888>{0}</color> | <b>Pos: {1}</b> | Score: {2} ({3}{4}) | MMR: {5} (<color={6}>{7}{8}</color>)", <dateStr>5__15, <posStr>5__17, <adj>5__10, <parSign>5__19, <par>5__11, <post>5__13, <mmrColor>5__18, (<mmr>5__12 >= 0) ? "+" : "", <mmr>5__12);
										<>4__this._recentMatches.Add(new MatchEntry
										{
											match_summary = <summary>5__20,
											match_date = <dtRaw>5__14
										});
										<dtRaw>5__14 = null;
										<dateStr>5__15 = null;
										<posStr>5__17 = null;
										<mmrColor>5__18 = null;
										<parSign>5__19 = null;
										<summary>5__20 = null;
										<item>5__8 = null;
									}
								}
								finally
								{
									if (<>s__7 != null)
									{
										<>s__7.Dispose();
									}
								}
								<>s__7 = null;
								<ja>5__6 = null;
							}
							catch
							{
							}
						}
						<>m__Finally1();
						<r>5__5 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<r>5__5 != null)
				{
					((IDisposable)<r>5__5).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <ForwardP2PMatchIdWithDelay>d__134 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string matchId;

			public float delaySeconds;

			public ulong senderId;

			public CompetitivePluginCheck <>4__this;

			private Exception <ex>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(delaySeconds);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					try
					{
						MatchResultSubmissionService.HandleIncomingMatchIdBroadcast(matchId);
						Debug.Log((object)$"[SBGL-CompPluginCheck] Forwarded P2P Match ID (delayed {delaySeconds:0.#}s) from {senderId}: {matchId}");
					}
					catch (Exception ex)
					{
						<ex>5__1 = ex;
						Debug.LogWarning((object)("[SBGL-CompPluginCheck] Error forwarding Match ID: " + <ex>5__1.Message));
					}
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <GetNetworkTime>d__152 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CompetitivePluginCheck <>4__this;

			private string <url>5__1;

			private UnityWebRequest <webRequest>5__2;

			private JObject <json>5__3;

			private string <timeStr>5__4;

			private DateTime <dt>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<url>5__1 = null;
				<webRequest>5__2 = null;
				<json>5__3 = null;
				<timeStr>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Invalid comparison between Unknown and I4
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<url>5__1 = "https://timeapi.io/api/Time/current/zone?timeZone=UTC";
						<webRequest>5__2 = UnityWebRequest.Get(<url>5__1);
						<>1__state = -3;
						<webRequest>5__2.timeout = 5;
						<>2__current = <webRequest>5__2.SendWebRequest();
						<>1__state = 1;
						result = true;
						break;
					case 1:
						{
							<>1__state = -3;
							if ((int)<webRequest>5__2.result == 1)
							{
								try
								{
									<json>5__3 = JObject.Parse(<webRequest>5__2.downloadHandler.text);
									<timeStr>5__4 = ((object)<json>5__3["dateTime"])?.ToString();
									if (!DateTime.TryParse(<timeStr>5__4, out <dt>5__5))
									{
										<json>5__3 = null;
										<timeStr>5__4 = null;
										goto IL_0127;
									}
									<>4__this._lastSyncTime = <dt>5__5.ToLocalTime().ToString("HH:mm:ss");
									result = false;
								}
								catch
								{
									goto IL_0127;
								}
								<>m__Finally1();
								break;
							}
							goto IL_0127;
						}
						IL_0127:
						<>m__Finally1();
						<webRequest>5__2 = null;
						<>4__this._lastSyncTime = DateTime.Now.ToString("HH:mm:ss") + " (Local)";
						result = false;
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<webRequest>5__2 != null)
				{
					((IDisposable)<webRequest>5__2).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <ResolvePlayerIdFromName>d__149 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string playerName;

			public CompetitivePluginCheck <>4__this;

			private string <query>5__1;

			private string <appId>5__2;

			private string <authToken>5__3;

			private string <url>5__4;

			private UnityWebRequest <r>5__5;

			private JArray <res>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<query>5__1 = null;
				<appId>5__2 = null;
				<authToken>5__3 = null;
				<url>5__4 = null;
				<r>5__5 = null;
				<res>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<query>5__1 = "{\"display_name\":{\"$regex\":\"^" + playerName + "$\",\"$options\":\"i\"}}";
						<appId>5__2 = UnifiedPlugin.GetCurrentAppId();
						<authToken>5__3 = UnifiedPlugin.GetCurrentAuthToken();
						<url>5__4 = "https://sbgleague.com/api/apps/" + <appId>5__2 + "/entities/MatchEntry?q=" + UnityWebRequest.EscapeURL(<query>5__1) + "&sort=-match_date&limit=5";
						<r>5__5 = UnityWebRequest.Get(<url>5__4);
						<>1__state = -3;
						<r>5__5.SetRequestHeader("X-App-Id", <appId>5__2);
						<r>5__5.SetRequestHeader("api_key", <authToken>5__3);
						<r>5__5.certificateHandler = (CertificateHandler)(object)new BypassCertificate();
						<>2__current = <r>5__5.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<r>5__5.result == 1)
						{
							try
							{
								<res>5__6 = JArray.Parse(<r>5__5.downloadHandler.text);
								if (((JContainer)<res>5__6).Count > 0)
								{
									<>4__this.ResolvedID = ((object)<res>5__6[0][(object)"id"])?.ToString() ?? "None";
									<>4__this.ResolvedName = ((object)<res>5__6[0][(object)"display_name"])?.ToString() ?? "Not Found";
									if (<>4__this.ConfigPlayerId == "PASTE_ID_HERE")
									{
										<>4__this.ConfigPlayerId = <>4__this.ResolvedID;
									}
								}
								else
								{
									<>4__this.ResolvedID = "None";
								}
								<res>5__6 = null;
							}
							catch
							{
								<>4__this.ResolvedID = "None";
							}
						}
						<>m__Finally1();
						<r>5__5 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<r>5__5 != null)
				{
					((IDisposable)<r>5__5).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <RetryResolveLobbyName>d__115 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Lobby lobby;

			public CompetitivePluginCheck <>4__this;

			private float[] <delays>5__1;

			private float[] <>s__2;

			private int <>s__3;

			private float <delay>5__4;

			private string <name>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<delays>5__1 = null;
				<>s__2 = null;
				<name>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Expected O, but got Unknown
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<delays>5__1 = new float[4] { 0.5f, 1.5f, 3f, 6f };
					<>s__2 = <delays>5__1;
					<>s__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					<name>5__5 = TryReadLobbyName(lobby);
					if (!string.IsNullOrWhiteSpace(<name>5__5))
					{
						_currentLobbyName = <name>5__5;
						Debug.Log((object)$"[SBGL-CompPluginCheck] ✓ Lobby name resolved (retry +{<delay>5__4}s): '{<name>5__5}'");
						return false;
					}
					<name>5__5 = null;
					<>s__3++;
					break;
				}
				if (<>s__3 < <>s__2.Length)
				{
					<delay>5__4 = <>s__2[<>s__3];
					<>2__current = (object)new WaitForSeconds(<delay>5__4);
					<>1__state = 1;
					return true;
				}
				<>s__2 = null;
				Debug.LogWarning((object)"[SBGL-CompPluginCheck] Lobby name still blank after all retries (non-host path).");
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <TriggerFullSync>d__146 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string configId;

			public CompetitivePluginCheck <>4__this;

			private string <idToUse>5__1;

			private MenuTabs <menuTabs>5__2;

			private SharedPlayerProfile <profile>5__3;

			private string <steamName>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<idToUse>5__1 = null;
				<menuTabs>5__2 = null;
				<profile>5__3 = null;
				<steamName>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this._isSyncing)
					{
						return false;
					}
					<>4__this._isSyncing = true;
					<>4__this._syncStatus = "Syncing...";
					<>4__this.ResetPlayerData();
					<>4__this.UpdateUIReport();
					<idToUse>5__1 = "";
					if (UnifiedPlugin.IsPlayerProfileResolved())
					{
						<profile>5__3 = UnifiedPlugin.GetPlayerProfile();
						<idToUse>5__1 = <profile>5__3.ID;
						<>4__this.ResolvedID = <profile>5__3.ID;
						<>4__this.ResolvedName = <profile>5__3.DisplayName;
						<profile>5__3 = null;
						goto IL_0193;
					}
					<steamName>5__4 = <>4__this.GetInGameName();
					if (!string.IsNullOrEmpty(<steamName>5__4))
					{
						<>2__current = <>4__this.ResolvePlayerIdFromName(<steamName>5__4);
						<>1__state = 1;
						return true;
					}
					goto IL_018b;
				case 1:
					<>1__state = -1;
					if (<>4__this.ResolvedID != "None")
					{
						<idToUse>5__1 = <>4__this.ResolvedID;
					}
					goto IL_018b;
				case 2:
					<>1__state = -1;
					<>2__current = <>4__this.FetchPlayerData(<idToUse>5__1);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = <>4__this.FetchLeaderboardRank(<idToUse>5__1);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = <>4__this.GetNetworkTime();
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<>2__current = <>4__this.FetchEvents();
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					<>2__current = <>4__this.FetchRecentMatches(<idToUse>5__1);
					<>1__state = 7;
					return true;
				case 7:
					{
						<>1__state = -1;
						<>4__this._syncStatus = ((<>4__this._activeUsername == "Invalid ID" || <>4__this._activeUsername == "API Offline") ? "Error" : "Connected");
						break;
					}
					IL_0193:
					if ((string.IsNullOrEmpty(<idToUse>5__1) || <idToUse>5__1 == "None") && !string.IsNullOrEmpty(configId) && configId != "PASTE_ID_HERE")
					{
						<idToUse>5__1 = configId;
						<>4__this.ResolvedID = configId;
					}
					if (!string.IsNullOrEmpty(<idToUse>5__1) && <idToUse>5__1 != "None" && <idToUse>5__1 != "PASTE_ID_HERE")
					{
						<>2__current = <>4__this.CheckPluginsRoutine();
						<>1__state = 2;
						return true;
					}
					<>4__this._syncStatus = "ID Required";
					<>4__this.ResetPlayerData("Link ID in Settings");
					break;
					IL_018b:
					<steamName>5__4 = null;
					goto IL_0193;
				}
				<menuTabs>5__2 = Object.FindFirstObjectByType<MenuTabs>();
				if ((Object)(object)<menuTabs>5__2 != (Object)null)
				{
					SBGLTabManager.Inject(<menuTabs>5__2);
				}
				<>4__this._isSyncing = false;
				<>4__this.UpdateUIReport();
				return false;
			}

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

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

		private ConfigEntry<float> _configX;

		private ConfigEntry<float> _configY;

		private ConfigEntry<float> _configWidth;

		private ConfigEntry<float> _configAlpha;

		private ConfigEntry<float> _configUpdateInterval;

		private ConfigEntry<float> _configCompliancePanelX;

		private ConfigEntry<float> _configCompliancePanelY;

		private ConfigEntry<bool> _configHideUIWindow;

		private ConfigEntry<bool> _configShowModList;

		private ConfigEntry<bool> _configShowDebugWindow;

		private ConfigEntry<bool> _configMelonLoaderChatEnabled;

		private ConfigEntry<string> _configPlayerId;

		private const string ALLOWED_MODS_URL = "https://gist.githubusercontent.com/Kingcox22/59765f02af8dd87179ca920409ff3b27/raw/Approved_Mods.json";

		private const int SBGL_NET_CHANNEL = 2622;

		private Dictionary<ulong, string> _remotePlayerMods = new Dictionary<ulong, string>();

		private Dictionary<ulong, string> _playerDisplayNames = new Dictionary<ulong, string>();

		private Dictionary<ulong, PlayerComplianceStatus> _playerComplianceStatus = new Dictionary<ulong, PlayerComplianceStatus>();

		private HashSet<ulong> _playersNotifiedAbout = new HashSet<ulong>();

		private HashSet<ulong> _knownPeers = new HashSet<ulong>();

		private Dictionary<ulong, float> _playerFirstSeenTime = new Dictionary<ulong, float>();

		private const float COMPLIANCE_TIMEOUT = 15f;

		private bool _hasLoggedDiscoveryInfo = false;

		private string _lastDiscoveryScene = "";

		private float _lastMelonLoaderAnnouncementTime = -100f;

		internal static string _currentLobbyName = "";

		private int _lastPlayerCosmeticsCount = 0;

		private Rect _compliancePanelRect;

		private bool _compliancePanelRectInit = false;

		private GUIStyle _compWindowStyle;

		private GameObject _canvasObj;

		private GameObject _profilePicContainer;

		private GameObject _bgObj;

		private GameObject _warnContainer;

		private GameObject _debugWindowObj;

		private TextMeshProUGUI _statsText;

		private TextMeshProUGUI _illegalWarningText;

		private TextMeshProUGUI _missingWarningText;

		private TextMeshProUGUI _debugWindowText;

		private Image _bgImage;

		private Image _debugWindowBg;

		private RawImage _profileIcon;

		private RectTransform _bgRect;

		private RectTransform _debugWindowRect;

		private static readonly HashSet<string> IgnoredPluginGuids = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "BepInEx", "com.sbgl.unified" };

		private AllowedModsSnapshot _allowedModsSnapshot = AllowedModsSnapshot.Empty;

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

		private Lobby _currentLobby;

		private bool _inLobby = false;

		public List<ProSeriesEvent> _upcomingEvents = new List<ProSeriesEvent>();

		public List<MatchEntry> _recentMatches = new List<MatchEntry>();

		private bool _isSyncing = false;

		private float _timeUntilNextUpdate = 0f;

		private string _lastSyncTime = "Never";

		public string _activeUsername = "Searching...";

		public string _playerRank = "N/A";

		public string _totalPlayers = "0";

		public string _playerMMR = "0";

		public string _matches = "0";

		public string _playerPeak = "0";

		public string _winRate = "0%";

		public string _lastChange = "0";

		public string _top3s = "0";

		public string _avgScore = "0.0";

		public string _syncStatus = "Idle";

		public string ResolvedName = "Not Found";

		public string ResolvedID = "None";

		private float ConfigX => _configX?.Value ?? PlayerPrefs.GetFloat("CompCheck_X", 20f);

		private float ConfigY => _configY?.Value ?? PlayerPrefs.GetFloat("CompCheck_Y", 100f);

		private float ConfigWidth => _configWidth?.Value ?? PlayerPrefs.GetFloat("CompCheck_Width", 200f);

		private float ConfigAlpha => _configAlpha?.Value ?? PlayerPrefs.GetFloat("CompCheck_Alpha", 0.85f);

		private float ConfigCompliancePanelX
		{
			get
			{
				return _configCompliancePanelX?.Value ?? PlayerPrefs.GetFloat("CompCheck_ComplianceX", (float)Screen.width - 420f);
			}
			set
			{
				if (_configCompliancePanelX != null)
				{
					_configCompliancePanelX.Value = value;
				}
			}
		}

		private float ConfigCompliancePanelY
		{
			get
			{
				return _configCompliancePanelY?.Value ?? PlayerPrefs.GetFloat("CompCheck_ComplianceY", (float)Screen.height - 350f);
			}
			set
			{
				if (_configCompliancePanelY != null)
				{
					_configCompliancePanelY.Value = value;
				}
			}
		}

		private bool ConfigHideUIWindow => _configHideUIWindow?.Value ?? (PlayerPrefs.GetInt("CompCheck_HideUIWindow", 0) == 1);

		private bool ConfigShowModList
		{
			get
			{
				return _configShowModList?.Value ?? (PlayerPrefs.GetInt("CompCheck_ShowModList", 0) == 1);
			}
			set
			{
				if (_configShowModList != null)
				{
					_configShowModList.Value = value;
				}
			}
		}

		private bool ConfigShowDebugWindow
		{
			get
			{
				return _configShowDebugWindow?.Value ?? (PlayerPrefs.GetInt("CompCheck_ShowDebugWindow", 0) == 1);
			}
			set
			{
				if (_configShowDebugWindow != null)
				{
					_configShowDebugWindow.Value = value;
				}
			}
		}

		internal string ConfigPlayerId
		{
			get
			{
				return _configPlayerId?.Value ?? PlayerPrefs.GetString("CompCheck_PlayerId", "PASTE_ID_HERE");
			}
			set
			{
				if (_configPlayerId != null)
				{
					_configPlayerId.Value = value;
				}
			}
		}

		private bool ConfigMelonLoaderChatEnabled => _configMelonLoaderChatEnabled?.Value ?? false;

		private static string NormalizePath(string path)
		{
			if (string.IsNullOrWhiteSpace(path))
			{
				return string.Empty;
			}
			try
			{
				return Path.GetFullPath(path).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
			}
			catch
			{
				return path;
			}
		}

		private static string TryGetAssemblyLocation(Assembly assembly)
		{
			if (assembly == null)
			{
				return string.Empty;
			}
			try
			{
				return NormalizePath(assembly.Location);
			}
			catch
			{
				return string.Empty;
			}
		}

		private bool IsTrackedRuntimeAssemblyPath(string assemblyPath)
		{
			if (string.IsNullOrWhiteSpace(assemblyPath))
			{
				return false;
			}
			string text = NormalizePath(assemblyPath);
			string text2 = NormalizePath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "BepInEx", "plugins"));
			if (text.StartsWith(text2 + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return text.IndexOf(Path.DirectorySeparatorChar + "Cheats" + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private void TrackRuntimeAssembly(Assembly assembly)
		{
			string text = TryGetAssemblyLocation(assembly);
			if (IsTrackedRuntimeAssemblyPath(text))
			{
				_observedRuntimeAssemblyPaths.Add(text);
			}
		}

		private void CaptureLoadedRuntimeAssemblies()
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				TrackRuntimeAssembly(assembly);
			}
		}

		private void OnRuntimeAssemblyLoaded(object sender, AssemblyLoadEventArgs args)
		{
			TrackRuntimeAssembly(args.LoadedAssembly);
		}

		private static string TryGetAssemblySimpleName(string assemblyPath)
		{
			if (string.IsNullOrWhiteSpace(assemblyPath) || !File.Exists(assemblyPath))
			{
				return string.Empty;
			}
			try
			{
				return AssemblyName.GetAssemblyName(assemblyPath).Name ?? string.Empty;
			}
			catch
			{
				return string.Empty;
			}
		}

		private static string ComputeSha256Hex(string filePath)
		{
			try
			{
				using SHA256 sHA = SHA256.Create();
				using FileStream inputStream = File.OpenRead(filePath);
				byte[] array = sHA.ComputeHash(inputStream);
				return BitConverter.ToString(array).Replace("-", "").ToLowerInvariant();
			}
			catch
			{
				return string.Empty;
			}
		}

		private KnownVisibleRuntimeAssemblies BuildKnownVisibleRuntimeAssemblies()
		{
			KnownVisibleRuntimeAssemblies knownVisibleRuntimeAssemblies = new KnownVisibleRuntimeAssemblies();
			foreach (PluginInfo value in Chainloader.PluginInfos.Values)
			{
				try
				{
					Assembly assembly = (((object)value).GetType().GetProperty("Instance", BindingFlags.Instance | BindingFlags.Public)?.GetValue(value))?.GetType().Assembly;
					string text = TryGetAssemblyLocation(assembly);
					if (string.IsNullOrWhiteSpace(text))
					{
						continue;
					}
					knownVisibleRuntimeAssemblies.ExactAssemblyPaths.Add(text);
					AssemblyName[] referencedAssemblies = assembly.GetReferencedAssemblies();
					foreach (AssemblyName assemblyName in referencedAssemblies)
					{
						if (!string.IsNullOrWhiteSpace(assemblyName.Name))
						{
							knownVisibleRuntimeAssemblies.AllowedCompanionAssemblyNames.Add(assemblyName.Name);
						}
					}
				}
				catch
				{
				}
			}
			return knownVisibleRuntimeAssemblies;
		}

		private static bool ShouldIgnorePluginGuid(string guid)
		{
			return !string.IsNullOrWhiteSpace(guid) && IgnoredPluginGuids.Contains(guid);
		}

		private bool IsAllowedPluginGuid(string guid)
		{
			return _allowedModsSnapshot.ContainsGuid(guid);
		}

		private LocalPluginScanResult BuildLocalPluginScanResult()
		{
			LocalPluginScanResult localPluginScanResult = new LocalPluginScanResult();
			HashSet<string> installedGuids = new HashSet<string>(from plugin in Chainloader.PluginInfos.Values
				select plugin.Metadata.GUID into guid
				where !string.IsNullOrWhiteSpace(guid)
				select guid, StringComparer.OrdinalIgnoreCase);
			KnownVisibleRuntimeAssemblies knownVisibleRuntimeAssemblies = BuildKnownVisibleRuntimeAssemblies();
			localPluginScanResult.MissingModNames.AddRange(_allowedModsSnapshot.GetMissingModNames(installedGuids));
			foreach (PluginInfo value in Chainloader.PluginInfos.Values)
			{
				if (ShouldIgnorePluginGuid(value.Metadata.GUID))
				{
					continue;
				}
				if (!IsAllowedPluginGuid(value.Metadata.GUID))
				{
					localPluginScanResult.HasIllegalMods = true;
					break;
				}
				if (!_allowedModsSnapshot.HasHashConstraints)
				{
					continue;
				}
				HashSet<string> allowedHashes = _allowedModsSnapshot.GetAllowedHashes(value.Metadata.GUID);
				if (allowedHashes == null || allowedHashes.Count <= 0)
				{
					continue;
				}
				try
				{
					string text = TryGetAssemblyLocation((((object)value).GetType().GetProperty("Instance", BindingFlags.Instance | BindingFlags.Public)?.GetValue(value))?.GetType().Assembly);
					if (!string.IsNullOrWhiteSpace(text) && File.Exists(text))
					{
						string text2 = ComputeSha256Hex(text);
						if (!string.IsNullOrWhiteSpace(text2) && !allowedHashes.Contains(text2))
						{
							localPluginScanResult.TamperedModNames.Add(value.Metadata.Name);
							localPluginScanResult.HasIllegalMods = true;
						}
					}
				}
				catch
				{
				}
			}
			foreach (string item in _observedRuntimeAssemblyPaths.OrderBy<string, string>((string path) => path, StringComparer.OrdinalIgnoreCase))
			{
				if (!knownVisibleRuntimeAssemblies.ExactAssemblyPaths.Contains(item))
				{
					string text3 = TryGetAssemblySimpleName(item);
					if (item.Contains(Path.DirectorySeparatorChar + "Cheats" + Path.DirectorySeparatorChar) || string.IsNullOrWhiteSpace(text3) || !knownVisibleRuntimeAssemblies.AllowedCompanionAssemblyNames.Contains(text3))
					{
						localPluginScanResult.SuspiciousRuntimeAssemblies.Add(item.Replace(NormalizePath(AppDomain.CurrentDomain.BaseDirectory) + Path.DirectorySeparatorChar, string.Empty));
						localPluginScanResult.HasIllegalMods = true;
					}
				}
			}
			return localPluginScanResult;
		}

		public void SetConfig(ConfigEntry<float> x, ConfigEntry<float> y, ConfigEntry<float> width, ConfigEntry<float> alpha, ConfigEntry<bool> hideUIWindow, ConfigEntry<bool> showModList, ConfigEntry<bool> showDebugWindow, ConfigEntry<float> updateInterval, ConfigEntry<string> playerId, ConfigEntry<float> compliancePanelX = null, ConfigEntry<float> compliancePanelY = null, ConfigEntry<bool> melonLoaderChatEnabled = null)
		{
			_configX = x;
			_configY = y;
			_configWidth = width;
			_configAlpha = alpha;
			_configHideUIWindow = hideUIWindow;
			_configShowModList = showModList;
			_configShowDebugWindow = showDebugWindow;
			_configUpdateInterval = updateInterval;
			_configPlayerId = playerId;
			_configCompliancePanelX = compliancePanelX;
			_configCompliancePanelY = compliancePanelY;
			_configMelonLoaderChatEnabled = melonLoaderChatEnabled;
		}

		private void OnEnable()
		{
			try
			{
				SteamMatchmaking.OnLobbyEntered += OnLobbyEntered;
			}
			catch
			{
			}
			try
			{
				SteamMatchmaking.OnLobbyMemberJoined += OnLobbyMemberJoined;
			}
			catch
			{
			}
			try
			{
				SteamMatchmaking.OnLobbyMemberLeave += OnLobbyMemberLeave;
			}
			catch
			{
			}
			try
			{
				SteamNetworking.OnP2PSessionRequest = (Action<SteamId>)Delegate.Combine(SteamNetworking.OnP2PSessionRequest, new Action<SteamId>(OnP2PSessionRequest));
			}
			catch
			{
			}
		}

		private void OnDisable()
		{
			try
			{
				SteamMatchmaking.OnLobbyEntered -= OnLobbyEntered;
			}
			catch
			{
			}
			try
			{
				SteamMatchmaking.OnLobbyMemberJoined -= OnLobbyMemberJoined;
			}
			catch
			{
			}
			try
			{
				SteamMatchmaking.OnLobbyMemberLeave -= OnLobbyMemberLeave;
			}
			catch
			{
			}
			try
			{
				SteamNetworking.OnP2PSessionRequest = (Action<SteamId>)Delegate.Remove(SteamNetworking.OnP2PSessionRequest, new Action<SteamId>(OnP2PSessionRequest));
			}
			catch
			{
			}
		}

		private void OnP2PSessionRequest(SteamId remoteId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0084: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			if (!_inLobby || !((Lobby)(ref _currentLobby)).Members.Any((Friend m) => SteamId.op_Implicit(m.Id) == SteamId.op_Implicit(remoteId)))
			{
				return;
			}
			SteamNetworking.AcceptP2PSessionWithUser(remoteId);
			if (!_playerDisplayNames.ContainsKey(remoteId.Value))
			{
				foreach (Friend member in ((Lobby)(ref _currentLobby)).Members)
				{
					Friend current = member;
					if (SteamId.op_Implicit(current.Id) == SteamId.op_Implicit(remoteId))
					{
						_playerDisplayNames[remoteId.Value] = ((Friend)(ref current)).Name;
						break;
					}
				}
			}
			Debug.Log((object)$"[SBGL-CompPluginCheck] ✓ Accepted P2P session request from {remoteId.Value}");
		}

		private void OnLobbyEntered(Lobby lobby)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0071: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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)
			_currentLobby = lobby;
			_inLobby = true;
			float time = Time.time;
			string text = TryReadLobbyName(lobby);
			if (!string.IsNullOrWhiteSpace(text))
			{
				_currentLobbyName = text;
			}
			Debug.Log((object)$"[SBGL-CompPluginCheck] ✓ OnLobbyEntered: {((Lobby)(ref lobby)).Id.Value}, member count: {((Lobby)(ref lobby)).MemberCount}, lobby name: '{text}'");
			foreach (Friend member in ((Lobby)(ref lobby)).Members)
			{
				Friend current = member;
				if (current.Id.Value != SteamId.op_Implicit(SteamClient.SteamId))
				{
					Debug.Log((object)$"[SBGL-CompPluginCheck] ✓ Lobby member: {((Friend)(ref current)).Name} ({current.Id.Value})");
					_playerDisplayNames[current.Id.Value] = ((Friend)(ref current)).Name;
					AddPlayerToTracking(current.Id.Value, time);
				}
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				((MonoBehaviour)this).StartCoroutine(RetryResolveLobbyName(lobby));
			}
		}

		private static string TryReadLobbyName(Lobby lobby)
		{
			string[] array = new string[5] { "name", "Name", "lobby_name", "LobbyName", "server_name" };
			string[] array2 = array;
			foreach (string text in array2)
			{
				try
				{
					string data = ((Lobby)(ref lobby)).GetData(text);
					if (!string.IsNullOrWhiteSpace(data))
					{
						return data;
					}
				}
				catch
				{
				}
			}
			return string.Empty;
		}

		[IteratorStateMachine(typeof(<RetryResolveLobbyName>d__115))]
		private IEnumerator RetryResolveLobbyName(Lobby lobby)
		{
			//IL_000e: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RetryResolveLobbyName>d__115(0)
			{
				<>4__this = this,
				lobby = lobby
			};
		}

		private void OnLobbyMemberJoined(Lobby lobby, Friend friend)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			if (friend.Id.Value != SteamId.op_Implicit(SteamClient.SteamId))
			{
				float time = Time.time;
				Debug.Log((object)$"[SBGL-CompPluginCheck] ✓ Lobby member joined: {((Friend)(ref friend)).Name} ({friend.Id.Value})");
				_playerDisplayNames[friend.Id.Value] = ((Friend)(ref friend)).Name;
				AddPlayerToTracking(friend.Id.Value, time);
			}
		}

		private void OnLobbyMemberLeave(Lobby lobby, Friend friend)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			ulong value = friend.Id.Value;
			if (value == SteamId.op_Implicit(SteamClient.SteamId))
			{
				_inLobby = false;
				_playerComplianceStatus.Clear();
				_playerFirstSeenTime.Clear();
				_knownPeers.Clear();
				_playersNotifiedAbout.Clear();
				_playerDisplayNames.Clear();
				_remotePlayerMods.Clear();
				_hasLoggedDiscoveryInfo = false;
				PlayerPrefs.SetString("LobbyName", "");
				Debug.Log((object)"[SBGL-CompPluginCheck] Left lobby — cleared all player tracking");
			}
			else
			{
				_playerComplianceStatus.Remove(value);
				_playerFirstSeenTime.Remove(value);
				_knownPeers.Remove(value);
				_playersNotifiedAbout.Remove(value);
				_playerDisplayNames.Remove(value);
				_remotePlayerMods.Remove(value);
				Debug.Log((object)$"[SBGL-CompPluginCheck] Player left lobby: {((Friend)(ref friend)).Name} ({value}) — removed from tracking");
			}
		}

		private void Awake()
		{
			if (!PlayerPrefs.HasKey("CompCheck_X"))
			{
				PlayerPrefs.SetFloat("CompCheck_X", 20f);
			}
			if (!PlayerPrefs.HasKey("CompCheck_Y"))
			{
				PlayerPrefs.SetFloat("CompCheck_Y", 100f);
			}
			if (!PlayerPrefs.HasKey("CompCheck_Width"))
			{
				PlayerPrefs.SetFloat("CompCheck_Width", 200f);
			}
			if (!PlayerPrefs.HasKey("CompCheck_Alpha"))
			{
				PlayerPrefs.SetFloat("CompCheck_Alpha", 0.85f);
			}
			if (!PlayerPrefs.HasKey("CompCheck_UpdateInterval"))
			{
				PlayerPrefs.SetFloat("CompCheck_UpdateInterval", 5f);
			}
			if (!PlayerPrefs.HasKey("CompCheck_HideUIWindow"))
			{
				PlayerPrefs.SetInt("CompCheck_HideUIWindow", 0);
			}
			if (!PlayerPrefs.HasKey("CompCheck_ShowModList"))
			{
				PlayerPrefs.SetInt("CompCheck_ShowModList", 0);
			}
			if (!PlayerPrefs.HasKey("CompCheck_ShowDebugWindow"))
			{
				PlayerPrefs.SetInt("CompCheck_ShowDebugWindow", 0);
			}
			if (!PlayerPrefs.HasKey("CompCheck_PlayerId"))
			{
				PlayerPrefs.SetString("CompCheck_PlayerId", "PASTE_ID_HERE");
			}
			if (HasMelonLoaderLoaded())
			{
				Debug.LogError((object)"[SBGL-CompPluginCheck] ⚠\ufe0f⚠\ufe0f⚠\ufe0f STARTUP DETECTION: MELONLOADER IS LOADED ⚠\ufe0f⚠\ufe0f⚠\ufe0f");
			}
			UnifiedPlugin.ApiConfigChanged += OnApiConfigChanged;
			AppDomain.CurrentDomain.AssemblyLoad += OnRuntimeAssemblyLoaded;
			CaptureLoadedRuntimeAssemblies();
			((MonoBehaviour)this).StartCoroutine(GetNetworkTime());
		}

		private void OnDestroy()
		{
			UnifiedPlugin.ApiConfigChanged -= OnApiConfigChanged;
			AppDomain.CurrentDomain.AssemblyLoad -= OnRuntimeAssemblyLoaded;
		}

		private void OnApiConfigChanged()
		{
			((MonoBehaviour)this).StopCoroutine(AutoUpdateLoop());
			((MonoBehaviour)this).StartCoroutine(AutoUpdateLoop());
		}

		private void Start()
		{
			if (!string.IsNullOrEmpty(ConfigPlayerId) && ConfigPlayerId != "PASTE_ID_HERE")
			{
				ResolvedID = ConfigPlayerId;
			}
			CreateUI();
			((MonoBehaviour)this).StartCoroutine(AutoUpdateLoop());
		}

		private void Update()
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			Keyboard current = Keyboard.current;
			if (current == null)
			{
				return;
			}
			if (((ButtonControl)current[(Key)102]).wasPressedThisFrame)
			{
				ConfigShowModList = !ConfigShowModList;
				UpdateUIReport();
			}
			if (((ButtonControl)current[(Key)103]).wasPressedThisFrame)
			{
				TriggerManualSync();
			}
			if (((ButtonControl)current[(Key)104]).wasPressedThisFrame)
			{
				ConfigShowDebugWindow = !ConfigShowDebugWindow;
				UpdateUIReport();
			}
			if ((Object)(object)_bgRect != (Object)null)
			{
				float num = Mathf.Clamp(ConfigX, 0f, (float)Screen.width - ConfigWidth);
				float num2 = Mathf.Clamp(ConfigY, 0f, (float)Screen.height - _bgRect.sizeDelta.y);
				_bgRect.anchoredPosition = new Vector2(num, num2);
				_bgRect.sizeDelta = new Vector2(ConfigWidth, _bgRect.sizeDelta.y);
				((Graphic)_bgImage).color = new Color(0f, 0f, 0f, ConfigAlpha);
				if (num != ConfigX)
				{
					_configX.Value = num;
				}
				if (num2 != ConfigY)
				{
					_configY.Value = num2;
				}
			}
			if ((Object)(object)_canvasObj != (Object)null)
			{
				_canvasObj.SetActive(!ConfigHideUIWindow);
			}
			if ((Object)(object)_debugWindowObj != (Object)null)
			{
				_debugWindowObj.SetActive(ConfigShowDebugWindow);
			}
			int num3 = 0;
			try
			{
				num3 = Object.FindObjectsByType<PlayerCosmetics>((FindObjectsSortMode)0).Length;
			}
			catch
			{
			}
			if (num3 != _lastPlayerCosmeticsCount)
			{
				Debug.Log((object)$"[SBGL-CompPluginCheck] PlayerCosmetics count changed: {_lastPlayerCosmeticsCount} → {num3}, triggering immediate discovery");
				_lastPlayerCosmeticsCount = num3;
				_hasLoggedDiscoveryInfo = false;
				DiscoverLobbyPlayers();
			}
			if (Time.frameCount % 300 == 0)
			{
				DiscoverLobbyPlayers();
			}
			if (HasMelonLoaderLoaded() && _inLobby)
			{
				float num4 = Time.time - _lastMelonLoaderAnnouncementTime;
				if (num4 >= 10f)
				{
					AnnounceOwnMelonLoaderToChat();
					_lastMelonLoaderAnnouncementTime = Time.time;
				}
			}
			AcceptIncomingP2PSessions();
			ListenForModReports();
			if (Time.frameCount % 600 == 0)
			{
				Debug.Log((object)$"[SBGL-CompPluginCheck] Frame {Time.frameCount}: Triggering BroadcastMyMods()");
				BroadcastMyMods();
			}
		}

		private void OnGUI()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigShowDebugWindow)
			{
				Scene activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name.ToLower().Contains("driving range"))
				{
					DrawPlayerComplianceDebugUI();
				}
			}
		}

		private void DrawPlayerComplianceDebugUI()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0038: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (_compWindowStyle == null)
			{
				_compWindowStyle = new GUIStyle(GUI.skin.box)
				{
					padding = new RectOffset(12, 12, 12, 12)
				};
			}
			if (!_compliancePanelRectInit)
			{
				float num = ((ConfigCompliancePanelX > 0f) ? ConfigCompliancePanelX : ((float)Screen.width - 480f));
				float num2 = ((ConfigCompliancePanelY > 0f) ? ConfigCompliancePanelY : ((float)Screen.height - 350f));
				_compliancePanelRect = new Rect(num, num2, 10f, 10f);
				_compliancePanelRectInit = true;
			}
			GUI.backgroundColor = new Color(0.07f, 0.07f, 0.07f, 0.95f);
			_compliancePanelRect = GUILayout.Window(42424, _compliancePanelRect, new WindowFunction(DrawComplianceWindowContent), "", _compWindowStyle, (GUILayoutOption[])(object)new GUILayoutOption[3]
			{
				GUILayout.MinWidth(300f),
				GUILayout.MaxWidth(500f),
				GUILayout.MaxHeight((float)Screen.height - 40f)
			});
			GUI.backgroundColor = Color.white;
		}

		private void DrawComplianceWindowContent(int windowId)
		{
			//IL_000b: 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_0019: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_0065: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Expected O, but got Unknown
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				fontSize = 15,
				fontStyle = (FontStyle)1
			};
			val.normal.textColor = Color.white;
			GUIStyle val2 = val;
			GUIStyle val3 = new GUIStyle(GUI.skin.label)
			{
				richText = true,
				fontSize = 12
			};
			val3.normal.textColor = Color.white;
			GUIStyle val4 = val3;
			GUIStyle val5 = new GUIStyle(GUI.skin.label)
			{
				richText = true,
				fontSize = 13,
				fontStyle = (FontStyle)1
			};
			val5.normal.textColor = Color.white;
			GUIStyle val6 = val5;
			GUIStyle val7 = new GUIStyle(GUI.skin.label)
			{
				richText = true,
				fontSize = 11
			};
			val7.normal.textColor = Color.white;
			GUIStyle val8 = val7;
			GUILayout.Label("PLAYER COMPLIANCE", val2, Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			int count = _playerComplianceStatus.Count;
			int num = _playerComplianceStatus.Values.Count((PlayerComplianceStatus s) => s.IsCompliant && s.HasReportedMods && !s.HasMelonLoader);
			int num2 = _playerComplianceStatus.Values.Count((PlayerComplianceStatus s) => s.HasReportedMods && (!s.IsCompliant || s.HasMelonLoader));
			int num3 = _playerComplianceStatus.Values.Count((PlayerComplianceStatus s) => !s.HasReportedMods);
			GUILayout.Label($"<color=white>Players: <b>{count}</b></color>    <color=lime>✓ {num}</color>    <color=red>✗ {num2}</color>    <color=yellow>? {num3}</color>", val4, Array.Empty<GUILayoutOption>());
			GUILayout.Space(6f);
			if (_playerComplianceStatus.Count == 0)
			{
				GUIStyle val9 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 12
				};
				val9.normal.textColor = new Color(0.6f, 0.6f, 0.6f);
				GUILayout.Label("Waiting for players...", val9, Array.Empty<GUILayoutOption>());
			}
			else
			{
				HashSet<string> hashSet = new HashSet<string>(_allowedModsSnapshot.DisplayNames.Select((string v) => v.ToLowerInvariant()));
				foreach (KeyValuePair<ulong, PlayerComplianceStatus> item in _playerComplianceStatus)
				{
					PlayerComplianceStatus value = item.Value;
					string text;
					string text2;
					if (!value.HasReportedMods)
					{
						text = "?";
						text2 = "yellow";
					}
					else if (value.HasMelonLoader)
					{
						text = "⚠";
						text2 = "orange";
					}
					else if (value.IsCompliant)
					{
						text = "✓";
						text2 = "lime";
					}
					else
					{
						text = "✗";
						text2 = "red";
					}
					string value2;
					string text3 = (_playerDisplayNames.TryGetValue(value.SteamId, out value2) ? value2 : value.SteamId.ToString());
					GUILayout.Label("<color=" + text2 + ">[" + text + "]</color>  " + text3, val6, Array.Empty<GUILayoutOption>());
					if (value.HasMelonLoader)
					{
						GUILayout.Label("      <color=orange>⚠ MelonLoader detected</color>", val8, Array.Empty<GUILayoutOption>());
					}
					if (_remotePlayerMods.TryGetValue(value.SteamId, out var value3))
					{
						string[] array = value3.Split(';');
						foreach (string text4 in array)
						{
							if (!string.IsNullOrEmpty(text4) && !text4.Contains("USER_HAS_MELONLOADER"))
							{
								string text5 = text4.Split('|')[0];
								bool flag = text5.StartsWith("⚡") || hashSet.Contains(text5.ToLowerInvariant());
								string text6 = (flag ? "#AAFFAA" : "#FF4444");
								string text7 = (flag ? "✓" : "✗");
								GUILayout.Label("      <color=" + text6 + ">" + text7 + " " + text5 + "</color>", val8, Array.Empty<GUILayoutOption>());
							}
						}
					}
					GUILayout.Space(5f);
				}
			}
			GUI.DragWindow();
		}

		private bool HasMelonLoaderLoaded()
		{
			return MelonLoaderBridge.IsMelonLoaderLoaded;
		}

		private void DiscoverLobbyPlayers()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_0557: Unknown result type (might be due to invalid IL or missing references)
			//IL_055a: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_059e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0611: Unknown result type (might be due to invalid IL or missing references)
			//IL_0613: Unknown result type (might be due to invalid IL or missing references)
			if (!SteamClient.IsValid)
			{
				return;
			}
			try
			{
				float time = Time.time;
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (name != _lastDiscoveryScene)
				{
					_hasLoggedDiscoveryInfo = false;
					_lastDiscoveryScene = name;
					_lastPlayerCosmeticsCount = 0;
					_playerComplianceStatus.Clear();
					_playerFirstSeenTime.Clear();
					_knownPeers.Clear();
					_playersNotifiedAbout.Clear();
					_playerDisplayNames.Clear();
					_remotePlayerMods.Clear();
					Debug.Log((object)("[SBGL-CompPluginCheck] Scene changed to: " + name + " - cleared player tracking and resetting discovery"));
				}
				bool flag = !_hasLoggedDiscoveryInfo;
				if (flag && !_playerComplianceStatus.ContainsKey(SteamId.op_Implicit(SteamClient.SteamId)))
				{
					bool flag2 = HasMelonLoaderLoaded();
					_playerComplianceStatus[SteamId.op_Implicit(SteamClient.SteamId)] = new PlayerComplianceStatus
					{
						SteamId = SteamId.op_Implicit(SteamClient.SteamId),
						FirstSeenTime = time,
						IsCompliant = true,
						HasReportedMods = true,
						HasMelonLoader = flag2,
						ModList = "⚡SBGL.UnifiedMod|1.0.0"
					};
					if (!_playerFirstSeenTime.ContainsKey(SteamId.op_Implicit(SteamClient.SteamId)))
					{
						_playerFirstSeenTime[SteamId.op_Implicit(SteamClient.SteamId)] = time;
					}
					Debug.Log((object)$"[SBGL-CompPluginCheck] ✓ Added self ({SteamClient.SteamId}) to tracking as COMPLIANT (MelonLoader={flag2})");
					_playerDisplayNames[SteamId.op_Implicit(SteamClient.SteamId)] = SteamClient.Name ?? "Me";
				}
				PlayerCosmetics[] array = (PlayerCosmetics[])(object)new PlayerCosmetics[0];
				try
				{
					array = Object.FindObjectsByType<PlayerCosmetics>((FindObjectsSortMode)0);
					if (flag)
					{
						Debug.Log((object)$"[SBGL-CompPluginCheck] \ud83d\udd0d Scene discovery: Found {array.Length} PlayerCosmetics components");
					}
					PlayerCosmetics[] array2 = array;
					foreach (PlayerCosmetics val in array2)
					{
						try
						{
							GameObject gameObject = ((Component)val).gameObject;
							string name2 = ((Object)gameObject).name;
							if (flag)
							{
								Debug.Log((object)("[SBGL-CompPluginCheck]   → PlayerCosmetics object: '" + name2 + "'"));
							}
							NetworkIdentity component = gameObject.GetComponent<NetworkIdentity>();
							if ((Object)(object)component != (Object)null)
							{
								if (flag)
								{
									Debug.Log((object)"[SBGL-CompPluginCheck]     → Has NetworkIdentity, checking for owner info");
								}
								ulong num = 0uL;
								bool flag3 = false;
								try
								{
									PropertyInfo property = typeof(NetworkIdentity).GetProperty("connectionToClient", BindingFlags.Instance | BindingFlags.Public);
									if (property != null)
									{
										object value = property.GetValue(component);
										if (value != null && flag)
										{
											Debug.Log((object)("[SBGL-CompPluginCheck]       → Has connectionToClient: " + value.GetType().Name));
											Type type = value.GetType();
											PropertyInfo property2 = type.GetProperty("authenticationData", BindingFlags.Instance | BindingFlags.Public);
											if (property2 != null)
											{
												object value2 = property2.GetValue(value);
												if (value2 != null)
												{
													Debug.Log((object)$"[SBGL-CompPluginCheck]       → Auth data: {value2}");
												}
											}
										}
									}
								}
								catch
								{
								}
								if (ulong.TryParse(name2, out var result))
								{
									num = result;
									flag3 = true;
									if (flag)
									{
										Debug.Log((object)$"[SBGL-CompPluginCheck]     ✓ Extracted Steam ID from name: {result}");
									}
								}
								if (flag3)
								{
									if (num == SteamId.op_Implicit(SteamClient.SteamId))
									{
										if (flag)
										{
											Debug.Log((object)$"[SBGL-CompPluginCheck]     ✓ Skipping self ({num})");
										}
										continue;
									}
									if (flag)
									{
										Debug.Log((object)$"[SBGL-CompPluginCheck]     ✓ Discovered player: {num}");
									}
									AddPlayerToTracking(num, time);
								}
								else if (flag)
								{
									Debug.Log((object)("[SBGL-CompPluginCheck]     ⚠\ufe0f PlayerCosmetics '" + name2 + "' has no Steam ID in name. Logging details..."));
									Type type2 = ((object)component).GetType();
									PropertyInfo property3 = type2.GetProperty("ownerId", BindingFlags.Instance | BindingFlags.Public);
									if (property3 != null)
									{
										object value3 = property3.GetValue(component);
										Debug.Log((object)$"[SBGL-CompPluginCheck]       → ownerId: {value3}");
									}
									PropertyInfo property4 = type2.GetProperty("netId", BindingFlags.Instance | BindingFlags.Public);
									if (property4 != null)
									{
										object value4 = property4.GetValue(component);
										Debug.Log((object)$"[SBGL-CompPluginCheck]       → netId: {value4}");
									}
								}
							}
							else if (flag)
							{
								Debug.Log((object)"[SBGL-CompPluginCheck]     ⚠\ufe0f PlayerCosmetics has no NetworkIdentity");
							}
						}
						catch (Exception ex)
						{
							if (flag)
							{
								Debug.LogError((object)("[SBGL-CompPluginCheck] Error processing PlayerCosmetics: " + ex.Message));
							}
						}
					}
					if (flag)
					{
						Debug.Log((object)$"[SBGL-CompPluginCheck] ✓ Discovery complete: {_playerComplianceStatus.Count} players added to tracking");
					}
				}
				catch (Exception ex2)
				{
					if (flag)
					{
						Debug.LogError((object)("[SBGL-CompPluginCheck] Error in PlayerCosmetics discovery: " + ex2.Message));
					}
				}
				if (_inLobby)
				{
					try
					{
						foreach (Friend member in ((Lobby)(ref _currentLobby)).Members)
						{
							Friend current = member;
							if (current.Id.Value != 0 && current.Id.Value != SteamId.op_Implicit(SteamClient.SteamId))
							{
								if (!_knownPeers.Contains(current.Id.Value))
								{
									Debug.Log((object)$"[SBGL-CompPluginCheck] ✓ Lobby refresh found new peer: {((Friend)(ref current)).Name} ({current.Id.Value})");
									AddPlayerToTracking(current.Id.Value, time);
								}
								if (!string.IsNullOrEmpty(((Friend)(ref current)).Name))
								{
									_playerDisplayNames[current.Id.Value] = ((Friend)(ref current)).Name;
								}
							}
						}
					}
					catch (Exception ex3)
					{
						if (flag)
						{
							Debug.LogWarning((object)("[SBGL-CompPluginCheck] Lobby member refresh error: " + ex3.Message));
						}
					}
				}
				else if (flag)
				{
					Debug.Log((object)"[SBGL-CompPluginCheck] ⚠\ufe0f Not in a tracked lobby yet - OnLobbyEntered has not fired");
				}
				_hasLoggedDiscoveryInfo = true;
				List<ulong> list = new List<ulong>();
				foreach (KeyValuePair<ulong, PlayerComplianceStatus> item in _playerComplianceStatus)
				{
					ulong key = item.Key;
					PlayerComplianceStatus value5 = item.Value;
					if (!value5.HasReportedMods && _playerFirstSeenTime.TryGetValue(key, out var value6) && time - value6 >= 15f)
					{
						list.Add(key);
					}
				}
				foreach (ulong item2 in list)
				{
					PlayerComplianceStatus playerComplianceStatus = _playerComplianceStatus[item2];
					if (!playerComplianceStatus.HasReportedMods)
					{
						Debug.LogWarning((object)$"[SBGL-CompPluginCheck] Player {item2} timed out without reporting mods - marking as non-compliant");
						playerComplianceStatus.IsCompliant = false;
						playerComplianceStatus.ModList = "(No report received)";
						SendComplianceNotification(item2, playerComplianceStatus);
						UpdateUIReport();
					}
				}
			}
			catch (Exception ex4)
			{
				Debug.LogError((object)("[SBGL-CompPluginCheck] Fatal error in DiscoverLobbyPlayers: " + ex4.Message + "\n" + ex4.StackTrace));
			}
		}

		private void AddPlayerToTracking(ulong steamId, float now)
		{
			if (!_playerComplianceStatus.ContainsKey(steamId))
			{
				_playerComplianceStatus[steamId] = new PlayerComplianceStatus
				{
					SteamId = steamId,
					FirstSeenTime = now,
					IsCompliant = false,
					HasReportedMods = false
				};
				if (!_playerFirstSeenTime.ContainsKey(steamId))
				{
					_playerFirstSeenTime[steamId] = now;
				}
				_knownPeers.Add(steamId);
				Debug.Log((object)$"[SBGL-CompPluginCheck] Added player {steamId} to tracking (knownPeers={_knownPeers.Count})");
				TrySendCurrentMatchIdToPeer(steamId, "peer discovered");
				UpdateUIReport();
			}
		}

		private static bool ShouldShareCurrentMatchId()
		{
			//IL_0015: 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)
			string currentMatchId = SBGLPlugin.CurrentMatchId;
			if (string.IsNullOrWhiteSpace(currentMatchId))
			{
				return false;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			string text = ((Scene)(ref activeScene)).name?.ToLowerInvariant() ?? string.Empty;
			if (text.Contains("menu") || text.Contains("driving") || text.Contains("range") || text.Contains("lobby"))
			{
				return false;
			}
			return true;
		}

		private void TrySendCurrentMatchIdToPeer(ulong peerId, string reason)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if (!SteamClient.IsValid || peerId == 0L || peerId == SteamId.op_Implicit(SteamClient.SteamId) || !ShouldShareCurrentMatchId())
			{
				return;
			}
			string currentMatchId = SBGLPlugin.CurrentMatchId;
			if (string.IsNullOrWhiteSpace(currentMatchId))
			{
				return;
			}
			try
			{
				byte[] bytes = Encoding.UTF8.GetBytes("SBGL_MATCH_ID:" + currentMatchId);
				SteamNetworking.SendP2PPacket(SteamId.op_Implicit(peerId), bytes, -1, 2622, (P2PSend)2);
				Debug.Log((object)$"[SBGL-CompPluginCheck] Sent active match ID {currentMatchId} to peer {peerId} ({reason})");
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)$"[SBGL-CompPluginCheck] Failed to send active match ID to peer {peerId} ({reason}): {ex.Message}");
			}
		}

		private void AcceptIncomingP2PSessions()
		{
			//IL_0037: 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_004d: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			if (!SteamClient.IsValid)
			{
				return;
			}
			try
			{
				foreach (ulong item in _playerComplianceStatus.Keys.ToList())
				{
					if (item != SteamId.op_Implicit(SteamClient.SteamId))
					{
						try
						{
							SteamNetworking.AcceptP2PSessionWithUser(SteamId.op_Implicit(item));
						}
						catch
						{
						}
					}
				}
				foreach (ulong item2 in _knownPeers.ToList())
				{
					if (item2 != SteamId.op_Implicit(SteamClient.SteamId))
					{
						try
						{
							SteamNetworking.AcceptP2PSessionWithUser(SteamId.op_Implicit(item2));
						}
						catch
						{
						}
					}
				}
				if (Time.frameCount % 1200 == 0)
				{
					Debug.Log((object)$"[SBGL-CompPluginCheck] SteamClient.IsValid={SteamClient.IsValid}, SteamClient.SteamId={SteamClient.SteamId}, Known Peers={_knownPeers.Count}, Tracked Players={_playerComplianceStatus.Count}");
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[SBGL-CompPluginCheck] Error in AcceptIncomingP2PSessions: " + ex.Message));
			}
		}

		private void BroadcastMyMods()
		{
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			if (!SteamClient.IsValid)
			{
				Debug.Log((object)"[SBGL-CompPluginCheck] BroadcastMyMods: SteamClient not valid");
				return;
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder("SBGL_REPORT:");
				UnifiedPlugin instance = UnifiedPlugin.Instance;
				string text = ((instance == null) ? null : ((BaseUnityPlugin)instance).Info.Metadata.Version?.ToString()) ?? "0.0.0";
				stringBuilder.Append("⚡SBGL.UnifiedMod|" + text + ";");
				bool flag = HasMelonLoaderLoaded();
				if (flag)
				{
					stringBuilder.Append("⚠\ufe0fUSER_HAS_MELONLOADER;");
					if (_lastMelonLoaderAnnouncementTime < 0f)
					{
						Debug.LogWarning((object)"[SBGL-CompPluginCheck] MelonLoader detected on this client.");
					}
				}
				foreach (PluginInfo value3 in Chainloader.PluginInfos.Values)
				{
					if (!ShouldIgnorePluginGuid(value3.Metadata.GUID))
					{
						stringBuilder.Append($"{value3.Metadata.Name}|{value3.Metadata.Version};");
					}
				}
				Debug.Log((object)$"[SBGL-CompPluginCheck] BroadcastMyMods (MelonLoader={flag})");
				string value = stringBuilder.ToString().Substring("SBGL_REPORT:".Length);
				_remotePlayerMods[SteamId.op_Implicit(SteamClient.SteamId)] = value;
				if (_playerComplianceStatus.TryGetValue(SteamId.op_Implicit(SteamClient.SteamId), out var value2))
				{
					value2.HasMelonLoader = flag;
				}
				if (!_playerDisplayNames.ContainsKey(SteamId.op_Implicit(SteamClient.SteamId)))
				{
					_playerDisplayNames[SteamId.op_Implicit(SteamClient.SteamId)] = SteamClient.Name ?? "Me";
				}
				byte[] bytes = Encoding.UTF8.GetBytes(stringBuilder.ToString());
				HashSet<ulong> hashSet = new HashSet<ulong>(_knownPeers);
				hashSet.UnionWith(_remotePlayerMods.Keys);
				hashSet.Remove(SteamId.op_Implicit(SteamClient.SteamId));
				if (hashSet.Count > 0)
				{
					Debug.Log((object)$"[SBGL-CompPluginCheck] Broadcasting to {hashSet.Count} peers");
				}
				foreach (ulong item in hashSet)
				{
					try
					{
						SteamNetworking.SendP2PPacket(SteamId.op_Implicit(item), bytes, -1, 2622, (P2PSend)2);
					}
					catch (Exception ex)
					{
						Debug.LogWarning((object)$"[SBGL-CompPluginCheck] Failed to send to peer {item}: {ex.Message}");
					}
				}
			}
			catch (Exception ex2)
			{
				Debug.LogError((object)("[SBGL-CompPluginCheck] Error in BroadcastMyMods: " + ex2.Message + "\n" + ex2.StackTrace));
			}
		}

		private void ListenForModReports()
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			if (!SteamClient.IsValid)
			{
				return;
			}
			uint num = default(uint);
			while (SteamNetworking.IsP2PPacketAvailable(ref num, 2622))
			{
				byte[] array = new byte[num];
				uint num2 = 0u;
				SteamId val = default(SteamId);
				if (!SteamNetworking.ReadP2PPacket(array, ref num2, ref val, 2622))
				{
					continue;
				}
				string @string = Encoding.UTF8.GetString(array);
				Debug.Log((object)$"[SBGL-CompPluginCheck] Received from peer {val.Value}: {@string}");
				_knownPeers.Add(val.Value);
				if (@string.StartsWith("SBGL_MATCH_ID:"))
				{
					string text = @string.Replace("SBGL_MATCH_ID:", "").Trim();
					try
					{
						((MonoBehaviour)this).StartCoroutine(ForwardP2PMatchIdWithDelay(text, 2f, val.Value));
					}
					catch
					{
						MatchResultSubmissionService.HandleIncomingMatchIdBroadcast(text);
						Debug.Log((object)$"[SBGL-CompPluginCheck] Forwarded P2P Match ID (immediate fallback) from {val.Value}: {text}");
					}
				}
				else if (@string.StartsWith("SBGL_REPORT:"))
				{
					string text2 = @string.Replace("SBGL_REPORT:", "");
					TrySendCurrentMatchIdToPeer(val.Value, "mod report received");
					if (!_playerComplianceStatus.ContainsKey(val.Value))
					{
						_playerComplianceStatus[val.Value] = new PlayerComplianceStatus
						{
							FirstSeenTime = Time.time
						};
					}
					PlayerComplianceStatus playerComplianceStatus = _playerComplianceStatus[val.Value];
					playerComplianceStatus.SteamId = val.Value;
					playerComplianceStatus.HasReportedMods = true;
					playerComplianceStatus.ModList = text2;
					playerComplianceStatus.IsCompliant = text2.Contains("⚡SBGL.UnifiedMod");
					playerComplianceStatus.HasMelonLoader = text2.Contains("⚠\ufe0fUSER_HAS_MELONLOADER");
					if (playerComplianceStatus.HasMelonLoader)
					{
						Debug.LogError((object)$"[SBGL-CompPluginCheck] ⚠\ufe0f⚠\ufe0f⚠\ufe0f ALERT: Player {val.Value} HAS MELONLOADER INSTALLED ⚠\ufe0f⚠\ufe0f⚠\ufe0f");
						text2 = text2.Replace("⚠\ufe0fUSER_HAS_MELONLOADER;", "");
					}
					if (!playerComplianceStatus.IsCompliant)
					{
						Debug.LogError((object)$"[SBGL-CompPluginCheck] ⚠\ufe0f MISSING MOD ALERT: Player {val.Value} does NOT have SBGL.UnifiedMod installed! Their mod list: {text2}");
						SendComplianceNotification(val.Value, playerComplianceStatus);
					}
					_remotePlayerMods[val.Value] = text2;
					UpdateUIReport();
				}
			}
		}

		[IteratorStateMachine(typeof(<ForwardP2PMatchIdWithDelay>d__134))]
		private IEnumerator ForwardP2PMatchIdWithDelay(string matchId, float delaySeconds, ulong senderId)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ForwardP2PMatchIdWithDelay>d__134(0)
			{
				<>4__this = this,
				matchId = matchId,
				delaySeconds = delaySeconds,
				senderId = senderId
			};
		}

		internal static IEnumerable<ulong> GetKnownPeers()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			CompetitivePluginCheck competitivePluginCheck = Object.FindFirstObjectByType<CompetitivePluginCheck>();
			if ((Object)(object)competitivePluginCheck == (Object)null)
			{
				return Array.Empty<ulong>();
			}
			HashSet<ulong> hashSet = new HashSet<ulong>(competitivePluginCheck._knownPeers);
			hashSet.UnionWith(competitivePluginCheck._remotePlayerMods.Keys);
			if (SteamClient.IsValid)
			{
				hashSet.Remove(SteamId.op_Implicit(SteamClient.SteamId));
			}
			return hashSet;
		}

		internal static bool HasHigherVersionPeer()
		{
			CompetitivePluginCheck competitivePluginCheck = Object.FindFirstObjectByType<CompetitivePluginCheck>();
			if ((Object)(object)competitivePluginCheck == (Object)null)
			{
				return false;
			}
			UnifiedPlugin instance = UnifiedPlugin.Instance;
			Version version = ((instance != null) ? ((BaseUnityPlugin)instance).Info.Metadata.Version : null) ?? new Version(0, 0, 0);
			foreach (string value in competitivePluginCheck._remotePlayerMods.Values)
			{
				if (string.IsNullOrEmpty(value))
				{
					continue;
				}
				string[] array = value.Split(';');
				foreach (string text in array)
				{
					if (text.StartsWith("⚡SBGL.UnifiedMod|"))
					{
						string input = text.Substring("⚡SBGL.UnifiedMod|".Length).Trim();
						if (Version.TryParse(input, out Version result) && result > version)
						{
							return true;
						}
						break;
					}
				}
			}
			return false;
		}

		internal static string GetCurrentSteamLobbyId()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			CompetitivePluginCheck competitivePluginCheck = Object.FindFirstObjectByType<CompetitivePluginCheck>();
			if (!((Object)(object)competitivePluginCheck == (Object)null) && competitivePluginCheck._inLobby)
			{
				SteamId id = ((Lobby)(ref competitivePluginCheck._currentLobby)).Id;
				if (((SteamId)(ref id)).IsValid)
				{
					id = ((Lobby)(ref competitivePluginCheck._currentLobby)).Id;
					return id.Value.ToString();
				}
			}
			return string.Empty;
		}

		private void SendComplianceNotification(ulong steamId, PlayerComplianceStatus status)
		{
			if (_playersNotifiedAbout.Contains(steamId))
			{
				return;
			}
			_playersNotifiedAbout.Add(steamId);
			string text = string.Format("[SBGL] ⚠\ufe0f Player {0} failed compliance check: {1}", steamId, status.HasMelonLoader ? "MelonLoader detected" : "Missing SBGL.UnifiedMod");
			Debug.LogWarning((object)("[SBGL-CompPluginCheck] NOTIFICATION: " + text));
			try
			{
				Type type = Type.GetType("GameAssembly+Chat, GameAssembly");
				if (type != null)
				{
					MethodInfo method = type.GetMethod("SendChatMessage", BindingFlags.Static | BindingFlags.Public);
					if (method != null)
					{
						method.Invoke(null, new object[1] { text });
						Debug.Log((object)"[SBGL-CompPluginCheck] Chat message sent via game API");
					}
				}
			}
			catch (Exception ex)
			{
				Debug.Log((object)("[SBGL-CompPluginCheck] Chat API not available (this is OK): " + ex.Message));
			}
		}

		private void AnnounceOwnMelonLoaderToChat()
		{
			//IL_00a8: 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)
			Debug.Log((object)"[SBGL-CompPluginCheck] ✓ AnnounceOwnMelonLoaderToChat() called");
			if (!ConfigMelonLoaderChatEnabled)
			{
				Debug.Log((object)"[SBGL-CompPluginCheck] MelonLoader chat announcement is disabled in config - skipping");
			}
			else
			{
				if (!_inLobby)
				{
					return;
				}
				string currentLobbyName = _currentLobbyName;
				Debug.Log((object)("[SBGL-CompPluginCheck] Lobby name check: '" + currentLobbyName + "'"));
				if (!currentLobbyName.StartsWith("SBGL-"))
				{
					Debug.Log((object)("[SBGL-CompPluginCheck] Lobby '" + currentLobbyName + "' is not an SBGL lobby - skipping announcement"));
					return;
				}
				string text = UnifiedPlugin.GetPlayerProfile()?.DisplayName;
				if (string.IsNullOrEmpty(text))
				{
					SteamId steamId = SteamClient.SteamId;
					text = ((object)(SteamId)(ref steamId)).ToString();
				}
				string text2 = "⚠\ufe0f MELONLOADER DETECTED: Player " + text + " is running MelonLoader!";
				Debug.LogWarning((object)("[SBGL-CompPluginCheck] Announcing MelonLoader presence: " + text2));
				if (!TrySendChatMessage(text2))
				{
					Debug.Log((object)"[SBGL-CompPluginCheck] ℹ\ufe0f Chat API not available (game may not have public chat API). MelonLoader detection is still being broadcast via P2P to other SBGL mod users.");
				}
			}
		}

		private bool TrySendChatMessage(string message)
		{
			string[] array = new string[3] { "GameAssembly+TextChatManager, GameAssembly", "GameAssembly.TextChatManager, GameAssembly", "TextChatManager, GameAssembly" };
			string[] array2 = new string[5] { "SendChatMessage", "PostMessage", "AddMessage", "Send", "SendMessage" };
			string[] array3 = array;
			foreach (string text in array3)
			{
				try
				{
					Type type = Type.GetType(text);
					if (type == null)
					{
						continue;
					}
					Debug.Log((object)("[SBGL-CompPluginCheck] Found TextChatManager type: " + text));
					string[] array4 = array2;
					foreach (string text2 in array4)
					{
						try
						{
							MethodInfo method = type.GetMethod(text2, BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
							if (method != null)
							{
								method.Invoke(null, new object[1] { message });
								Debug.Log((object)("[SBGL-CompPluginCheck] ✓ Chat message sent via static " + text + "." + text2));
								return true;
							}
						}
						catch
						{
						}
					}
					PropertyInfo propertyInfo = type.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public) ?? type.GetProperty("Singleton", BindingFlags.Static | BindingFlags.Public) ?? type.GetField("_instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.DeclaringType?.GetProperty("_instance", BindingFlags.Static | BindingFlags.Public);
					if (propertyInfo == null)
					{
						FieldInfo field = type.GetField("Instance", BindingFlags.Static | BindingFlags.Public);
						if (field != null)
						{
							object value = field.GetValue(null);
							if (value != null)
							{
								string[] array5 = array2;
								foreach (string text3 in array5)
								{
									try
									{
										MethodInfo method2 = type.GetMethod(text3, BindingFlags.Instance | BindingFlags.Public);
										if (method2 != null)
										{
											method2.Invoke(value, new object[1] { message });
											Debug.Log((object)("[SBGL-CompPluginCheck] ✓ Chat message sent via " + text + "." + text3 + "() [instance field]"));
											return true;
										}
									}
									catch
									{
									}
								}
							}
						}
					}
					else if ((object)propertyInfo != null)
					{
						PropertyInfo propertyInfo2 = propertyInfo;
						if (true)
						{
							object value2 = propertyInfo2.GetValue(null);
							if (value2 != null)
							{
								string[] array6 = array2;
								foreach (string text4 in array6)
								{
									try
									{
										MethodInfo method3 = type.GetMethod(text4, BindingFlags.Instance | BindingFlags.Public);
										if (method3 != null)
										{
											method3.Invoke(value2, new object[1] { message });
											Debug.Log((object)("[SBGL-CompPluginCheck] ✓ Chat message sent via " + text + "." + text4 + "() [singleton]"));
											return true;
										}
									}
									catch
									{
									}
								}
							}
						}
					}
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
					Debug.Log((object)("[SBGL-CompPluginCheck] Available methods on " + text + ": " + string.Join(", ", methods.Select((MethodInfo m) => m.Name).Distinct())));
				}
				catch (Exception ex)
				{
					Debug.Log((object)("[SBGL-CompPluginCheck] Error trying " + text + ": " + ex.Message));
				}
			}
			Debug.Log((object)"[SBGL-CompPluginCheck] TextChatManager not found or no compatible method available");
			return false;
		}

		public void TriggerManualSync()
		{
			((MonoBehaviour)this).StopAllCoroutines();
			_isSyncing = false;
			((MonoBehaviour)this).StartCoroutine(AutoUpdateLoop());
		}

		private string GetOrdinal(int number)
		{
			if (number <= 0)
			{
				return number.ToString();
			}
			int num = number % 100;
			int num2 = num;
			if ((uint)(num2 - 11) <= 2u)
			{
				return number + "th";
			}
			return (number % 10) switch
			{
				1 => number + "st", 
				2 => number + "nd", 
				3 => number + "rd", 
				_ => number + "th", 
			};
		}

		private void ResetPlayerData(string userStatus = "Updating...")
		{
			_activeUsername = userStatus;
			_playerRank = "N/A";
			_playerMMR = "0";
			_playerPeak = "0";
			_matches = "0";
			_lastChange = "0";
			_top3s = "0";
			_avgScore = "0.0";
			_winRate = "0%";
			if ((Object)(object)_profilePicContainer != (Object)null)
			{
				_profilePicContainer.SetActive(false);
			}
		}

		private string GetInGameName()
		{
			try
			{
				Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "com.rlabrecque.steamworks.net" || a.GetName().Name.Contains("Steamworks"));
				if (assembly != null)
				{
					Type type = assembly.GetType("Steamworks.SteamClient");
					if (type != null)
					{
						string text = type.GetProperty("Name", BindingFlags.Static | BindingFlags.Public)?.GetValue(null)?.ToString();
						if (!string.IsNullOrEmpty(text))
						{
							return text;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Debug.Log((object)("[SBGL] Steam Reflection failed (Safe): " + ex.Message));
			}
			return "";
		}

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

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

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

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

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

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

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

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

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

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

		private void UpdateUIReport()
		{
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			LocalPluginScanResult localPluginScanResult = BuildLocalPluginScanResult();
			stringBuilder.AppendLine("User: <color=#FFFFFF>" + _activeUsername + "</color>");
			stringBuilder.AppendLine("Rank: <color=#00FF00>#" + _playerRank + "</color> / " + _totalPlayers);
			stringBuilder.AppendLine("Win Rate: <color=#FFA500>" + _winRate + "</color>");
			float.TryParse(_lastChange, out var result);
			stringBuilder.AppendLine("MMR: <color=#00FFFF>" + _playerMMR + "</color> (<color=" + ((result >= 0f) ? "#55FF55" : "#FF5555") + ">" + ((result >= 0f) ? "+" : "") + _lastChange + "</color>)");
			stringBuilder.AppendLine("Avg. Par: <color=#CC88FF>" + _avgScore + "</color>");
			stringBuilder.AppendLine("Matches: <color=#FFFFFF>" + _matches + "</color> | Top 3s: <color=#00FF00>" + _top3s + "</color>");
			if (ConfigShowModList)
			{
				stringBuilder.AppendLine("--- <color=#AAAAAA>MY MODS</color> ---");
				foreach (PluginInfo value in Chainloader.PluginInfos.Values)
				{
					if (!ShouldIgnorePluginGuid(value.Metadata.GUID))
					{
						stringBuilder.AppendLine((IsAllowedPluginGuid(value.Metadata.GUID) ? "<color=#00FF00>O</color>" : "<color=#FF0000>X</color>") + " <size=11>" + value.Metadata.Name + "</size>");
					}
				}
			}
			stringBuilder.AppendLine("---");
			stringBuilder.AppendLine("<size=10><color=#888888>Sync: " + _lastSyncTime + " | Status: " + _syncStatus + "</color></size>");
			if ((Object)(object)_statsText != (Object)null)
			{
				((TMP_Text)_statsText).text = stringBuilder.ToString();
			}
			UpdateDebugWindow(localPluginScanResult);
			if ((Object)(object)_illegalWarningText != (Object)null)
			{
				((Component)_illegalWarningText).gameObject.SetActive(localPluginScanResult.HasIllegalMods);
			}
			if ((Object)(object)_missingWarningText != (Object)null)
			{
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				bool flag = name.Contains("Driving") || name.Contains("Range");
				((Component)_missingWarningText).gameObject.SetActive(localPluginScanResult.MissingModNames.Count > 0 && flag);
				if (((Component)_missingWarningText).gameObject.activeSelf)
				{
					((TMP_Text)_missingWarningText).text = "<color=yellow>MISSING MODS:</color>\n<size=18>" + string.Join(", ", localPluginScanResult.MissingModNames) + "</size>";
				}
			}
		}

		private void UpdateDebugWindow(LocalPluginScanResult localPluginScan)
		{
			if ((Object)(object)_debugWindowText == (Object)null || (Object)(object)_debugWindowObj == (Object)null)
			{
				return;
			}
			if (ConfigShowDebugWindow)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("--- DEBUG INFORMATION ---");
				stringBuilder.AppendLine($"Config Show Debug: {ConfigShowDebugWindow}");
				stringBuilder.AppendLine($"Remote Players Count: {_remotePlayerMods.Count}");
				stringBuilder.AppendLine($"Allowed Mods Count: {_allowedModsSnapshot.Count}");
				stringBuilder.AppendLine("Hash Enforcement: " + (_allowedModsSnapshot.HasHashConstraints ? "ON" : "OFF (legacy)"));
				stringBuilder.AppendLine($"Missing Mods Count: {localPluginScan.MissingModNames.Count}");
				stringBuilder.AppendLine($"Tampered Mods Count: {localPluginScan.TamperedModNames.Count}");
				stringBuilder.AppendLine($"Suspicious Runtime Assemblies: {localPluginScan.SuspiciousRuntimeAssemblies.Count}");
				stringBuilder.AppendLine($"Any Illegal Mods: {localPluginScan.HasIllegalMods}");
				stringBuilder.AppendLine("Sync Status: " + _syncStatus);
				stringBuilder.AppendLine("Last Sync Time: " + _lastSyncTime);
				stringBuilder.AppendLine("Player ID: " + ConfigPlayerId);
				stringBuilder.AppendLine("Resolved ID: " + ResolvedID);
				if (localPluginScan.TamperedModNames.Count > 0)
				{
					stringBuilder.AppendLine("--- HASH MISMATCH (TAMPERED) ---");
					foreach (string tamperedModName in localPluginScan.TamperedModNames)
					{
						stringBuilder.AppendLine(tamperedModName);
					}
				}
				if (localPluginScan.SuspiciousRuntimeAssemblies.Count > 0)
				{
					stringBuilder.AppendLine("--- SUSPICIOUS RUNTIME ASSEMBLIES ---");
					foreach (string suspiciousRuntimeAssembly in localPluginScan.SuspiciousRuntimeAssemblies)
					{
						stringBuilder.AppendLine(suspiciousRuntimeAssembly);
					}
				}
				stringBuilder.AppendLine("--- REMOTE PLAYERS ---");
				foreach (KeyValuePair<ulong, string> remotePlayerMod in _remotePlayerMods)
				{
					stringBuilder.AppendLine($"Player {remotePlayerMod.Key}: {remotePlayerMod.Value}");
				}
				((TMP_Text)_debugWindowText).text = stringBuilder.ToString();
				_debugWindowObj.SetActive(true);
			}
			else
			{
				_debugWindowObj.SetActive(false);
			}
		}

		private void CreateUI()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Expected O, but got Unknown
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			_canvasObj = new GameObject("SBG_Canvas");
			Canvas val = _canvasObj.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 99999;
			_bgObj = new GameObject("BG");
			_bgObj.transform.SetParent(_canvasObj.transform, false);
			_bgImage = _bgObj.AddComponent<Image>();
			((Graphic)_bgImage).color = new Color(0f, 0f, 0f, ConfigAlpha);
			_bgRect = _bgObj.GetComponent<RectTransform>();
			RectTransform bgRect = _bgRect;
			RectTransform bgRect2 = _bgRect;
			Vector2 val2 = (_bgRect.pivot = Vector2.zero);
			Vector2 val5 = (bgRect.anchorMin = (bgRect2.anchorMax = val2));
			VerticalLayoutGroup val6 = _bgObj.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val6).padding = new RectOffset(10, 10, 10, 10);
			_bgObj.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			_profilePicContainer = new GameObject("PicContainer");
			_profilePicContainer.transform.SetParent(_bgObj.transform, false);
			RectTransform val7 = _profilePicContainer.AddComponent<RectTransform>();
			((Vector2)(ref val2))..ctor(1f, 1f);
			val7.pivot = val2;
			val5 = (val7.anchorMin = (val7.anchorMax = val2));
			val7.anchoredPosition = new Vector2(-10f, -10f);
			val7.sizeDelta = new Vector2(42f, 42f);
			_profilePicContainer.AddComponent<LayoutElement>().ignoreLayout = true;
			_profilePicContainer.AddComponent<RectMask2D>();
			_profileIcon = new GameObject("I").AddComponent<RawImage>();
			((Component)_profileIcon).transform.SetParent(_profilePicContainer.transform, false);
			((Graphic)_profileIcon).rectTransform.anchorMin = Vector2.zero;
			((Graphic)_profileIcon).rectTransform.anchorMax = Vector2.one;
			((Graphic)_profileIcon).rectTransform.sizeDelta = Vector2.zero;
			_profilePicContainer.SetActive(false);
			_statsText = new GameObject("S").AddComponent<TextMeshProUGUI>();
			((TMP_Text)_statsText).transform.SetParent(_bgObj.transform, false);
			((TMP_Text)_statsText).fontSize = 13f;
			((TMP_Text)_statsText).richText = true;
			_warnContainer = new GameObject("WarnContainer");
			_warnContainer.transform.SetParent(_canvasObj.transform, false);
			RectTransform val10 = _warnContainer.AddComponent<RectTransform>();
			((Vector2)(ref val5))..ctor(0.5f, 0f);
			val10.anchorMax = val5;
			val10.anchorMin = val5;
			val10.pivot = new Vector2(0.5f, 0f);
			val10.anchoredPosition = new Vector2(0f, 15f);
			val10.sizeDelta = new Vector2(1000f, 200f);
			VerticalLayoutGroup val11 = _warnContainer.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val11).childAlignment = (TextAnchor)7;
			_illegalWarningText = new GameObject("RT").AddComponent<TextMeshProUGUI>();
			((TMP_Text)_illegalWarningText).transform.SetParent(_warnContainer.transform, false);
			((TMP_Text)_illegalWarningText).text = "ILLEGAL MODS DETECTED";
			((Graphic)_illegalWarningText).color = Color.red;
			((TMP_Text)_illegalWarningText).fontSize = 32f;
			((TMP_Text)_illegalWarningText).alignment = (TextAlignmentOptions)514;
			((TMP_Text)_illegalWarningText).fontStyle = (FontStyles)1;
			((Component)_illegalWarningText).gameObject.SetActive(false);
			_missingWarningText = new GameObject("YT").AddComponent<TextMeshProUGUI>();
			((TMP_Text)_missingWarningText).transform.SetParent(_warnContainer.transform, false);
			((Graphic)_missingWarningText).color = Color.yellow;
			((TMP_Text)_missingWarningText).fontSize = 18f;
			((TMP_Text)_missingWarningText).alignment = (TextAlignmentOptions)514;
			((Component)_missingWarningText).gameObject.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_canvasObj);
		}
	}
	[HarmonyPatch]
	public static class MenuTabsPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(MenuTabs), "Awake")]
		public static void Postfix(MenuTabs __instance)
		{
			SBGLTabManager.Inject(__instance);
		}
	}
	public static class SBGLTabManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<GameObject, bool> <>9__1_0;

			public static Func<GameObject, bool> <>9__1_1;

			public static UnityAction <>9__5_2;

			internal bool <Inject>b__1_0(GameObject t)
			{
				return ((Object)t).name == "SBGL";
			}

			internal bool <Inject>b__1_1(GameObject t)
			{
				return ((Object)t).name.Contains("Controls");
			}

			internal void <PopulateSBGLPage>b__5_2()
			{
				Application.OpenURL("https://sbgleague.com/AccountSettings");
			}
		}

		private const string TAB_NAME = "SBGL";

		public static void Inject(MenuTabs menuTabs)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Expected O, but got Unknown
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Expected O, but got Unknown
			if ((Object)(object)menuTabs == (Object)null)
			{
				return;
			}
			Transform val = ((Component)menuTabs).transform.Find("Menu/Options Tab");
			GameObject val2 = ((IEnumerable<GameObject>)menuTabs.tabs).FirstOrDefault((Func<GameObject, bool>)((GameObject t) => ((Object)t).name == "SBGL"));
			if ((Object)(object)val2 != (Object)null)
			{
				List<GameObject> list = new List<GameObject>();
				foreach (Transform item in val2.transform)
				{
					Transform val3 = item;
					list.Add(((Component)val3).gameObject);
				}
				list.ForEach((Action<GameObject>)Object.DestroyImmediate);
				PopulateSBGLPage(val2);
				return;
			}
			Transform val4 = ((val != null) ? val.Find("Controls") : null);
			GameObject val5 = ((IEnumerable<GameObject>)menuTabs.tabs).FirstOrDefault((Func<GameObject, bool>)((GameObject t) => ((Object)t).name.Contains("Controls")));
			if (!((Object)(object)val4 != (Object)null) || !((Object)(object)val5 != (Object)null))
			{
				return;
			}
			((HorizontalOrVerticalLayoutGroup)((Component)val).GetComponent<HorizontalLayoutGroup>()).spacing = -45f;
			Button[] tabButtons = menuTabs.tabButtons;
			foreach (Button val6 in tabButtons)
			{
				((Component)val6).transform.localScale = new Vector3(0.8f, 0.8f, 0.8f);
			}
			GameObject val7 = Object.Instantiate<GameObject>(((Component)val4).gameObject, val);
			((Object)val7).name = "SBGL";
			SetupButtonText(val7, "SBGL");
			GameObject val8 = Object.Instantiate<GameObject>(val5, val5.transform.parent);
			((Object)val8).name = "SBGL";
			if (Object.op_Implicit((Object)(object)val8.GetComponent<ControlsRebind>()))
			{
				Object.DestroyImmediate((Object)(object)val8.GetComponent<ControlsRebind>());
			}
			foreach (Transform item2 in val8.transform)
			{
				Transform val9 = item2;
				Object.DestroyImmediate((Object)(object)((Component)val9).gameObject);
			}
			PopulateSBGLPage(val8);
			menuTabs.tabButtons = menuTabs.tabButtons.Append(val7.GetComponent<Button>()).ToArray();
			menuTabs.tabs = menuTabs.tabs.Append(val8).ToArray();
			menuTabs.textColors = menuTabs.textColors.Append(new Color(0f, 0.71f, 0.5f)).ToArray();
			int newIndex = menuTabs.tabs.Length - 1;
			((UnityEventBase)val7.GetComponent<Button>().onClick).RemoveAllListeners();
			((UnityEvent)val7.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				menuTabs.SelectTab(newIndex);
			});
		}

		private static void SetupButtonText(GameObject btn, string txt)
		{
			MonoBehaviour[] componentsInChildren = btn.GetComponentsInChildren<MonoBehaviour>();
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name = ((object)val).GetType().Name;
					if (name.IndexOf("Localiz", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Translat", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						Object.DestroyImmediate((Object)(object)val);
					}
				}
			}
			TextMeshProUGUI[] componentsInChildren2 = btn.GetComponentsInChildren<TextMeshProUGUI>();
			foreach (TextMeshProUGUI val2 in componentsInChildren2)
			{
				((TMP_Text)val2).text = txt;
			}
		}

		private static GameObject CreateText(Transform parent, string text, Color color, int fontSize, int height)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("TextInfo", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(600f, (float)height);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).text = text;
			((Graphic)val2).color = color;
			((TMP_Text)val2).fontSize = fontSize;
			((TMP_Text)val2).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val2).richText = true;
			return val;
		}

		private static GameObject CreateButton(Transform parent, string text, Color color, int width, int height)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SBGButton", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(parent, false);
			val.GetComponent<RectTransform>().sizeDelta = new Vector2((float)width, (float)height);
			((Graphic)val.GetComponent<Image>()).color = color;
			GameObject val2 = new GameObject("BtnText", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(val.transform, false);
			val2.GetComponent<RectTransform>().anchorMin = Vector2.zero;
			val2.GetComponent<RectTransform>().anchorMax = Vector2.one;
			val2.GetComponent<RectTransform>().sizeDelta = Vector2.zero;
			TextMeshProUGUI val3 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val3).text = text;
			((Graphic)val3).color = Color.white;
			((TMP_Text)val3).fontSize = 18f;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
			return val;
		}

		private static void PopulateSBGLPage(GameObject page)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_065e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0687: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected O, but got Unknown
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Expected O, but got Unknown
			//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f3: Expected O, but got Unknown
			//IL_0722: Unknown result type (might be due to invalid IL or missing references)
			//IL_073e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0761: Unknown result type (might be due to invalid IL or missing references)
			//IL_0768: Expected O, but got Unknown
			//IL_0795: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c1: Expected O, but got Unknown
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Expected O, but got Unknown
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_081d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0840: Unknown result type (might be due to invalid IL or missing references)
			//IL_084a: Expected O, but got Unknown
			//IL_0866: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0958: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_091f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Expected O, but got Unknown
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			CompetitivePluginCheck plugin = Object.FindFirstObjectByType<CompetitivePluginCheck>();
			string currentId = ((!string.IsNullOrEmpty(plugin?.ResolvedID) && plugin.ResolvedID != "None") ? plugin.ResolvedID : plugin?.ConfigPlayerId);
			bool flag = !string.IsNullOrEmpty(currentId) && currentId != "PASTE_ID_HERE" && currentId != "None";
			VerticalLayoutGroup val = page.GetComponent<VerticalLayoutGroup>() ?? page.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val).padding = new RectOffset(60, 60, 20, 20);
			((HorizontalOrVerticalLayoutGroup)val).spacing = 15f;
			((LayoutGroup)val).childAlignment = (TextAnchor)1;
			bool childControlHeight = (((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = false);
			((HorizontalOrVerticalLayoutGroup)val).childControlHeight = childControlHeight;
			CreateText(page.transform, "<b>SBG LEAGUE INTEGRATION</b>", new Color(0.16f, 0.99f, 0.75f), 32, 50);
			if (flag)
			{
				CreateText(page.transform, "<color=#222222>--- ACCOUNT ACTIVE ---</color>", Color.black, 18, 30);
				GameObject val2 = CreateButton(page.transform, "VIEW LEAGUE PROFILE", new Color(0.12f, 0.45f, 0.35f), 350, 45);
				((UnityEvent)val2.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					Application.OpenURL("https://sbgleague.com/PlayerProfile?id=" + currentId);
				});
				GameObject val3 = new GameObject("AccountHeader", new Type[2]
				{
					typeof(RectTransform),
					typeof(HorizontalLayoutGroup)
				});
				val3.transform.SetParent(page.transform, false);
				RectTransform component = val3.GetComponent<RectTransform>();
				component.sizeDelta = new Vector2(500f, 80f);
				HorizontalLayoutGroup component2 = val3.GetComponent<HorizontalLayoutGroup>();
				((LayoutGroup)component2).padding = new RectOffset(0, 0, 5, 5);
				((HorizontalOrVerticalLayoutGroup)component2).spacing = 15f;
				((LayoutGroup)component2).childAlignment = (TextAnchor)4;
				childControlHeight = (((HorizontalOrVerticalLayoutGroup)component2).childControlWidth = false);
				((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = childControlHeight;
				childControlHeight = (((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = false);
				((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = childControlHeight;
				Texture2D profilePicture = UnifiedPlugin.GetProfilePicture();
				if ((Object)(object)profilePicture != (Object)null)
				{
					GameObject val4 = new GameObject("ProfilePic", new Type[2]
					{
						typeof(RectTransform),
						typeof(RawImage)
					});
					val4.transform.SetParent(val3.transform, false);
					RawImage component3 = val4.GetComponent<RawImage>();
					component3.texture = (Texture)(object)profilePicture;
					RectTransform component4 = val4.GetComponent<RectTransform>();
					component4.sizeDelta = new Vector2(65f, 65f);
				}
				GameObject val5 = new GameObject("UserInfo", new Type[2]
				{
					typeof(RectTransform),
					typeof(TextMeshProUGUI)
				});
				val5.transform.SetParent(val3.transform, false);
				RectTransform component5 = val5.GetComponent<RectTransform>();
				component5.sizeDelta = new Vector2(300f, 80f);
				TextMeshProUGUI component6 = val5.GetComponent<TextMeshProUGUI>();
				((TMP_Text)component6).text = "<b><size=32>" + (plugin?.ResolvedName ?? "Found") + "</size></b>\n<color=#555555><size=18>ID: " + currentId + "</size></color>";
				((TMP_Text)component6).alignment = (TextAlignmentOptions)514;
				((TMP_Text)component6).verticalAlignment = (VerticalAlignmentOptions)512;
				((Graphic)component6).color = Color.black;
				((TMP_Text)component6).textWrappingMode = (TextWrappingModes)0;
				CreateText(page.transform, "<b>RECENT MATCH HISTORY</b>", new Color(0.12f, 0.65f, 0.55f), 24, 40);
				if ((Object)(object)plugin != (Object)null && plugin._recentMatches != null && plugin._recentMatches.Count > 0)
				{
					foreach (MatchEntry recentMatch in plugin._recentMatches)
					{
						GameObject val6 = CreateText(page.transform, recentMatch.match_summary ?? "", Color.black, 14, 25);
						TextMeshProUGUI component7 = val6.GetComponent<TextMeshProUGUI>();
						if ((Object)(object)component7 != (Object)null)
						{
							((TMP_Text)component7).textWrappingMode = (TextWrappingModes)0;
							((TMP_Text)component7).overflowMode = (TextOverflowModes)0;
							((TMP_Text)component7).alignment = (TextAlignmentOptions)514;
							((Graphic)component7).raycastTarget = false;
						}
					}
				}
				else
				{
					CreateText(page.transform, "No matches found.", Color.gray, 14, 25);
				}
				CreateText(page.transform, "<b>PRO SERIES EVENTS</b>", new Color(0.12f, 0.65f, 0.55f), 24, 40);
				if ((Object)(object)plugin != (Object)null && plugin._upcomingEvents != null && plugin._upcomingEvents.Count > 0)
				{
					foreach (ProSeriesEvent upcomingEvent in plugin._upcomingEvents)
					{
						DateTime result;
						string text = (DateTime.TryParse(upcomingEvent.event_date, out result) ? result.ToString("MM/dd") : "");
						CreateText(page.transform, "<color=#111111>" + upcomingEvent.name + "</color> - <size=14>" + text + "</size>", Color.black, 18, 25);
					}
				}
				else
				{
					CreateText(page.transform, "No upcoming events scheduled.", Color.gray, 16, 25);
				}
				((UnityEvent)CreateButton(page.transform, "REFRESH / AUTO-DETECT", new Color(0.2f, 0.2f, 0.25f), 350, 40).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					if ((Object)(object)plugin != (Object)null)
					{
						plugin.ConfigPlayerId = "PASTE_ID_HERE";
						plugin.ResolvedID = "None";
						plugin.TriggerManualSync();
					}
				});
			}
			else
			{
				CreateText(page.transform, "<color=#444444>--- MANUAL SETUP REQUIRED ---</color>", Color.black, 18, 30);
				ButtonClickedEvent onClick = CreateButton(page.transform, "FIND MY PLAYER ID", new Color(0.12f, 0.12f, 0.12f), 350, 45).GetComponent<Button>().onClick;
				object obj = <>c.<>9__5_2;
				if (obj == null)
				{
					UnityAction val7 = delegate
					{
						Application.OpenURL("https://sbgleague.com/AccountSettings");
					};
					<>c.<>9__5_2 = val7;
					obj = (object)val7;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				GameObject val8 = new GameObject("Box", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val8.transform.SetParent(page.transform, false);
				((Graphic)val8.GetComponent<Image>()).color = new Color(0.05f, 0.05f, 0.05f, 1f);
				val8.GetComponent<RectTransform>().sizeDelta = new Vector2(350f, 50f);
				GameObject val9 = new GameObject("T", new Type[1] { typeof(RectTransform) });
				val9.transform.SetParent(val8.transform, false);
				TextMeshProUGUI val10 = val9.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val10).fontSize = 20f;
				((Graphic)val10).color = Color.white;
				((TMP_Text)val10).alignment = (TextAlignmentOptions)514;
				TMP_InputField input = val8.AddComponent<TMP_InputField>();
				input.textComponent = (TMP_Text)(object)val10;
				input.text = (((Object)(object)plugin != (Object)null) ? plugin.ConfigPlayerId : "");
				((UnityEvent)CreateButton(page.transform, "SAVE & SYNC PROFILE", new Color(0.1f, 0.6f, 0.45f), 400, 55).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					if ((Object)(object)plugin != (Object)null)
					{
						plugin.ConfigPlayerId = input.text;
						plugin.TriggerManualSync();
					}
				});
			}
			CreateText(page.transform, "<b>PRO SERIES EVENTS</b>", new Color(0.12f, 0.65f, 0.55f), 24, 40);
			if ((Object)(object)plugin != (Object)null && plugin._upcomingEvents.Count > 0)
			{
				foreach (ProSeriesEvent upcomingEvent2 in plugin._upcomingEvents)
				{
					DateTime result2;
					string text2 = (DateTime.TryParse(upcomingEvent2.event_date, out result2) ? result2.ToString("MM/dd") : "");
					CreateText(page.transform, "<color=#111111>" + upcomingEvent2.name + "</color> - <size=14>" + text2 + "</size>", Color.black, 18, 25);
				}
				return;
			}
			CreateText(page.transform, "No upcoming events scheduled.", Color.gray, 16, 25);
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public static class LobbyNameCapturePatch
	{
		public static void Postfix(string value)
		{
			CompetitivePluginCheck._currentLobbyName = value ?? "";
		}
	}
}
namespace SBGL.UnifiedMod.Core
{
	public static class MapPoolConfig
	{
		public class Course
		{
			public string Name { get; set; }

			public string Biome { get; set; }

			public bool IsApproved { get; set; }

			public Course(string name, string biome, bool isApproved)
			{
				Name = name;
				Biome = biome;
				IsApproved = isApproved;
			}
		}

		private static readonly Course[] ApprovedCourses;

		private static readonly Course[] BannedCourses;

		private static readonly List<Course> AllCourses;

		static MapPoolConfig()
		{
			ApprovedCourses = new Course[28]
			{
				new Course("Snow 1", "Snow", isApproved: true),
				new Course("Snow 3", "Snow", isApproved: true),
				new Course("Snow 6", "Snow", isApproved: true),
				new Course("Snow 7", "Snow", isApproved: true),
				new Course("Snow 2", "Snow", isApproved: true),
				new Course("Snow 8", "Snow", isApproved: true),
				new Course("Snow 9", "Snow", isApproved: true),
				new Course("Twin Beach", "Coast", isApproved: true),
				new Course("Cove", "Coast", isApproved: true),
				new Course("Woodland Bay", "Coast", isApproved: true),
				new Course("Rolling Hills", "Coast", isApproved: true),
				new Course("Sandbanks", "Coast", isApproved: true),
				new Course("Lone Island", "Coast", isApproved: true),
				new Course("Treasure Island", "Coast", isApproved: true),
				new Course("Atoll", "Coast", isApproved: true),
				new Course("Hidden Lagoon", "Coast", isApproved: true),
				new Course("Jungle", "Coast", isApproved: true),
				new Course("Twin Path", "Forest", isApproved: true),
				new Course("Overgrown", "Forest", isApproved: true),
				new Course("Roundabout", "Forest", isApproved: true),
				new Course("Blast Off", "Forest", isApproved: true),
				new Course("Hilltops", "Forest", isApproved: true),
				new Course("Terraces", "Forest", isApproved: true),
				new Course("Patches", "Desert", isApproved: true),
				new Course("Big Rock", "Desert", isApproved: true),
				new Course("Oasis", "Desert", isApproved: true),
				new Course("Sand Traps", "Desert", isApproved: true),
				new Course("Serpent Trail", "Desert", isApproved: true)
			};
			BannedCourses = new Course[17]
			{
				new Course("Snow 4", "Snow", isApproved: false),
				new Course("Snow 5", "Snow", isApproved: false),
				new Course("Long Beach", "Coast", isApproved: false),
				new Course("Downhill", "Coast", isApproved: false),
				new Course("Bullseye", "Coast", isApproved: false),
				new Course("Shallows", "Coast", isApproved: false),
				new Course("Catwalk", "Coast", isApproved: false),
				new Course("Spiral", "Coast", isApproved: false),
				new Course("Seaside Cliff", "Coast", isApproved: false),
				new Course("Gauntlet", "Coast", isApproved: false),
				new Course("Overlook", "Forest", isApproved: false),
				new Course("Donut", "Forest", isApproved: false),
				new Course("Upward", "Forest", isApproved: false),
				new Course("Showdown", "Desert", isApproved: false),
				new Course("Underpass", "Desert", isApproved: false),
				new Course("Chasm", "Desert", isApproved: false),
				new Course("Vertigo", "Desert", isApproved: false)
			};
			AllCourses = new List<Course>();
			AllCourses.AddRange(ApprovedCourses);
			AllCourses.AddRange(BannedCourses);
		}

		public static List<Course> GetApprovedCourses()
		{
			return ApprovedCourses.ToList();
		}

		public static List<Course> GetBannedCourses()
		{
			return BannedCourses.ToList();
		}

		public static bool IsCourseApproved(string courseName)
		{
			if (string.IsNullOrEmpty(courseName))
			{
				return false;
			}
			return ApprovedCourses.Any((Course c) => c.Name.Equals(courseName, StringComparison.OrdinalIgnoreCase));
		}

		public static bool IsCourseBanned(string courseName)
		{
			if (string.IsNullOrEmpty(courseName))
			{
				return false;
			}
			return BannedCourses.Any((Course c) => c.Name.Equals(courseName, StringComparison.OrdinalIgnoreCase));
		}

		public static Course GetRandomApprovedCourse()
		{
			return ApprovedCourses[Random.Range(0, ApprovedCourses.Length)];
		}

		public static List<Course> GetApprovedCoursesByBiome(string biome)
		{
			return ApprovedCourses.Where((Course c) => c.Biome.Equals(biome, StringComparison.OrdinalIgnoreCase)).ToList();
		}

		public static int GetTotalCourseCount()
		{
			return AllCourses.Count;
		}

		public static Course FindCourseByName(string courseName)
		{
			if (string.IsNullOrEmpty(courseName))
			{
				return null;
			}
			return AllCourses.FirstOrDefault((Course c) => c.Name.Equals(courseName, StringComparison.OrdinalIgnoreCase));
		}

		public static int GetGameCourseIndexForBiome(string biome)
		{
			return biome?.ToLowerInvariant() switch
			{
				"coast" => 0, 
				"forest" => 1, 
				"desert" => 2, 
				"snow" => 3, 
				_ => -1, 
			};
		}

		public static int GetGameCourseIndexForCourseName(string courseName)
		{
			Course course = FindCourseByName(courseName);
			if (course == null)
			{
				return -1;
			}
			return GetGameCourseIndexForBiome(course.Biome);
		}
	}
	public static class MelonLoaderBridge
	{
		private static bool _initialized;

		private static bool _melonLoaderDetected;

		public static bool IsMelonLoaderLoaded => _melonLoaderDetected;

		public static void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
				_melonLoaderDetected = DetectMelonLoader();
				if (_melonLoaderDetected)
				{
					Debug.LogError((object)"[SBGL-MelonLoaderBridge] ⚠\ufe0f⚠\ufe0f⚠\ufe0f MELONLOADER DETECTED AT INITIALIZATION ⚠\ufe0f⚠\ufe0f⚠\ufe0f");
				}
			}
		}

		private static bool DetectMelonLoader()
		{
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					if (assembly.GetName().Name.Equals("MelonLoader", StringComparison.OrdinalIgnoreCase))
					{
						Debug.LogError((object)"[SBGL-MelonLoaderBridge] ✓ Found MelonLoader in AppDomain.GetAssemblies()");
						return true;
					}
				}
				string baseDirectory = AppDomain.CurrentDomain.BaseDirectory;
				string text = Path.Combine(baseDirectory, "MelonLoader", "MelonLoader.dll");
				if (File.Exists(text))
				{
					Debug.LogError((object)("[SBGL-MelonLoaderBridge] ✓ Found MelonLoader.dll file at: " + text));
					return true;
				}
				Debug.Log((object)"[SBGL-MelonLoaderBridge] No MelonLoader detected");
				return false;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[SBGL-MelonLoaderBridge] Error in DetectMelonLoader: " + ex.Message));
				return false;
			}
		}
	}
	public class SharedPlayerProfile
	{
		public string ID { get; set; }

		public string DisplayName { get; set; }

		public float CurrentMMR { get; set; }

		public string Region { get; set; }

		public string ProfilePicUrl { get; set; }

		public bool IsResolved { get; set; }
	}
	[BepInPlugin("com.sbgl.unified", "SBGL Unified Mod", "0.1.1")]
	public class UnifiedPlugin : BaseUnityPlugin
	{
		public delegate void OnApiConfigChanged();

		[CompilerGenerated]
		private sealed class <>c__DisplayClass75_0
		{
			public bool found;

			public UnifiedPlugin <>4__this;

			internal void <ResolvePlayerProfile>b__0(bool success, PlayerProfileFetcher.PlayerProfile profile)
			{
				if (success && profile != null)
				{
					_sharedProfile.ID = profile.ID;
					_sharedProfile.DisplayName = profile.DisplayName;
					_sharedProfile.CurrentMMR = profile.CurrentMMR;
					_sharedProfile.Region = profile.Region;
					_sharedProfile.ProfilePicUrl = profile.ProfilePicUrl;
					_sharedProfile.IsResolved = true;
					found = true;
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Player Lookup] ✓ Profile resolved: " + _sharedProfile.DisplayName + " (ID: " + _sharedProfile.ID + ")"));
				}
			}

			internal void <ResolvePlayerProfile>b__1(bool success, PlayerProfileFetcher.PlayerProfile profile)
			{
				if (success && profile != null)
				{
					_sharedProfile.ID = profile.ID;
					_sharedProfile.DisplayName = profile.DisplayName;
					_sharedProfile.CurrentMMR = profile.CurrentMMR;
					_sharedProfile.Region = profile.Region;
					_sharedProfile.ProfilePicUrl = profile.ProfilePicUrl;
					_sharedProfile.IsResolved = true;
					found = true;
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Player Lookup] ✓ Fuzzy match resolved: " + _sharedProfile.DisplayName));
				}
			}
		}

		[CompilerGenerated]
		private sealed class <DownloadProfilePicture>d__76 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string url;

			public UnifiedPlugin <>4__this;

			private UnityWebRequest <request>5__1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<request>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (string.IsNullOrEmpty(url))
						{
							return false;
						}
						if (url.StartsWith("http://"))
						{
							url = url.Replace("http://", "https://");
						}
						<request>5__1 = UnityWebRequestTexture.GetTexture(url);
						<>1__state = -3;
						<request>5__1.certificateHandler = (CertificateHandler)(object)new BypassCertificate();
						<>2__current = <request>5__1.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						if ((int)<request>5__1.result == 1)
						{
							_profilePicture = DownloadHandlerTexture.GetContent(<request>5__1);
							((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)$"[Player Lookup] ✓ Profile picture downloaded: {((Texture)_profilePicture).width}x{((Texture)_profilePicture).height}");
						}
						else
						{
							((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("[Player Lookup] Failed to download profile picture: " + <request>5__1.error));
						}
						<>m__Finally1();
						<request>5__1 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<request>5__1 != null)
				{
					((IDisposable)<request>5__1).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <InitializeAsync>d__64 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnifiedPlugin <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] Starting InitializeAsync()");
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Init] Staff list count before RefreshStaffList: " + <>4__this._dynamicStaffList.Count));
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] Calling RefreshStaffList() coroutine...");
					<>2__current = <>4__this.RefreshStaffList();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Init] RefreshStaffList() completed. Staff list now has " + <>4__this._dynamicStaffList.Count + " members"));
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] Calling DetectStaffUser()...");
					<>4__this.DetectStaffUser();
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Init] DetectStaffUser() completed. _isStaffUser = " + <>4__this._isStaffUser));
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] Calling SetupApiEndpoints()...");
					<>4__this.SetupApiEndpoints();
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] SetupApiEndpoints() completed");
					<>4__this.SyncConfigToPlayerPrefs();
					<>4__this.InitializeFeatures();
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"SBGL-UnifiedMod is awake and managing features!");
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <RefreshStaffList>d__67 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnifiedPlugin <>4__this;

			private UnityWebRequest <webRequest>5__1;

			private string <rawContent>5__2;

			private string[] <lines>5__3;

			private string[] <>s__4;

			private int <>s__5;

			private string <line>5__6;

			private string[] <parts>5__7;

			private string <username>5__8;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<webRequest>5__1 = null;
				<rawContent>5__2 = null;
				<lines>5__3 = null;
				<>s__4 = null;
				<line>5__6 = null;
				<parts>5__7 = null;
				<username>5__8 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Invalid comparison between Unknown and I4
				//IL_0376: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Staff List] Starting RefreshStaffList() coroutine...");
						((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Staff List] Gist URL: https://gist.githubusercontent.com/Kingcox22/f1b51955d78305177533759cc4ae6024/raw/86f00f088db32e68e9cd5429b3695db22b435ba0/staff.txt");
						<webRequest>5__1 = UnityWebRequest.Get("https://gist.githubusercontent.com/Kingcox22/f1b51955d78305177533759cc4ae6024/raw/86f00f088db32e68e9cd5429b3695db22b435ba0/staff.txt");
						<>1__state = -3;
						<webRequest>5__1.certificateHandler = (CertificateHandler)(object)new BypassCertificate();
						((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Staff List] Sending web request...");
						<>2__current = <webRequest>5__1.SendWebRequest();
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -3;
						((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)$"[Staff List] Web request completed. Result: {<webRequest>5__1.result}");
						if ((int)<webRequest>5__1.result == 1)
						{
							<rawContent>5__2 = <webRequest>5__1.downloadHandler.text;
							((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)$"[Staff List] Downloaded {<rawContent>5__2.Length} characters");
							<lines>5__3 = <rawContent>5__2.Split(new char[2] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
							((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)$"[Staff List] Split into {<lines>5__3.Length} lines");
							<>4__this._dynamicStaffList.Clear();
							<>s__4 = <lines>5__3;
							for (<>s__5 = 0; <>s__5 < <>s__4.Length; <>s__5++)
							{
								<line>5__6 = <>s__4[<>s__5];
								((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Staff List] Processing line: '" + <line>5__6 + "'"));
								<parts>5__7 = <line>5__6.Split('|');
								((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)$"[Staff List] Split by pipe: {<parts>5__7.Length} parts");
								if (<parts>5__7.Length >= 2)
								{
									<username>5__8 = <parts>5__7[1].Trim();
									((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Staff List] Extracted username: '" + <username>5__8 + "'"));
									if (!string.IsNullOrEmpty(<username>5__8))
									{
										<>4__this._dynamicStaffList.Add(<username>5__8);
										((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Staff List] ✓ Added staff member: " + <username>5__8));
									}
									<username>5__8 = null;
								}
								<parts>5__7 = null;
								<line>5__6 = null;
							}
							<>s__4 = null;
							((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)$"[Staff List] ✓ Final staff list has {<>4__this._dynamicStaffList.Count} members");
							<>4__this.DetectStaffUser();
							<>4__this.SetupApiEndpoints();
							<rawContent>5__2 = null;
							<lines>5__3 = null;
						}
						else
						{
							((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)$"[Staff List] ✗ Web request failed. Result: {<webRequest>5__1.result}, Error: {<webRequest>5__1.error}");
							((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)$"[Staff List] Response Code: {<webRequest>5__1.responseCode}");
							DownloadHandler downloadHandler = <webRequest>5__1.downloadHandler;
							if (!string.IsNullOrEmpty((downloadHandler != null) ? downloadHandler.text : null))
							{
								((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("[Staff List] Response Text: " + <webRequest>5__1.downloadHandler.text));
							}
						}
						<>m__Finally1();
						<webRequest>5__1 = null;
						return false;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<webRequest>5__1 != null)
				{
					((IDisposable)<webRequest>5__1).Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <ResolvePlayerProfile>d__75 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string playerIdOrName;

			public UnifiedPlugin <>4__this;

			private <>c__DisplayClass75_0 <>8__1;

			private string <steamName>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<steamName>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass75_0();
					<>8__1.<>4__this = <>4__this;
					if (string.IsNullOrEmpty(playerIdOrName) || playerIdOrName == "PASTE_ID_HERE")
					{
						<steamName>5__2 = <>4__this.GetSteamUsername();
						if (string.IsNullOrEmpty(<steamName>5__2))
						{
							((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)"[Player Lookup] Player ID not configured and Steam username unavailable. Skipping profile resolution.");
							return false;
						}
						((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Player Lookup] No Player ID configured, using Steam username: " + <steamName>5__2));
						playerIdOrName = <steamName>5__2;
						<steamName>5__2 = null;
					}
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Player Lookup] Resolving player profile for: " + playerIdOrName));
					<>8__1.found = false;
					<>2__current = PlayerProfileFetcher.FetchPlayerProfile(playerIdOrName, <>4__this._currentPlayerApi, <>4__this._currentAppId, <>4__this._currentAuthToken, delegate(bool success, PlayerProfileFetcher.PlayerProfile profile)
					{
						if (success && profile != null)
						{
							_sharedProfile.ID = profile.ID;
							_sharedProfile.DisplayName = profile.DisplayName;
							_sharedProfile.CurrentMMR = profile.CurrentMMR;
							_sharedProfile.Region = profile.Region;
							_sharedProfile.ProfilePicUrl = profile.ProfilePicUrl;
							_sharedProfile.IsResolved = true;
							<>8__1.found = true;
							((BaseUnityPlugin)<>8__1.<>4__this).Logger.LogInfo((object)("[Player Lookup] ✓ Profile resolved: " + _sharedProfile.DisplayName + " (ID: " + _sharedProfile.ID + ")"));
						}
					}, ((BaseUnityPlugin)<>4__this).Logger);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!<>8__1.found && !playerIdOrName.All(char.IsDigit))
					{
						((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Player Lookup] Exact match failed, trying fuzzy match...");
						<>2__current = PlayerProfileFetcher.FuzzySearchPlayer(playerIdOrName, <>4__this._currentPlayerApi, <>4__this._currentAppId, <>4__this._currentAuthToken, delegate(bool success, PlayerProfileFetcher.PlayerProfile profile)
						{
							if (success && profile != null)
							{
								_sharedProfile.ID = profile.ID;
								_sharedProfile.DisplayName = profile.DisplayName;
								_sharedProfile.CurrentMMR = profile.CurrentMMR;
								_sharedProfile.Region = profile.Region;
								_sharedProfile.ProfilePicUrl = profile.ProfilePicUrl;
								_sharedProfile.IsResolved = true;
								<>8__1.found = true;
								((BaseUnityPlugin)<>8__1.<>4__this).Logger.LogInfo((object)("[Player Lookup] ✓ Fuzzy match resolved: " + _sharedProfile.DisplayName));
							}
						}, ((BaseUnityPlugin)<>4__this).Logger);
						<>1__state = 2;
						return true;
					}
					goto IL_022e;
				case 2:
					<>1__state = -1;
					goto IL_022e;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_022e:
					if (!_sharedProfile.IsResolved)
					{
						((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("[Player Lookup] Failed to resolve player profile for: " + playerIdOrName));
					}
					else if (!string.IsNullOrEmpty(_sharedProfile.ProfilePicUrl))
					{
						((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Player Lookup] Downloading profile picture: " + _sharedProfile.ProfilePicUrl));
						<>2__current = <>4__this.DownloadProfilePicture(_sharedProfile.ProfilePicUrl);
						<>1__state = 3;
						return true;
					}
					break;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <RetryStaffDetectionAfterSteamInit>d__63 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnifiedPlugin <>4__this;

			private string <steamName>5__1;

			private bool <wasStaff>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(6f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] Retrying staff detection after Steam initialization...");
					<steamName>5__1 = <>4__this.GetSteamUsername();
					if (!string.IsNullOrEmpty(<steamName>5__1))
					{
						((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Init] ✓ Steam username finally retrieved: '" + <steamName>5__1 + "'"));
						<wasStaff>5__2 = <>4__this._isStaffUser;
						<>4__this.DetectStaffUser();
						if (<>4__this._isStaffUser && !<wasStaff>5__2)
						{
							((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] ✓ Staff status changed to TRUE! Updating API configuration...");
							<>4__this.SetupApiEndpoints();
							((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] API endpoints updated for staff member");
						}
						else if (!<>4__this._isStaffUser)
						{
							((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[Init] User '" + <steamName>5__1 + "' confirmed not in staff list"));
						}
						((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] Retrying player profile resolution with Steam username...");
						<>2__current = <>4__this.ResolvePlayerProfile(<>4__this.CompCheck_PlayerId.Value);
						<>1__state = 2;
						return true;
					}
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] Could not retrieve Steam username even after delay");
					break;
				case 2:
					<>1__state = -1;
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[Init] Player profile resolution retry completed");
					break;
				}
				return false;
			}

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

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

		private const string GIST_URL = "https://gist.githubusercontent.com/Kingcox22/f1b51955d78305177533759cc4ae6024/raw/86f00f088db32e68e9cd5429b3695db22b435ba0/staff.txt";

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

		private const string PROD_PLAYER_API = "https://sbgleague.com/api/apps/69b0f4aba3975f2440fbf070/entities/Player";

		private const string PROD_APP_ID = "69b0f4aba3975f2440fbf070";

		private const string PROD_AUTH_TOKEN = "3f7c84bf7a734c6a86bbc34245a1e6e4";

		private const string PREPROD_PLAYER_API = "https://sbg-league-manager-preprod.base44.app/api/apps/69d5bc0bb18e58e435ff4e3f/entities/Player";

		private const string PREPROD_APP_ID = "69d5bc0bb18e58e435ff4e3f";

		private const string PREPROD_AUTH_TOKEN = "1ec5fe0220c041939070ac4690933ba3";

		private string _currentPlayerApi;

		private string _currentAppId;

		private string _currentAuthToken;

		private bool _isStaffUser = false;

		private static SharedPlayerProfile _sharedProfile = new SharedPlayerProfile();

		private static Texture2D _profilePicture = null;

		public ConfigEntry<float> CompCheck_X;

		public ConfigEntry<float> CompCheck_Y;

		public ConfigEntry<float> CompCheck_Width;

		public ConfigEntry<float> CompCheck_Alpha;

		public ConfigEntry<bool> CompCheck_HideUIWindow;

		public ConfigEntry<bool> CompCheck_ShowModList;

		public ConfigEntry<bool> CompCheck_ShowDebugWindow;

		public ConfigEntry<float> CompCheck_UpdateInterval;

		public ConfigEntry<string> CompCheck_PlayerId;

		public ConfigEntry<float> CompCheck_CompliancePanelX;

		public ConfigEntry<float> CompCheck_CompliancePanelY;

		public ConfigEntry<bool> CompCheck_MelonLoaderChatEnabled;

		public ConfigEntry<bool> MM_ShowSystemLogs;

		public ConfigEntry<bool> MM_ShowFlowDebug;

		public ConfigEntry<bool> MM_ShowUploadNotices;

		public ConfigEntry<bool> MM_IgnoreSbglLobbyRequirement;

		public ConfigEntry<bool> PDS_Enabled;

		public ConfigEntry<float> PDS_RequeueDelay;

		public ConfigEntry<string> PDS_DefaultRuleset;

		public ConfigEntry<float> RS_PosX;

		public ConfigEntry<float> RS_PosY;

		public ConfigEntry<bool> RS_ShowDetails;

		public ConfigEntry<bool> RS_ApplyRulesets;

		public ConfigEntry<float> LL_Width;

		public ConfigEntry<float> LL_MaxHeight;

		public ConfigEntry<float> LL_PosX;

		public ConfigEntry<float> LL_PosY;

		public ConfigEntry<float> LL_Opacity;

		public ConfigEntry<int> LL_MaxPlayers;

		public ConfigEntry<string> API_Environment;

		public ConfigEntry<string> Staff_ModManifestOutputPath;

		private readonly Rect _staffToolsRect = new Rect(20f, 20f, 340f, 110f);

		private string _staffManifestStatus = "Ready";

		public static UnifiedPlugin Instance { get; private set; }

		public static event OnApiConfigChanged ApiConfigChanged;

		public static string GetCurrentPlayerApi()
		{
			return ((Object)(object)Instance != (Object)null) ? Instance._currentPlayerApi : "https://sbgleague.com/api/apps/69b0f4aba3975f2440fbf070/entities/Player";
		}

		public static string GetCurrentAppId()
		{
			return ((Object)(object)Instance != (Object)null) ? Instance._currentAppId : "69b0f4aba3975f2440fbf070";
		}

		public static string GetCurrentAuthToken()
		{
			return ((Object)(object)Instance != (Object)null) ? Instance._currentAuthToken : "3f7c84bf7a734c6a86bbc34245a1e6e4";
		}

		public static bool IsStaffUser()
		{
			return (Object)(object)Instance != (Object)null && Instance._isStaffUser;
		}

		public static SharedPlayerProfile GetPlayerProfile()
		{
			return _sharedProfile;
		}

		public static bool IsPlayerProfileResolved()
		{
			return _sharedProfile.IsResolved;
		}

		public static Texture2D GetProfilePicture()
		{
			return _profilePicture;
		}

		private void Awake()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Expected O, but got Unknown
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Expected O, but got Unknown
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Expected O, but got Unknown
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Expected O, but got Unknown
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Expected O, but got Unknown
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Expected O, but got Unknown
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Expected O, but got Unknown
			//IL_0563: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Expected O, but got Unknown
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ab: Expected O, but got Unknown
			//IL_05d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05df: Expected O, but got Unknown
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0629: Expected O, but got Unknown
			MelonLoaderBridge.Initialize();
			Instance = this;
			CompCheck_X = ((BaseUnityPlugin)this).Config.Bind<float>("CompetitiveCheck.UI Position", "X Offset", 20f, new ConfigDescription("Horizontal position", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 4000f), Array.Empty<object>()));
			CompCheck_Y = ((BaseUnityPlugin)this).Config.Bind<float>("CompetitiveCheck.UI Position", "Y Offset", 100f, new ConfigDescription("Vertical position", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 4000f), Array.Empty<object>()));
			CompCheck_Width = ((BaseUnityPlugin)this).Config.Bind<float>("CompetitiveCheck.UI Size", "Width", 200f, new ConfigDescription("Panel width", (AcceptableValueBase)(object)new AcceptableValueRange<float>(150f, 800f), Array.Empty<object>()));
			CompCheck_Alpha = ((BaseUnityPlugin)this).Config.Bind<float>("CompetitiveCheck.UI Appearance", "Opacity", 0.85f, new ConfigDescription("Panel transparency", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			CompCheck_HideUIWindow = ((BaseUnityPlugin)this).Config.Bind<bool>("CompetitiveCheck.UI Appearance", "Hide UI Window Completely", false, "Hide the Competitive Plugin Check overlay window entirely.");
			CompCheck_ShowModList = ((BaseUnityPlugin)this).Config.Bind<bool>("CompetitiveCheck.UI Appearance", "Show My Mods", false, "Display local mod list");
			CompCheck_ShowDebugWindow = ((BaseUnityPlugin)this).Config.Bind<bool>("CompetitiveCheck.UI Appearance", "Show Debug Window", false, "Display debug information");
			CompCheck_UpdateInterval = ((BaseUnityPlugin)this).Config.Bind<float>("CompetitiveCheck.Logic", "Update Interval", 5f, new ConfigDescription("Update frequency in minutes", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 60f), Array.Empty<object>()));
			CompCheck_PlayerId = ((BaseUnityPlugin)this).Config.Bind<string>("CompetitiveCheck.League", "Player ID", "PASTE_ID_HERE", "Your SBGL player ID");
			((BaseUnityPlugin)this).Logger.LogInfo((object)("[Init] CompCheck_PlayerId initialized: '" + CompCheck_PlayerId.Value + "'"));
			CompCheck_CompliancePanelX = ((BaseUnityPlugin)this).Config.Bind<float>("CompetitiveCheck.Debug Panel", "Compliance Panel X", 0f, new ConfigDescription("Compliance debug panel X position (0 = auto)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 4000f), Array.Empty<object>()));
			CompCheck_CompliancePanelY = ((BaseUnityPlugin)this).Config.Bind<float>("CompetitiveCheck.Debug Panel", "Compliance Panel Y", 0f, new ConfigDescription("Compliance debug panel Y position (0 = auto)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 4000f), Array.Empty<object>()));
			CompCheck_MelonLoaderChatEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("CompetitiveCheck.Notifications", "Announce MelonLoader In Chat", false, "When enabled, broadcasts a chat message in SBGL lobbies when MelonLoader is detected on your client.");
			MM_ShowSystemLogs = ((BaseUnityPlugin)this).Config.Bind<bool>("Matchmaking.UI Settings", "Show System Logs", true, "Display system event logs");
			MM_ShowFlowDebug = ((BaseUnityPlugin)this).Config.Bind<bool>("Matchmaking.UI Settings", "Show Flow Debug", false, "Display flow diagnostics");
			MM_ShowUploadNotices = ((BaseUnityPlugin)this).Config.Bind<bool>("Matchmaking.UI Settings", "Show Upload Notices", true, "Show on-screen upload success/failure notices during gameplay");
			MM_IgnoreSbglLobbyRequirement = ((BaseUnityPlugin)this).Config.Bind<bool>("Matchmaking.UI Settings", "Upload All Matches", false, "When enabled, uploads match results for any match and ignores the SBGL-* lobby-name requirement.");
			PDS_Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("PseudoDedicatedServer", "Enabled", false, "When true, automatically joins queue, accepts matches, hosts/joins lobbies, and requeues after each match.");
			PDS_RequeueDelay = ((BaseUnityPlugin)this).Config.Bind<float>("PseudoDedicatedServer", "Requeue Delay Seconds", 10f, new ConfigDescription("How long (seconds) to wait on the Driving Range before returning to main menu to requeue.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(3f, 120f), Array.Empty<object>()));
			PDS_DefaultRuleset = ((BaseUnityPlugin)this).Config.Bind<string>("PseudoDedicatedServer", "Default Ruleset", "ranked", new ConfigDescription("Ruleset to apply automatically as host.", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[2] { "ranked", "pro_series" }), Array.Empty<object>()));
			RS_PosX = ((BaseUnityPlugin)this).Config.Bind<float>("RuleSetDisplay.UI", "X Position", -1f, new ConfigDescription("Horizontal position. -1 = auto (right edge)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-1f, 4000f), Array.Empty<object>()));
			RS_PosY = ((BaseUnityPlugin)this).Config.Bind<float>("RuleSetDisplay.UI", "Y Position", 20f, new ConfigDescription("Vertical position", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 4000f), Array.Empty<object>()));
			RS_ShowDetails = ((BaseUnityPlugin)this).Config.Bind<bool>("RuleSetDisplay.UI", "Show Details Panel", false, "Show match type, course, season and ruleset labels below the buttons");
			RS_ApplyRulesets = ((BaseUnityPlugin)this).Config.Bind<bool>("RuleSetDisplay.UI", "Apply Rulesets", false, "When disabled, the mod will NOT enforce Season 1 rules or item weights on match start. Use this as a fallback if rules are being applied incorrectly.");
			LL_Width = ((BaseUnityPlugin)this).Config.Bind<float>("LiveLeaderboard.UI", "Width", 350f, new ConfigDescription("Total width of leaderboard panel", (AcceptableValueBase)(object)new AcceptableValueRange<float>(250f, 800f), Array.Empty<object>()));
			LL_MaxHeight = ((BaseUnityPlugin)this).Config.Bind<float>("LiveLeaderboard.UI", "Max Height", 999f, new ConfigDescription("Maximum height of leaderboard panel", (AcceptableValueBase)(object)new AcceptableValueRange<float>(200f, 1440f), Array.Empty<object>()));
			LL_PosX = ((BaseUnityPlugin)this).Config.Bind<float>("LiveLeaderboard.UI", "X Position", 5f, new ConfigDescription("Horizontal position", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3000f), Array.Empty<object>()));
			LL_PosY = ((BaseUnityPlugin)this).Config.Bind<float>("LiveLeaderboard.UI", "Y Position", 200f, new ConfigDescription("Vertical position", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2160f), Array.Empty<object>()));
			LL_Opacity = ((BaseUnityPlugin)this).Config.Bind<float>("LiveLeaderboard.UI", "Opacity", 0.85f, new ConfigDescription("Panel transparency", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			LL_MaxPlayers = ((BaseUnityPlugin)this).Config.Bind<int>("LiveLeaderboard.UI", "Max Players", 16, new ConfigDescription("Maximum rows to display", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), Array.Empty<object>()));
			API_Environment = ((BaseUnityPlugin)this).Config.Bind<string>("API.Environment", "API Environment", "Production", new ConfigDescription("Select API environment: Production or PreProd (Staff Only)", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[2] { "Production", "PreProd" }), Array.Empty<object>()));
			Staff_ModManifestOutputPath = ((BaseUnityPlugin)this).Config.Bind<string>("Staff.Tools", "Approved Mod Manifest Output Path", Path.Combine(Paths.ConfigPath, "sbgl-approved-mods.generated.json"), "Staff-only output path for exporting the approved mod hash manifest.");
			API_Environment.SettingChanged += delegate
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)("[API Setup] ⚡ Config setting changed to: " + API_Environment.Value));
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[API Setup] Rechecking staff status for environment change...");
				DetectStaffUser();
				SetupApiEndpoints();
			};
			((MonoBehaviour)this).StartCoroutine(InitializeAsync());
			((MonoBehaviour)this).StartCoroutine(RetryStaffDetectionAfterSteamInit());
		}

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

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

		private void DetectStaffUser()
		{
			try
			{
				string steamUsername = GetSteamUsername();
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"[Staff Detection] Steam username: '{steamUsername}' | Staff list contains {_dynamicStaffList.Count} members");
				if (!string.IsNullOrEmpty(steamUsername))
				{
					bool flag = _dynamicStaffList.Contains(steamUsername);
					((BaseUnityPlugin)this).Logger.LogInfo((object)$"[Staff Detection] Is '{steamUsername}' in staff list: {flag}");
					_isStaffUser = flag;
					if (_isStaffUser)
					{
						((BaseUnityPlugin)this).Logger.LogInfo((object)("✓ Staff user detected: " + steamUsername + ". API environment switching enabled!"));
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogInfo((object)("✗ '" + steamUsername + "' is not in staff list. Using Production only."));
					}
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"[Staff Detection] Could not retrieve Steam username");
					_isStaffUser = false;
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("[Staff Detection] Exception during staff detection: " + ex.Message));
				_isStaffUser = false;
			}
		}

		private string GetSteamUsername()
		{
			try
			{
				if (!SteamClient.IsValid)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"[Steam Detection] SteamClient is not initialized yet");
					return string.Empty;
				}
				string name = SteamClient.Name;
				if (!string.IsNullOrEmpty(name))
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)("[Steam Detection] Retrieved Steam username: '" + name + "'"));
					return name;
				}
				((BaseUnityPlugin)this).Logger.LogWarning((object)"[Steam Detection] SteamClient returned an empty username");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("[Steam Detection] Outer exception: " + ex.GetType().Name + ": " + ex.Message));
			}
			return string.Empty;
		}

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

		private void OnGUI()
		{
			//IL_0015: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (!_isStaffUser)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			string text = ((Scene)(ref activeScene)).name?.ToLowerInvariant() ?? string.Empty;
			if (text.Contains("menu"))
			{
				GUI.Box(_staffToolsRect, "SBGL Staff Tools");
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((Rect)(ref _staffToolsRect)).x + 10f, ((Rect)(ref _staffToolsRect)).y + 28f, ((Rect)(ref _staffToolsRect)).width - 20f, 30f);
				if (GUI.Button(val, "Generate Approved Mods JSON"))
				{
					ExportApprovedModsManifest();
				}
				Rect val2 = default(Rect);
				((Rect)(ref val2))..ctor(((Rect)(ref _staffToolsRect)).x + 10f, ((Rect)(ref _staffToolsRect)).y + 65f, ((Rect)(ref _staffToolsRect)).width - 20f, 36f);
				GUI.Label(val2, _staffManifestStatus);
			}
		}

		private void ExportApprovedModsManifest()
		{
			try
			{
				string text = Staff_ModManifestOutputPath?.Value;
				if (string.IsNullOrWhiteSpace(text))
				{
					throw new InvalidOperationException("Staff manifest output path is empty.");
				}
				string contents = BuildApprovedModsManifestJson();
				string directoryName = Path.GetDirectoryName(text);
				if (!string.IsNullOrWhiteSpace(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				File.WriteAllText(text, contents);
				_staffManifestStatus = "Manifest written: " + text;
				((BaseUnityPlugin)this).Logger.LogInfo((object)("[Staff Tools] Approved mod manifest exported to '" + text + "'"));
			}
			catch (Exception ex)
			{
				_staffManifestStatus = "Export failed: " + ex.Message;
				((BaseUnityPlugin)this).Logger.LogError((object)$"[Staff Tools] Failed to export approved mod manifest: {ex}");
			}
		}

		private string BuildApprovedModsManifestJson()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0116: 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_0137: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			JArray val = new JArray();
			foreach (PluginInfo item in Chainloader.PluginInfos.Values.OrderBy<PluginInfo, string>((PluginInfo p) => p.Metadata.Name, StringComparer.OrdinalIgnoreCase))
			{
				Assembly assembly = (((object)item).GetType().GetProperty("Instance")?.GetValue(item))?.GetType().Assembly;
				if (!(assembly == null) && !string.IsNullOrWhiteSpace(assembly.Location))
				{
					string fullPath = Path.GetFullPath(assembly.Location);
					JArray val2 = new JArray();
					val2.Add((JToken)new JObject
					{
						["file"] = JToken.op_Implicit(Path.GetFileName(fullPath)),
						["relativePath"] = JToken.op_Implicit(MakeRelativeToPluginsRoot(fullPath)),
						["sha256"] = JToken.op_Implicit(ComputeSha256(fullPath))
					});
					val.Add((JToken)new JObject
					{
						["name"] = JToken.op_Implicit(item.Metadata.Name),
						["guid"] = JToken.op_Implicit(item.Metadata.GUID),
						["version"] = JToken.op_Implicit(item.Metadata.Version?.ToString() ?? string.Empty),
						["assemblies"] = (JToken)(object)val2
					});
				}
			}
			JObject val3 = new JObject
			{
				["version"] = JToken.op_Implicit(1),
				["generatedAtUtc"] = JToken.op_Implicit(DateTime.UtcNow.ToString("o")),
				["generatedBy"] = JToken.op_Implicit(GetSteamUsername()),
				["mods"] = (JToken)(object)val
			};
			return ((JToken)val3).ToString((Formatting)1, Array.Empty<JsonConverter>());
		}

		private static string MakeRelativeToPluginsRoot(string fullPath)
		{
			try
			{
				string text = Path.GetFullPath(fullPath).Replace('\\', '/');
				int num = text.IndexOf("/BepInEx/plugins/", StringComparison.OrdinalIgnoreCase);
				if (num >= 0)
				{
					return text.Substring(num + "/BepInEx/plugins/".Length);
				}
				return Path.GetRelativePath(AppDomain.CurrentDomain.BaseDirectory, fullPath).Replace('\\', '/');
			}
			catch
			{
				return fullPath;
			}
		}

		private static string ComputeSha256(string filePath)
		{
			using FileStream inputStream = File.OpenRead(filePath);
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(inputStream);
			return BitConverter.ToString(array).Replace("-", string.Empty).ToLowerInvariant();
		}

		private void SetupApiEndpoints()
		{
			_sharedProfile.IsResolved = false;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[API Setup] Cleared cached profile for environment switch");
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"[API Setup] _isStaffUser={_isStaffUser}, API_Environment.Value='{API_Environment.Value}'");
			if (_isStaffUser)
			{
				string value = API_Environment.Value;
				if (value == "PreProd")
				{
					_currentPlayerApi = "https://sbg-league-manager-preprod.base44.app/api/apps/69d5bc0bb18e58e435ff4e3f/entities/Player";
					_currentAppId = "69d5bc0bb18e58e435ff4e3f";
					_currentAuthToken = "1ec5fe0220c041939070ac4690933ba3";
					((BaseUnityPlugin)this).Logger.LogInfo((object)"[API Setup] ✓ Switched to PreProd configuration");
				}
				else
				{
					_currentPlayerApi = "https://sbgleague.com/api/apps/69b0f4aba3975f2440fbf070/entities/Player";
					_currentAppId = "69b0f4aba3975f2440fbf070";
					_currentAuthToken = "3f7c84bf7a734c6a86bbc34245a1e6e4";
					((BaseUnityPlugin)this).Logger.LogInfo((object)"[API Setup] ✓ Switched to Production configuration");
				}
			}
			else
			{
				_currentPlayerApi = "https://sbgleague.com/api/apps/69b0f4aba3975f2440fbf070/entities/Player";
				_currentAppId = "69b0f4aba3975f2440fbf070";
				_currentAuthToken = "3f7c84bf7a734c6a86bbc34245a1e6e4";
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[API Setup] User is not staff - using Production only");
			}
			string text = (_isStaffUser ? API_Environment.Value : "Production (Standard)");
			string text2 = ((_currentAuthToken.Length > 15) ? (_currentAuthToken.Substring(0, 10) + "..." + _currentAuthToken.Substring(_currentAuthToken.Length - 5)) : "****");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"==========================================");
			((BaseUnityPlugin)this).Logger.LogInfo((object)("API CONFIGURATION LOADED (" + text + ")"));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Endpoint:  " + _currentPlayerApi));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("App ID:    " + _currentAppId));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Auth:      " + text2));
			((BaseUnityPlugin)this).Logger.LogInfo((object)"==========================================");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[API Setup] Re-resolving player profile for new API environment...");
			((MonoBehaviour)this).StartCoroutine(ResolvePlayerProfile(CompCheck_PlayerId.Value));
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[API Setup] ✓ Notifying components of API configuration change");
			UnifiedPlugin.ApiConfigChanged?.Invoke();
		}

		private void InitializeFeatures()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[Init] Initializing Harmony patches...");
			try
			{
				Harmony val = new Harmony("com.sbgl.unified.patches");
				val.PatchAll(typeof(RulePatches));
				RulePatches.SetLogger(((BaseUnityPlugin)this).Logger);
				RulePatches.SetApplyRulesetsConfig(RS_ApplyRulesets);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[Init] ✓ Harmony patches initialized successfully");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("[Init] Failed to initialize Harmony patches: " + ex.Message));
			}
			SyncConfigToPlayerPrefs();
			GameObject val2 = new GameObject("SBGL-CompetitivePluginCheck");
			Object.DontDestroyOnLoad((Object)(object)val2);
			CompetitivePluginCheck competitivePluginCheck = val2.AddComponent<CompetitivePluginCheck>();
			competitivePluginCheck.SetConfig(CompCheck_X, CompCheck_Y, CompCheck_Width, CompCheck_Alpha, CompCheck_HideUIWindow, CompCheck_ShowModList, CompCheck_ShowDebugWindow, CompCheck_UpdateInterval, CompCheck_PlayerId, CompCheck_CompliancePanelX, CompCheck_CompliancePanelY, CompCheck_MelonLoaderChatEnabled);
			GameObject val3 = new GameObject("SBGL-MatchmakingAssistant");
			Object.DontDestroyOnLoad((Object)(object)val3);
			SBGLPlugin sBGLPlugin = val3.AddComponent<SBGLPlugin>();
			sBGLPlugin.SetConfig(MM_ShowSystemLogs, MM_ShowFlowDebug, MM_ShowUploadNotices, MM_IgnoreSbglLobbyRequirement, null, null, ((BaseUnityPlugin)this).Logger);
			GameObject val4 = new GameObject("SBGL-RuleSetDisplayManager");
			Object.DontDestroyOnLoad((Object)(object)val4);
			RuleSetDisplayManager ruleSetDisplayManager = val4.AddComponent<RuleSetDisplayManager>();
			ruleSetDisplayManager.SetConfig(RS_PosX, RS_PosY, RS_ShowDetails, RS_ApplyRulesets);
			GameObject val5 = new GameObject("SBGL-LiveLeaderboard");
			Object.DontDestroyOnLoad((Object)(object)val5);
			LiveLeaderboardPlugin liveLeaderboardPlugin = val5.AddComponent<LiveLeaderboardPlugin>();
			liveLeaderboardPlugin.SetConfig(LL_Width, LL_MaxHeight, LL_PosX, LL_PosY, LL_Opacity, LL_MaxPlayers);
			GameObject val6 = new GameObject("SBGL-PseudoDedicatedServer");
			Object.DontDestroyOnLoad((Object)(object)val6);
			PseudoDedicatedServer pseudoDedicatedServer = val6.AddComponent<PseudoDedicatedServer>();
			pseudoDedicatedServer.SetConfig(PDS_Enabled, PDS_RequeueDelay, PDS_DefaultRuleset, ((BaseUnityPlugin)this).Logger);
		}

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

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

		private void SyncConfigToPlayerPrefs()
		{
			PlayerPrefs.SetFloat("CompCheck_X", CompCheck_X.Value);
			PlayerPrefs.SetFloat("CompCheck_Y", CompCheck_Y.Value);
			PlayerPrefs.SetFloat("CompCheck_Width", CompCheck_Width.Value);
			PlayerPrefs.SetFloat("CompCheck_Alpha", CompCheck_Alpha.Value);
			PlayerPrefs.SetInt("CompCheck_HideUIWindow", CompCheck_HideUIWindow.Value ? 1 : 0);
			PlayerPrefs.SetInt("CompCheck_ShowModList", CompCheck_ShowModList.Value ? 1 : 0);
			PlayerPrefs.SetInt("CompCheck_ShowDebugWindow", CompCheck_ShowDebugWindow.Value ? 1 : 0);
			PlayerPrefs.SetFloat("CompCheck_UpdateInterval", CompCheck_UpdateInterval.Value);
			PlayerPrefs.SetString("CompCheck_PlayerId", CompCheck_PlayerId.Value);
			PlayerPrefs.SetFloat("CompCheck_ComplianceX", CompCheck_CompliancePanelX.Value);
			PlayerPrefs.SetFloat("CompCheck_ComplianceY", CompCheck_CompliancePanelY.Value);
			PlayerPrefs.SetInt("MM_ShowSystemLogs", MM_ShowSystemLogs.Value ? 1 : 0);
			PlayerPrefs.SetInt("MM_IgnoreSbglLobbyRequirement", MM_IgnoreSbglLobbyRequirement.Value ? 1 : 0);
			PlayerPrefs.SetFloat("LL_Width", LL_Width.Value);
			PlayerPrefs.SetFloat("LL_MaxHeight", LL_MaxHeight.Value);
			PlayerPrefs.SetFloat("LL_PosX", LL_PosX.Value);
			PlayerPrefs.SetFloat("LL_PosY", LL_PosY.Value);
			PlayerPrefs.SetFloat("LL_Opacity", LL_Opacity.Value);
			PlayerPrefs.SetInt("LL_MaxPlayers", LL_MaxPlayers.Value);
			PlayerPrefs.Save();
		}
	}
	public static class RuleSetManager
	{
		private static ManualLogSource _logger;

		public static void SetLogger(ManualLogSource logger)
		{
			_logger = logger;
		}

		private static void Log(string message)
		{
			if (_logger != null)
			{
				_logger.LogInfo((object)("[RuleSetManager] " + message));
			}
		}

		private static void LogWarning(string message)
		{
			if (_logger != null)
			{
				_logger.LogWarning((object)("[RuleSetManager] " + message));
			}
		}

		private static void LogError(string message)
		{
			if (_logger != null)
			{
				_logger.LogError((object)("[RuleSetManager] " + message));
			}
		}

		public static Dictionary<Rule, float> GetRuleSetForSeason(int season)
		{
			if (season != 1)
			{
				LogWarning($"Season {season} not supported, defaulting to Season 1");
			}
			return Season1RuleSet.GetRulesSettings();
		}

		public static bool ValidateCourseForRanked(string courseName)
		{
			if (string.IsNullOrEmpty(courseName))
			{
				LogError("Course name is null or empty");
				return false;
			}
			bool flag = MapPoolConfig.IsCourseApproved(courseName);
			if (!flag)
			{
				LogWarning("Course '" + courseName + "' is not approved for ranked play");
			}
			return flag;
		}

		public static bool ValidateMatchConfiguration(string matchType, string courseName, int season)
		{
			if (string.IsNullOrEmpty(matchType))
			{
				LogError("Match type is null or empty");
				return false;
			}
			if (string.IsNullOrEmpty(courseName))
			{
				LogError("Course name is null or empty");
				return false;
			}
			if (season != 1)
			{
				LogWarning($"Season {season} not officially supported");
			}
			if (!ValidateCourseForRanked(courseName))
			{
				LogError($"Course '{courseName}' is not approved for ranked season {season}");
				return false;
			}
			if (!matchType.Contains("ranked") && !matchType.Contains("pro_series"))
			{
				LogWarning("Match type '" + matchType + "' may not be a ranked/competitive type");
			}
			return true;
		}

		public static string GetFallbackCourse()
		{
			MapPoolConfig.Course randomApprovedCourse = MapPoolConfig.GetRandomApprovedCourse();
			LogWarning("Using fallback course: " + randomApprovedCourse.Name);
			return randomApprovedCourse.Name;
		}

		public static string ValidateAndGetCourseName(string courseName)
		{
			if (string.IsNullOrEmpty(courseName))
			{
				LogError("Course name is null or empty, using fallback");
				return GetFallbackCourse();
			}
			if (!MapPoolConfig.IsCourseApproved(courseName))
			{
				LogError("Course '" + courseName + "' is not approved, using fallback");
				return GetFallbackCourse();
			}
			return courseName;
		}

		public static void LogMatchConfiguration(string matchType, string courseName, int season)
		{
			Log($"Match Configuration Applied - Type: {matchType}, Course: {courseName}, Season: {season}");
			Log("Course Biome: " + (MapPoolConfig.FindCourseByName(courseName)?.Biome ?? "Unknown"));
			Log("Season 1 Ranked Rules Applied - Wind: Enabled, Comeback: Enabled, Knockouts: Disabled, OutOfBounds: 5s");
		}

		public static bool IsCompetitiveMatch(string matchType)
		{
			if (string.IsNullOrEmpty(matchType))
			{
				return false;
			}
			return matchType.Contains("ranked") || matchType.Contains("pro_series") || matchType.Contains("competitive");
		}
	}
	public static class Season1RuleSet
	{
		public const int SEASON = 1;

		public const string SEASON_ID = "69de6bf4fb103cb0d5eb00c5";

		public const string PRO_SERIES_SEASON_ID = "69b59af135403a1cb7b113c8";

		public const string MATCH_TYPE_CASUAL = "casual";

		public const string MATCH_TYPE_RANKED = "ranked_season_1";

		public const string MATCH_TYPE_PRO_SERIES = "pro_series_season_1";

		public static string BuildRulesDescription(Dictionary<Rule, float> rules)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			foreach (KeyValuePair<Rule, float> rule in rules)
			{
				string text = ValueColor(rule.Value);
				list.Add("<b>" + FormatRuleName(rule.Key) + ":</b> <color=" + text + ">" + FormatRuleValue(rule.Key, rule.Value) + "</color>");
			}
			return string.Join("\n", list);
		}

		public static string BuildBannedItemsDescription()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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)
			HashSet<ItemType> disabledItems = GetDisabledItems();
			if (disabledItems.Count == 0)
			{
				return "None";
			}
			List<string> list = new List<string>();
			foreach (ItemType item in disabledItems)
			{
				list.Add(FormatItemName(item));
			}
			return string.Join(", ", list);
		}

		private static string ValueColor(float value)
		{
			return (value != 0f) ? "#AAFFAA" : "#FFAAAA";
		}

		private static string FormatRuleName(Rule rule)
		{
			string text = ((object)(Rule)(ref rule)).ToString();
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < text.Length; i++)
			{
				if (i > 0 && char.IsUpper(text[i]))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(text[i]);
			}
			return stringBuilder.ToString();
		}

		private static string FormatRuleValue(Rule rule, float value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			if ((int)rule != 0)
			{
				if ((int)rule != 1)
				{
					if ((int)rule == 20)
					{
						if (value == 0f)
						{
							return "Off";
						}
						if (value == 1f)
						{
							return "Low";
						}
						if (value == 2f)
						{
							return "Medium";
						}
						if (value == 3f)
						{
							return "High";
						}
						return value.ToString("G");
					}
					if (value == 0f)
					{
						return "Off";
					}
					if (value == 1f)
					{
						return "On";
					}
					return value.ToString("G");
				}
				return (value == 0f) ? "Off" : $"x{value:G}";
			}
			return (value == 0f) ? "Off" : $"{value:G}s";
		}

		private static string FormatItemName(ItemType item)
		{
			string text = ((object)(ItemType)(ref item)).ToString();
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < text.Length; i++)
			{
				if (i > 0 && char.IsUpper(text[i]))
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(text[i]);
			}
			return stringBuilder.ToString();
		}

		public static HashSet<ItemType> GetDisabledItems()
		{
			return new HashSet<ItemType>
			{
				(ItemType)10,
				(ItemType)11
			};
		}

		public static Dictionary<ItemPoolId, float> GetItemSpawnWeights()
		{
			Dictionary<ItemPoolId, float> w = new Dictionary<ItemPoolId, float>();
			Set(1, (ItemType)8, 20f);
			Set(1, (ItemType)4, 10f);
			Set(1, (ItemType)9, 10f);
			Set(1, (ItemType)2, 35f);
			Set(1, (ItemType)5, 20f);
			Set(1, (ItemType)1, 0f);
			Set(1, (ItemType)3, 0f);
			Set(1, (ItemType)7, 0f);
			Set(1, (ItemType)6, 0f);
			Set(1, (ItemType)10, 0f);
			Set(1, (ItemType)11, 0f);
			Set(1, (ItemType)12, 5f);
			Set(2, (ItemType)8, 0f);
			Set(2, (ItemType)4, 0f);
			Set(2, (ItemType)9, 5f);
			Set(2, (ItemType)2, 0f);
			Set(2, (ItemType)5, 10f);
			Set(2, (ItemType)1, 30f);
			Set(2, (ItemType)3, 20f);
			Set(2, (ItemType)7, 0f);
			Set(2, (ItemType)6, 10f);
			Set(2, (ItemType)10, 0f);
			Set(2, (ItemType)11, 0f);
			Set(2, (ItemType)12, 20f);
			Set(3, (ItemType)8, 0f);
			Set(3, (ItemType)4, 0f);
			Set(3, (ItemType)9, 0f);
			Set(3, (ItemType)2, 0f);
			Set(3, (ItemType)5, 10f);
			Set(3, (ItemType)1, 20f);
			Set(3, (ItemType)3, 0f);
			Set(3, (ItemType)7, 20f);
			Set(3, (ItemType)6, 27.5f);
			Set(3, (ItemType)10, 0f);
			Set(3, (ItemType)11, 0f);
			Set(3, (ItemType)12, 0f);
			Set(4, (ItemType)8, 0f);
			Set(4, (ItemType)4, 0f);
			Set(4, (ItemType)9, 0f);
			Set(4, (ItemType)2, 0f);
			Set(4, (ItemType)5, 0f);
			Set(4, (ItemType)1, 20f);
			Set(4, (ItemType)3, 0f);
			Set(4, (ItemType)7, 20f);
			Set(4, (ItemType)6, 35f);
			Set(4, (ItemType)10, 0f);
			Set(4, (ItemType)11, 0f);
			Set(4, (ItemType)12, 0f);
			Set(5, (ItemType)8, 0f);
			Set(5, (ItemType)4, 0f);
			Set(5, (ItemType)9, 0f);
			Set(5, (ItemType)2, 0f);
			Set(5, (ItemType)5, 30f);
			Set(5, (ItemType)1, 30f);
			Set(5, (ItemType)3, 0f);
			Set(5, (ItemType)7, 0f);
			Set(5, (ItemType)6, 20f);
			Set(5, (ItemType)10, 0f);
			Set(5, (ItemType)11, 0f);
			Set(5, (ItemType)12, 0f);
			Set(0, (ItemType)8, 0f);
			Set(0, (ItemType)4, 0f);
			Set(0, (ItemType)9, 0f);
			Set(0, (ItemType)2, 0f);
			Set(0, (ItemType)5, 33.3f);
			Set(0, (ItemType)1, 66.7f);
			Set(0, (ItemType)3, 0f);
			Set(0, (ItemType)7, 0f);
			Set(0, (ItemType)6, 0f);
			Set(0, (ItemType)10, 0f);
			Set(0, (ItemType)11, 0f);
			Set(0, (ItemType)12, 0f);
			return w;
			void Set(int pool, ItemType item, float weight)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				w[ItemPoolId.Get(pool, item)] = weight;
			}
		}

		public static Dictionary<Rule, float> GetProSeriesRulesSettings()
		{
			return new Dictionary<Rule, float>
			{
				{
					(Rule)20,
					1f
				},
				{
					(Rule)16,
					0f
				},
				{
					(Rule)19,
					0f
				}
			};
		}

		public static Dictionary<Rule, float> GetRulesSettings()
		{
			return new Dictionary<Rule, float>
			{
				{
					(Rule)20,
					1f
				},
				{
					(Rule)9,
					1f
				},
				{
					(Rule)10,
					0f
				},
				{
					(Rule)16,
					0f
				},
				{
					(Rule)12,
					1f
				},
				{
					(Rule)13,
					1f
				},
				{
					(Rule)14,
					1f
				},
				{
					(Rule)15,
					0f
				},
				{
					(Rule)1,
					5f
				},
				{
					(Rule)11,
					0f
				},
				{
					(Rule)0,
					45f
				},
				{
					(Rule)2,
					0f
				},
				{
					(Rule)3,
					1f
				},
				{
					(Rule)4,
					1f
				},
				{
					(Rule)5,
					1f
				},
				{
					(Rule)6,
					1f
				},
				{
					(Rule)7,
					1f
				},
				{
					(Rule)8,
					1f
				},
				{
					(Rule)17,
					1f
				},
				{
					(Rule)18,
					1f
				},
				{
					(Rule)19,
					0f
				}
			};
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}