using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Utilities;
using Il2CppTMPro;
using MatchInfo;
using MelonLoader;
using Microsoft.CodeAnalysis;
using RumbleModUI;
using RumbleModdingAPI;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Main), "MatchInfo", "2.2.0", "UlvakSkillz", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 195, 0, 255)]
[assembly: MelonAuthorColor(255, 195, 0, 255)]
[assembly: VerifyLoaderVersion(0, 6, 6, true)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("MatchInfo")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MatchInfo")]
[assembly: AssemblyTitle("MatchInfo")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace MatchInfo
{
	public static class BuildInfo
	{
		public const string ModName = "MatchInfo";

		public const string ModVersion = "2.2.0";

		public const string Author = "UlvakSkillz";
	}
	public class Main : MelonMod
	{
		[CompilerGenerated]
		private sealed class <MatchStarted>d__51 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Main <>4__this;

			private bool <won>5__1;

			private string <winOrLose>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f6: Expected O, but got Unknown
				//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;
					break;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (<>4__this.matchActive)
				{
					if (!<>4__this.ranWinLoss && Singleton<PlayerManager>.instance.AllPlayers.Count == 2 && <>4__this.MatchSlabOne.active)
					{
						<won>5__1 = false;
						<winOrLose>5__2 = "Unlocalized Entry!";
						if (Players.IsHost())
						{
							<winOrLose>5__2 = ((TMP_Text)<>4__this.Slab1Text).text;
						}
						else
						{
							<winOrLose>5__2 = ((TMP_Text)<>4__this.Slab2Text).text;
						}
						if (<winOrLose>5__2 == "Unlocalized Entry!")
						{
							<>2__current = (object)new WaitForFixedUpdate();
							<>1__state = 1;
							return true;
						}
						if (<winOrLose>5__2 == "Victory!")
						{
							<won>5__1 = true;
						}
						else
						{
							<won>5__1 = false;
						}
						if (<won>5__1)
						{
							<>4__this.fileText[<>4__this.playerFileSpot + 1] = (int.Parse(<>4__this.fileText[<>4__this.playerFileSpot + 1]) + 1).ToString();
							((TMP_Text)player2MatchWinsComponent).text = <>4__this.fileText[<>4__this.playerFileSpot + 1] + " Wins";
						}
						else
						{
							<>4__this.fileText[<>4__this.playerFileSpot + 2] = (int.Parse(<>4__this.fileText[<>4__this.playerFileSpot + 2]) + 1).ToString();
							((TMP_Text)player1MatchWinsComponent).text = <>4__this.fileText[<>4__this.playerFileSpot + 2] + " Wins";
						}
						((TMP_Text)player2BPComponent).text = Singleton<PlayerManager>.instance.AllPlayers[0].Data.GeneralData.BattlePoints + " BP";
						((TMP_Text)player1BPComponent).text = Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.BattlePoints + " BP";
						<>4__this.ranWinLoss = true;
						File.WriteAllLines(<>4__this.FILEPATH + "\\" + <>4__this.FILENAME, <>4__this.fileText);
						<winOrLose>5__2 = null;
					}
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 2;
					return true;
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public Main <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(7f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (<>4__this.currentScene == "Map0")
					{
						matchInfoGameObject.transform.position = new Vector3(-1f, -0.5f, 20.5f);
						matchInfoGameObject.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
					}
					else if (<>4__this.currentScene == "Map1")
					{
						matchInfoGameObject.transform.position = new Vector3(0f, 5.25f, 11f);
						matchInfoGameObject.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
					}
					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 <OnePlayerFound>d__53 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Main <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(4f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					matchInfoGameObject.SetActive(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();
			}
		}

		private string currentScene = "Loader";

		public Mod MatchInfo = new Mod();

		public bool enabled = true;

		private bool init = false;

		private bool backedUp = false;

		private string FILEPATH = "UserData\\MatchInfo";

		private string FILENAME = "MatchInfo.txt";

		private string BACKUPFILENAME = "MatchInfo_Backup";

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

		public static GameObject matchInfoGameObject;

		public static GameObject player1GameObject;

		public static GameObject player2GameObject;

		public static GameObject vsGameObject;

		public static GameObject player1BPGameObject;

		public static GameObject player2BPGameObject;

		public static GameObject player1MatchWinsGameObject;

		public static GameObject player2MatchWinsGameObject;

		public static TextMeshPro player1Component;

		public static TextMeshPro player2Component;

		public static TextMeshPro vsComponent;

		public static TextMeshPro player1BPComponent;

		public static TextMeshPro player2BPComponent;

		public static TextMeshPro player1MatchWinsComponent;

		public static TextMeshPro player2MatchWinsComponent;

		public static GameObject gymMatchInfoGameObject;

		public static GameObject gymMatchInfoTotalGameObject;

		public static GameObject gymMatchInfoWinsGameObject;

		public static GameObject gymMatchInfoLossesGameObject;

		public static GameObject gymMatchInfoWinPercentGameObject;

		public static TextMeshPro gymMatchInfoTitleComponent;

		public static TextMeshPro gymMatchInfoTotalComponent;

		public static TextMeshPro gymMatchInfoWinsComponent;

		public static TextMeshPro gymMatchInfoLossesComponent;

		public static TextMeshPro gymMatchInfoWinPercentComponent;

		private bool matchActive = false;

		private bool showGymInfo = true;

		private bool showMatchInfo = true;

		private GameObject MatchSlabOne;

		private TextMeshPro Slab1Text;

		private TextMeshPro Slab2Text;

		private int playerFileSpot = 0;

		private bool ranWinLoss = true;

		public static void Log(string msg)
		{
			MelonLogger.Msg(msg);
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			currentScene = sceneName;
		}

		public override void OnLateInitializeMelon()
		{
			Calls.onMapInitialized += mapLoaded;
			UI.instance.UI_Initialized += UIInit;
			CheckFiles();
		}

		private void CheckFiles()
		{
			if (!Directory.Exists(FILEPATH))
			{
				Log("Folder Not Found, Creating Folder: " + FILEPATH);
				Directory.CreateDirectory(FILEPATH);
			}
			if (!File.Exists(FILEPATH + "\\" + FILENAME))
			{
				Log("Creating File " + FILENAME);
				File.Create(FILEPATH + "\\" + FILENAME);
			}
			if (!Directory.Exists(FILEPATH + "\\Backups"))
			{
				Log("Folder Not Found, Creating Folder: " + FILEPATH + "\\Backups");
				Directory.CreateDirectory(FILEPATH + "\\Backups");
			}
			if (!File.Exists(FILEPATH + "\\Backups\\" + BACKUPFILENAME + "1.txt"))
			{
				Log("Creating File " + BACKUPFILENAME + "1.txt");
				saveFile("", FILEPATH + "\\Backups\\" + BACKUPFILENAME + "1.txt");
			}
			if (!File.Exists(FILEPATH + "\\Backups\\" + BACKUPFILENAME + "2.txt"))
			{
				Log("Creating File " + BACKUPFILENAME + "2.txt");
				saveFile("", FILEPATH + "\\Backups\\" + BACKUPFILENAME + "2.txt");
			}
			if (!File.Exists(FILEPATH + "\\Backups\\" + BACKUPFILENAME + "3.txt"))
			{
				Log("Creating File " + BACKUPFILENAME + "3.txt");
				saveFile("", FILEPATH + "\\Backups\\" + BACKUPFILENAME + "3.txt");
			}
			string[] array = ReadFileText(FILEPATH, FILENAME);
			string[] array2 = array;
			foreach (string item in array2)
			{
				fileText.Add(item);
			}
		}

		public static string[] ReadFileText(string filePath, string fileName)
		{
			try
			{
				return File.ReadAllLines(filePath + "\\" + fileName);
			}
			catch (Exception ex)
			{
				MelonLogger.Error((object)ex);
			}
			return null;
		}

		private void saveFile(string textToSave, string file)
		{
			FileStream fileStream = File.Create(file);
			byte[] bytes = Encoding.UTF8.GetBytes(textToSave);
			fileStream.Write(bytes);
			fileStream.Close();
			fileStream.Dispose();
		}

		private void UIInit()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			MatchInfo.ModName = "MatchInfo";
			MatchInfo.ModVersion = "2.2.0";
			MatchInfo.SetFolder("MatchInfo");
			MatchInfo.AddToList("Show Gym Info", true, 0, "Toggles Mod Info in Gym On/Off", new Tags());
			MatchInfo.AddToList("Show Win/Loss in Match", true, 0, "Toggles Mod Info in Matches", new Tags());
			MatchInfo.GetFromFile();
			MatchInfo.ModSaved += Save;
			UI.instance.AddMod(MatchInfo);
			Save();
		}

		public void Save()
		{
			showGymInfo = (bool)MatchInfo.Settings[0].SavedValue;
			showMatchInfo = (bool)MatchInfo.Settings[1].SavedValue;
			if (currentScene == "Gym")
			{
				gymMatchInfoGameObject.SetActive(showGymInfo);
			}
			else if ((currentScene == "Map0" || currentScene == "Map1") && !showMatchInfo)
			{
				player1MatchWinsGameObject.SetActive(showMatchInfo);
				player2MatchWinsGameObject.SetActive(showMatchInfo);
			}
		}

		public void mapLoaded()
		{
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: 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)
			if (currentScene == "Gym")
			{
				if (!init)
				{
					RunInit();
				}
				matchInfoGameObject.SetActive(false);
				gymMatchInfoGameObject.SetActive(true);
				CountWinLoss();
				if (!showGymInfo)
				{
					gymMatchInfoGameObject.SetActive(false);
				}
				matchActive = false;
			}
			else
			{
				gymMatchInfoGameObject.SetActive(false);
			}
			if (!(currentScene == "Map0") && !(currentScene == "Map1"))
			{
				return;
			}
			matchInfoGameObject.SetActive(true);
			try
			{
				if (currentScene == "Map0")
				{
					MatchSlabOne = MatchFormCanvas.GetGameObject();
					Slab1Text = MatchText.GetGameObject().GetComponent<TextMeshPro>();
					Slab2Text = MatchText.GetGameObject().GetComponent<TextMeshPro>();
				}
				else if (currentScene == "Map1")
				{
					MatchSlabOne = MatchFormCanvas.GetGameObject();
					Slab1Text = MatchText.GetGameObject().GetComponent<TextMeshPro>();
					Slab2Text = MatchText.GetGameObject().GetComponent<TextMeshPro>();
				}
			}
			catch
			{
				return;
			}
			if (Players.IsHost())
			{
				matchInfoGameObject.transform.position = new Vector3(-3f, 3f, 0f);
				matchInfoGameObject.transform.rotation = Quaternion.Euler(0f, -90f, 0f);
			}
			else
			{
				matchInfoGameObject.transform.position = new Vector3(3f, 3f, 0f);
				matchInfoGameObject.transform.rotation = Quaternion.Euler(0f, 90f, 0f);
			}
			((TMP_Text)player2Component).text = Singleton<PlayerManager>.instance.AllPlayers[0].Data.GeneralData.PublicUsername;
			if (Singleton<PlayerManager>.instance.AllPlayers[0].Data.GeneralData.PlayFabMasterId == "5832566FD2375E31")
			{
				((TMP_Text)player2Component).text = "<#990099>U<#ff00ff>l<#ff66ff>v<#cc66ff>a<#9966ff>k<#6666ff>S<#3366ff>k<#6699ff>i<#809fff>l<#b3c6ff>l<#e6ecff>z";
			}
			((TMP_Text)player2BPComponent).text = Singleton<PlayerManager>.instance.AllPlayers[0].Data.GeneralData.BattlePoints + " BP";
			if (Singleton<PlayerManager>.instance.AllPlayers.Count > 1)
			{
				((TMP_Text)player1Component).text = Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername;
				if (Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId == "5832566FD2375E31")
				{
					((TMP_Text)player1Component).text = "<#990099>U<#ff00ff>l<#ff66ff>v<#cc66ff>a<#9966ff>k<#6666ff>S<#3366ff>k<#6699ff>i<#809fff>l<#b3c6ff>l<#e6ecff>z";
				}
				((TMP_Text)player1BPComponent).text = Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.BattlePoints + " BP";
				bool flag = false;
				for (int i = 0; i < fileText.Count; i += 3)
				{
					if (fileText[i].Contains(Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId))
					{
						if (fileText[i] == Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId)
						{
							List<string> list = fileText;
							int index = i;
							list[index] = list[index] + " - " + Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername;
						}
						else if (!fileText[i].Contains(Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername))
						{
							fileText[i] = Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId + " - " + Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername;
						}
						playerFileSpot = i;
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					fileText.Add(Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId + " - " + Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername);
					fileText.Add("0");
					fileText.Add("0");
					playerFileSpot = fileText.Count - 3;
				}
				player1MatchWinsGameObject.SetActive(true);
				player2MatchWinsGameObject.SetActive(true);
				((TMP_Text)player1MatchWinsComponent).text = fileText[playerFileSpot + 2] + " Wins";
				((TMP_Text)player2MatchWinsComponent).text = fileText[playerFileSpot + 1] + " Wins";
				if (!showMatchInfo)
				{
					player1MatchWinsGameObject.SetActive(false);
					player2MatchWinsGameObject.SetActive(false);
				}
				matchActive = true;
				ranWinLoss = false;
				MelonCoroutines.Start(MoveSign());
				MelonCoroutines.Start(MatchStarted());
			}
			else
			{
				MelonCoroutines.Start(OnePlayerFound());
			}
		}

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

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

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

		public void CountWinLoss()
		{
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < fileText.Count; i += 3)
			{
				num += int.Parse(fileText[i + 1]);
				num2 += int.Parse(fileText[i + 2]);
			}
			((TMP_Text)gymMatchInfoTotalComponent).text = "Total: " + (num + num2);
			((TMP_Text)gymMatchInfoWinsComponent).text = "Wins: " + num;
			((TMP_Text)gymMatchInfoLossesComponent).text = "Losses: " + num2;
			((TMP_Text)gymMatchInfoWinPercentComponent).text = "Win Rate: " + (float)(int)((float)num / (float)(num + num2) * 10000f) / 100f + "%";
			if (num + num2 == 0)
			{
				((TMP_Text)gymMatchInfoWinPercentComponent).text = "Win Rate: N/A";
			}
		}

		private void RunInit()
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_070f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0733: Unknown result type (might be due to invalid IL or missing references)
			//IL_0757: Unknown result type (might be due to invalid IL or missing references)
			//IL_077b: Unknown result type (might be due to invalid IL or missing references)
			//IL_079f: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_080b: Unknown result type (might be due to invalid IL or missing references)
			//IL_082f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0853: Unknown result type (might be due to invalid IL or missing references)
			if (!backedUp)
			{
				Log("Backing up File 2 -> 3");
				File.Copy(FILEPATH + "\\Backups\\" + BACKUPFILENAME + "2.txt", FILEPATH + "\\Backups\\" + BACKUPFILENAME + "3.txt", overwrite: true);
				Log("Backing up File 1 -> 2");
				File.Copy(FILEPATH + "\\Backups\\" + BACKUPFILENAME + "1.txt", FILEPATH + "\\Backups\\" + BACKUPFILENAME + "2.txt", overwrite: true);
				Log("Backing up File MatchInfo.txt -> 1");
				File.Copy(FILEPATH + "\\" + FILENAME, FILEPATH + "\\Backups\\" + BACKUPFILENAME + "1.txt", overwrite: true);
				backedUp = true;
			}
			matchInfoGameObject = new GameObject();
			((Object)matchInfoGameObject).name = "MatchInfoMod";
			matchInfoGameObject.SetActive(false);
			player1GameObject = Object.Instantiate<GameObject>(Nr.GetGameObject());
			player1GameObject.transform.parent = matchInfoGameObject.transform;
			((Object)player1GameObject).name = "Player1Name";
			player1Component = player1GameObject.GetComponent<TextMeshPro>();
			((TMP_Text)player1Component).text = "name";
			((TMP_Text)player1Component).fontSize = 5f;
			((TMP_Text)player1Component).color = new Color(1f, 1f, 1f, 1f);
			((TMP_Text)player1Component).outlineColor = Color32.op_Implicit(new Color(0f, 0f, 0f, 0.5f));
			((TMP_Text)player1Component).alignment = (TextAlignmentOptions)516;
			((TMP_Text)player1Component).enableWordWrapping = false;
			((TMP_Text)player1Component).outlineWidth = 0.1f;
			player2GameObject = Object.Instantiate<GameObject>(player1GameObject);
			player2GameObject.transform.parent = matchInfoGameObject.transform;
			((Object)player2GameObject).name = "Player2Name";
			player2Component = player2GameObject.GetComponent<TextMeshPro>();
			((TMP_Text)player2Component).alignment = (TextAlignmentOptions)513;
			vsGameObject = Object.Instantiate<GameObject>(player2GameObject);
			vsGameObject.transform.parent = matchInfoGameObject.transform;
			((Object)vsGameObject).name = "VSText";
			vsComponent = vsGameObject.GetComponent<TextMeshPro>();
			((TMP_Text)vsComponent).alignment = (TextAlignmentOptions)514;
			((TMP_Text)vsComponent).color = new Color(0f, 0f, 0f, 1f);
			((TMP_Text)vsComponent).text = "vs";
			((TMP_Text)vsComponent).fontSize = 3.5f;
			player1BPGameObject = Object.Instantiate<GameObject>(player2GameObject);
			player1BPGameObject.transform.parent = matchInfoGameObject.transform;
			((Object)player1BPGameObject).name = "Player1BP";
			player1BPComponent = player1BPGameObject.GetComponent<TextMeshPro>();
			((TMP_Text)player1BPComponent).alignment = (TextAlignmentOptions)514;
			((TMP_Text)player1BPComponent).text = "P1BP";
			((TMP_Text)player1BPComponent).fontSize = 4f;
			player2BPGameObject = Object.Instantiate<GameObject>(player2GameObject);
			player2BPGameObject.transform.parent = matchInfoGameObject.transform;
			((Object)player2BPGameObject).name = "Player2BP";
			player2BPComponent = player2BPGameObject.GetComponent<TextMeshPro>();
			((TMP_Text)player2BPComponent).alignment = (TextAlignmentOptions)514;
			((TMP_Text)player2BPComponent).text = "P2BP";
			((TMP_Text)player2BPComponent).fontSize = 4f;
			player1MatchWinsGameObject = Object.Instantiate<GameObject>(player1BPGameObject);
			player1MatchWinsGameObject.transform.parent = matchInfoGameObject.transform;
			((Object)player1MatchWinsGameObject).name = "P1Wins";
			player1MatchWinsComponent = player1MatchWinsGameObject.GetComponent<TextMeshPro>();
			((TMP_Text)player1MatchWinsComponent).alignment = (TextAlignmentOptions)514;
			((TMP_Text)player1MatchWinsComponent).text = "0 Wins";
			((TMP_Text)player1MatchWinsComponent).color = new Color(1f, 1f, 1f, 1f);
			player2MatchWinsGameObject = Object.Instantiate<GameObject>(player1MatchWinsGameObject);
			player2MatchWinsGameObject.transform.parent = matchInfoGameObject.transform;
			((Object)player2MatchWinsGameObject).name = "P2Wins";
			player2MatchWinsComponent = player2MatchWinsGameObject.GetComponent<TextMeshPro>();
			((TMP_Text)player2MatchWinsComponent).alignment = (TextAlignmentOptions)514;
			((TMP_Text)player2MatchWinsComponent).text = "0 Wins";
			gymMatchInfoGameObject = Object.Instantiate<GameObject>(player1GameObject);
			((Object)gymMatchInfoGameObject).name = "GymMatchInfo";
			gymMatchInfoTitleComponent = gymMatchInfoGameObject.GetComponent<TextMeshPro>();
			((TMP_Text)gymMatchInfoTitleComponent).alignment = (TextAlignmentOptions)513;
			((TMP_Text)gymMatchInfoTitleComponent).text = "Match History";
			((TMP_Text)gymMatchInfoTitleComponent).fontSize = 3.5f;
			gymMatchInfoTotalGameObject = Object.Instantiate<GameObject>(gymMatchInfoGameObject);
			gymMatchInfoTotalGameObject.transform.parent = gymMatchInfoGameObject.transform;
			((Object)gymMatchInfoTotalGameObject).name = "Total";
			gymMatchInfoTotalComponent = gymMatchInfoTotalGameObject.GetComponent<TextMeshPro>();
			((TMP_Text)gymMatchInfoTotalComponent).text = "Total: ";
			gymMatchInfoWinsGameObject = Object.Instantiate<GameObject>(gymMatchInfoTotalGameObject);
			gymMatchInfoWinsGameObject.transform.parent = gymMatchInfoGameObject.transform;
			((Object)gymMatchInfoWinsGameObject).name = "Wins";
			gymMatchInfoWinsComponent = gymMatchInfoWinsGameObject.GetComponent<TextMeshPro>();
			((TMP_Text)gymMatchInfoWinsComponent).text = "Wins: ";
			gymMatchInfoLossesGameObject = Object.Instantiate<GameObject>(gymMatchInfoTotalGameObject);
			gymMatchInfoLossesGameObject.transform.parent = gymMatchInfoGameObject.transform;
			((Object)gymMatchInfoLossesGameObject).name = "Losses";
			gymMatchInfoLossesComponent = gymMatchInfoLossesGameObject.GetComponent<TextMeshPro>();
			((TMP_Text)gymMatchInfoLossesComponent).text = "Losses: ";
			gymMatchInfoWinPercentGameObject = Object.Instantiate<GameObject>(gymMatchInfoTotalGameObject);
			gymMatchInfoWinPercentGameObject.transform.parent = gymMatchInfoGameObject.transform;
			((Object)gymMatchInfoWinPercentGameObject).name = "WinPercent";
			gymMatchInfoWinPercentComponent = gymMatchInfoWinPercentGameObject.GetComponent<TextMeshPro>();
			((TMP_Text)gymMatchInfoWinPercentComponent).text = "Win Rate: ";
			player1GameObject.transform.position = new Vector3(-0.75f, 1f, 0f);
			player1BPGameObject.transform.position = new Vector3(-1.25f, 0.5f, 0f);
			vsGameObject.transform.position = new Vector3(0f, 0.75f, 0f);
			player2GameObject.transform.position = new Vector3(0.75f, 1f, 0f);
			player2BPGameObject.transform.position = new Vector3(1.25f, 0.5f, 0f);
			player1MatchWinsGameObject.transform.position = new Vector3(-1.25f, 0f, 0f);
			player2MatchWinsGameObject.transform.position = new Vector3(1.25f, 0f, 0f);
			gymMatchInfoGameObject.transform.position = new Vector3(5.5236f, 2.75f, 11.3364f);
			gymMatchInfoGameObject.transform.rotation = Quaternion.Euler(0f, 30.5f, 0f);
			gymMatchInfoTotalGameObject.transform.localPosition = new Vector3(0.0334f, -0.3f, -0.0012f);
			gymMatchInfoWinsGameObject.transform.localPosition = new Vector3(0.0334f, -0.6f, -0.0012f);
			gymMatchInfoLossesGameObject.transform.localPosition = new Vector3(0.0334f, -0.9f, -0.0012f);
			gymMatchInfoWinPercentGameObject.transform.localPosition = new Vector3(0.0334f, -1.2f, -0.0012f);
			gymMatchInfoGameObject.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)matchInfoGameObject);
			Object.DontDestroyOnLoad((Object)(object)gymMatchInfoGameObject);
			init = true;
			Log("Initialized");
		}
	}
}