using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using HarmonyLib;
using Il2CppExitGames.Client.Photon;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppPhoton.Pun;
using Il2CppPhoton.Realtime;
using Il2CppRUMBLE.Audio;
using Il2CppRUMBLE.Environment.Matchmaking;
using Il2CppRUMBLE.Interactions.InteractionBase;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Players;
using Il2CppRUMBLE.Players.Subsystems;
using Il2CppRUMBLE.Pools;
using Il2CppRUMBLE.Utilities;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.IO;
using Il2CppSystem.Reflection;
using Il2CppTMPro;
using MelonLoader;
using RumbleModdingAPI;
using RumbleModdingAPI.RMAPI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(global::RumbleModdingAPI.RumbleModdingAPI), "RumbleModdingAPI", "5.1.1", "UlvakSkillz", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 195, 0, 255)]
[assembly: MelonAuthorColor(255, 195, 0, 255)]
[assembly: VerifyLoaderVersion(0, 7, 2, true)]
[assembly: AssemblyDescription("")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("1ae819fd-d86a-44b0-bc6b-aee140e7ca82")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("RumbleModdingAPI")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+049688b95e54526eae962ff1cb5e1004aca06eb6")]
[assembly: AssemblyProduct("RumbleModdingAPI")]
[assembly: AssemblyTitle("RumbleModdingAPI")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace RumbleModdingAPI
{
	public static class ModBuildInfo
	{
		public const string Version = "5.1.1";
	}
	public class ModInfo
	{
		public string ModName;

		public string ModVersion;

		public ModInfo(string name, string version)
		{
			ModName = name;
			ModVersion = version;
		}
	}
	public class RumbleModdingAPI : MelonMod
	{
		[HarmonyPatch(typeof(MatchmakeConsole), "MatchmakeStatusUpdated", new Type[] { typeof(MatchmakeStatus) })]
		public static class MatchmakingType
		{
			private static void Prefix(GameObject __instance, MatchmakeStatus status)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0004: Invalid comparison between Unknown and I4
				if ((int)status == 9)
				{
					matchmakingType = ((InteractionNumericalBase)GameObjects.Gym.INTERACTABLES.MatchConsole.MatchmakingSettings.InteractionSliderHorizontalGrip.Sliderhandle.GetGameObject().GetComponent<InteractionSlider>()).snappedStep;
				}
			}
		}

		[HarmonyPatch(typeof(PlayerController), "Initialize", new Type[] { typeof(Player) })]
		public static class PlayerSpawn
		{
			private static void Postfix(ref PlayerController __instance, ref Player player)
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Invalid comparison between Unknown and I4
				if (player.Data.GeneralData.PlayFabMasterId == "5832566FD2375E31" && Singleton<PlayerManager>.instance.localPlayer != player)
				{
					MelonCoroutines.Start(WaitForTitleLoad(player));
				}
				if ((int)__instance.controllerType == 1)
				{
					MelonCoroutines.Start(AddModsToLocalProps());
				}
				Actions.TriggerOnPlayerSpawned(player);
			}
		}

		[HarmonyPatch(typeof(PlayerNameTag), "FadePlayerNameTag", new Type[] { typeof(bool) })]
		public static class UpdatePlayerTitleText
		{
			private static void Postfix(ref PlayerNameTag __instance, ref bool on)
			{
				if (on)
				{
					MelonCoroutines.Start(UpdateTitle(__instance));
				}
			}
		}

		[HarmonyPatch(typeof(PlayerNameTag), "UpdatePlayerTitleText", new Type[] { })]
		public static class UpdatePlayerBPText
		{
			private static void Postfix(ref PlayerNameTag __instance)
			{
				MelonCoroutines.Start(UpdateTitle(__instance));
			}
		}

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

			private object <>2__current;

			private string <sceneName>5__1;

			private Player <local>5__2;

			private Hashtable <table>5__3;

			private IEnumerator<MelonMod> <>s__4;

			private MelonMod <mod>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<sceneName>5__1 = null;
				<local>5__2 = null;
				<table>5__3 = null;
				<>s__4 = null;
				<mod>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Expected O, but got Unknown
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<sceneName>5__1 = Calls.Scene.GetSceneName();
					if (<sceneName>5__1 == "Gym" || <sceneName>5__1 == "Loader")
					{
						return false;
					}
					<local>5__2 = null;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				while (<local>5__2 == null)
				{
					try
					{
						<local>5__2 = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject.GetComponent<PhotonView>().Owner;
					}
					catch
					{
					}
					if (<local>5__2 == null)
					{
						<>2__current = (object)new WaitForFixedUpdate();
						<>1__state = 1;
						return true;
					}
				}
				<table>5__3 = new Hashtable();
				<>s__4 = MelonTypeBase<MelonMod>.RegisteredMelons.GetEnumerator();
				try
				{
					while (<>s__4.MoveNext())
					{
						<mod>5__5 = <>s__4.Current;
						<table>5__3[Object.op_Implicit(((MelonBase)<mod>5__5).Info.Name)] = Object.op_Implicit(((MelonBase)<mod>5__5).Info.Version);
						<mod>5__5 = null;
					}
				}
				finally
				{
					if (<>s__4 != null)
					{
						<>s__4.Dispose();
					}
				}
				<>s__4 = null;
				<local>5__2.SetCustomProperties(<table>5__3, (Hashtable)null, (WebFlags)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 <UpdateTitle>d__52 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerNameTag __instance;

			private TMP_Text <titleTextMeshPro>5__1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<titleTextMeshPro>5__1 = null;
				<>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(0.25f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					try
					{
						if (((Component)((Component)__instance).transform.parent).GetComponent<PlayerController>().AssignedPlayer.Data.GeneralData.PlayFabMasterId == "5832566FD2375E31")
						{
							<titleTextMeshPro>5__1 = __instance.playerTitleText;
							<titleTextMeshPro>5__1.text = "GrassBender";
							<titleTextMeshPro>5__1 = null;
						}
					}
					catch
					{
					}
					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 <WaitATickThemTriggerOnMyModsGathered>d__39 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RumbleModdingAPI <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Actions.TriggerOnMyModsGathered();
					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 <WaitForTitleLoad>d__53 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			private PlayerNameTag <playerNameTag>5__1;

			private bool <worked>5__2;

			private TMP_Text <titleTextMeshPro>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
				}
				else
				{
					<>1__state = -1;
					<playerNameTag>5__1 = ((Component)((Component)player.Controller).transform.GetChild(9)).GetComponent<PlayerNameTag>();
					<worked>5__2 = true;
					<titleTextMeshPro>5__3 = null;
					try
					{
						<titleTextMeshPro>5__3 = <playerNameTag>5__1.playerTitleText;
					}
					catch
					{
						<worked>5__2 = false;
					}
					if (!<worked>5__2)
					{
						goto IL_00c6;
					}
				}
				if (<titleTextMeshPro>5__3.text == "Player Title")
				{
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				}
				<titleTextMeshPro>5__3.text = "GrassBender";
				goto IL_00c6;
				IL_00c6:
				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 static readonly bool debug = false;

		public static MelonMod instance;

		internal static byte myEventCode = 15;

		internal static RaiseEventOptions eventOptions = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)0,
			CachingOption = (EventCaching)4
		};

		internal static bool EventSent = false;

		internal static List<ModInfo> myMods = new List<ModInfo>();

		internal static string myModString;

		internal static List<ModInfo> opponentMods = new List<ModInfo>();

		internal static string opponentModString;

		internal static string currentScene = "";

		internal static string lastScene = "";

		internal static bool init = false;

		internal static bool mapInit = false;

		internal static GameObject[] allBaseDDOLGameObjects = (GameObject[])(object)new GameObject[4];

		internal static GameObject[] allBaseGymGameObjects = (GameObject[])(object)new GameObject[8];

		internal static GameObject[] allBaseParkGameObjects = (GameObject[])(object)new GameObject[7];

		internal static GameObject[] allBaseMap0GameObjects = (GameObject[])(object)new GameObject[3];

		internal static GameObject[] allBaseMap1GameObjects = (GameObject[])(object)new GameObject[4];

		internal static GameObject parentAPIItems;

		private static readonly InputActionMap map = new InputActionMap("InputMap");

		internal static InputAction rightTrigger = InputActionSetupExtensions.AddAction(map, "Right Trigger", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction rightPrimary = InputActionSetupExtensions.AddAction(map, "Right Primary", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction rightSecondary = InputActionSetupExtensions.AddAction(map, "Right Secondary", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction rightGrip = InputActionSetupExtensions.AddAction(map, "Right Grip", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction rightJoystick = InputActionSetupExtensions.AddAction(map, "Right Joystick", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction rightJoystickClick = InputActionSetupExtensions.AddAction(map, "Right Joystick Click", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftTrigger = InputActionSetupExtensions.AddAction(map, "Left Trigger", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftPrimary = InputActionSetupExtensions.AddAction(map, "Left Primary", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftSecondary = InputActionSetupExtensions.AddAction(map, "Left Secondary", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftGrip = InputActionSetupExtensions.AddAction(map, "Left Grip", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftJoystick = InputActionSetupExtensions.AddAction(map, "Left Joystick", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftJoystickClick = InputActionSetupExtensions.AddAction(map, "Left Joystick Click", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static int matchmakingType = 0;

		internal GameObject RMLManager;

		internal static void Log(string msg, bool useDebug = false)
		{
			if (!useDebug || debug)
			{
				Melon<RumbleModdingAPI>.Logger.Msg(msg);
			}
		}

		internal static void Error(Exception e)
		{
			Melon<RumbleModdingAPI>.Logger.Error("Error: " + e);
		}

		public override void OnLateInitializeMelon()
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			instance = (MelonMod)(object)this;
			InputActionSetupExtensions.AddBinding(rightTrigger, "<XRController>{RightHand}/trigger", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(rightPrimary, "<XRController>{RightHand}/primaryButton", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(rightSecondary, "<XRController>{RightHand}/secondaryButton", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(rightGrip, "<XRController>{RightHand}/Grip", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(rightJoystick, "<XRController>{RightHand}/primary2DAxis", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(rightJoystickClick, "<XRController>{RightHand}/joystickClicked", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftTrigger, "<XRController>{LeftHand}/trigger", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftPrimary, "<XRController>{LeftHand}/primaryButton", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftSecondary, "<XRController>{LeftHand}/secondaryButton", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftGrip, "<XRController>{LeftHand}/Grip", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftJoystick, "<XRController>{LeftHand}/primary2DAxis", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftJoystickClick, "<XRController>{LeftHand}/joystickClicked", (string)null, (string)null, (string)null);
			map.Enable();
			CreateMyModString();
			PhotonRPCs.PhotonRpcInjector.Initialize();
			RMLManager = new GameObject("Manager component holder (Rumble Modding Library)");
			RMLManager.AddComponent<Utilities.RaiseEventManager>();
			RMLManager.AddComponent<Utilities.ControllerInputManager>();
			RMLManager.AddComponent<Utilities.DoNotDisable>();
			Object.DontDestroyOnLoad((Object)(object)RMLManager);
		}

		private static void CreateMyModString()
		{
			myModString = "";
			for (int i = 0; i < MelonBase.RegisteredMelons.Count; i++)
			{
				ModInfo modInfo = new ModInfo(MelonBase.RegisteredMelons[i].Info.Name, MelonBase.RegisteredMelons[i].Info.Version);
				myMods.Add(modInfo);
				if (i > 0)
				{
					myModString += "|";
				}
				myModString = myModString + modInfo.ModName + "|" + modInfo.ModVersion;
			}
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			lastScene = currentScene;
			currentScene = sceneName;
			mapInit = false;
			EventSent = false;
			Actions.sceneCount++;
			try
			{
				if (currentScene == "Loader")
				{
					if (!init)
					{
						GrabBaseDDOLObjects();
						init = true;
						Log("API Initialized");
						Log("API By UlvakSkillz. Consider Donating to Their KoFi: https://ko-fi.com/ulvakskillz");
						MelonCoroutines.Start(WaitATickThemTriggerOnMyModsGathered());
					}
				}
				else if (currentScene == "Gym" && !mapInit)
				{
					GrabBaseGymObjects();
					LoadBalancingClient networkingClient = PhotonNetwork.NetworkingClient;
					networkingClient.EventReceived += Action<EventData>.op_Implicit((Action<EventData>)OnEvent);
					Create.SetupAPIItems();
					mapInit = true;
				}
				else if (currentScene == "Park" && !mapInit)
				{
					GrabBaseParkObjects();
					mapInit = true;
				}
				else if (currentScene == "Map0" && !mapInit)
				{
					GrabBaseMap0Objects();
					mapInit = true;
				}
				else if (currentScene == "Map1" && !mapInit)
				{
					GrabBaseMap1Objects();
					mapInit = true;
				}
				if (mapInit)
				{
					MelonCoroutines.Start(Actions.StartActionWatcher());
				}
			}
			catch (Exception e)
			{
				Error(e);
			}
		}

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

		[IteratorStateMachine(typeof(<AddModsToLocalProps>d__40))]
		private static IEnumerator AddModsToLocalProps()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AddModsToLocalProps>d__40(0);
		}

		private static void GrabBaseDDOLObjects()
		{
			//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)
			List<string> list = new List<string> { "LanguageManager", "PhotonMono", "Game Instance", "Timer Updater" };
			Scene scene = ((Component)Singleton<PlayerManager>.instance).gameObject.scene;
			Il2CppReferenceArray<GameObject> rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
			allBaseDDOLGameObjects = (GameObject[])(object)new GameObject[4];
			foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)rootGameObjects)
			{
				int num = list.IndexOf(((Object)item).name);
				if (num >= 0)
				{
					allBaseDDOLGameObjects[num] = item;
				}
			}
			GameObject[] array = allBaseDDOLGameObjects;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					Log("null", useDebug: true);
				}
				else
				{
					Log("Stored: " + ((Object)val).name, useDebug: true);
				}
			}
		}

		private static void GrabBaseGymObjects()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string> { "!ftraceLightmaps", "ProbeVolumePerSceneData", "SCENE VFX/SFX", "SCENE", "INTERACTABLES", "TUTORIAL", "LIGHTING", "LOGIC" };
			Scene activeScene = SceneManager.GetActiveScene();
			Il2CppReferenceArray<GameObject> rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			allBaseGymGameObjects = (GameObject[])(object)new GameObject[8];
			foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)rootGameObjects)
			{
				if (list.Contains(((Object)item).name))
				{
					int num = list.IndexOf(((Object)item).name);
					if (num >= 0)
					{
						allBaseGymGameObjects[num] = item;
					}
				}
			}
			GameObject[] array = allBaseGymGameObjects;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					Log("Stored: null", useDebug: true);
				}
				else
				{
					Log("Stored: " + ((Object)val).name, useDebug: true);
				}
			}
		}

		private static void GrabBaseParkObjects()
		{
			//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)
			List<string> list = new List<string> { "LOGIC", "!ftraceLightmaps", "ProbeVolumePerSceneData", "INTERACTABLES", "LIGHTING", "SCENE VFX/SFX", "SCENE" };
			Scene activeScene = SceneManager.GetActiveScene();
			Il2CppReferenceArray<GameObject> rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			allBaseParkGameObjects = (GameObject[])(object)new GameObject[7];
			foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)rootGameObjects)
			{
				if (list.Contains(((Object)item).name))
				{
					int num = list.IndexOf(((Object)item).name);
					if (num >= 0)
					{
						allBaseParkGameObjects[num] = item;
					}
				}
			}
			GameObject[] array = allBaseParkGameObjects;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					Log("Stored: null", useDebug: true);
				}
				else
				{
					Log("Stored: " + ((Object)val).name, useDebug: true);
				}
			}
		}

		private static void GrabBaseMap0Objects()
		{
			//IL_002b: 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)
			List<string> list = new List<string> { "Logic", "Lighting & Effects", "Scene" };
			Scene activeScene = SceneManager.GetActiveScene();
			Il2CppReferenceArray<GameObject> rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			allBaseMap0GameObjects = (GameObject[])(object)new GameObject[3];
			foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)rootGameObjects)
			{
				if (list.Contains(((Object)item).name))
				{
					int num = list.IndexOf(((Object)item).name);
					if (num >= 0)
					{
						allBaseMap0GameObjects[num] = item;
					}
				}
			}
			GameObject[] array = allBaseMap0GameObjects;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					Log("Stored: null", useDebug: true);
				}
				else
				{
					Log("Stored: " + ((Object)val).name, useDebug: true);
				}
			}
		}

		private static void GrabBaseMap1Objects()
		{
			//IL_002b: 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)
			List<string> list = new List<string> { "Lighting & Effects", "Logic", "Scene" };
			Scene activeScene = SceneManager.GetActiveScene();
			Il2CppReferenceArray<GameObject> rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			allBaseMap1GameObjects = (GameObject[])(object)new GameObject[3];
			foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)rootGameObjects)
			{
				if (list.Contains(((Object)item).name))
				{
					int num = list.IndexOf(((Object)item).name);
					if (num >= 0)
					{
						allBaseMap1GameObjects[num] = item;
					}
				}
			}
			GameObject[] array = allBaseMap1GameObjects;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					Log("Stored: null", useDebug: true);
				}
				else
				{
					Log("Stored: " + ((Object)val).name, useDebug: true);
				}
			}
		}

		internal static void GetMods()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!EventSent && !PhotonNetwork.IsMasterClient && (currentScene == "Map0" || currentScene == "Map1"))
			{
				EventSent = true;
				PhotonNetwork.RaiseEvent(myEventCode, Object.op_Implicit(myModString), eventOptions, SendOptions.SendReliable);
			}
		}

		public void OnEvent(EventData eventData)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (eventData.Code == myEventCode)
			{
				if (PhotonNetwork.IsMasterClient)
				{
					PhotonNetwork.RaiseEvent(myEventCode, Object.op_Implicit(myModString), eventOptions, SendOptions.SendReliable);
				}
				opponentMods.Clear();
				string text = (opponentModString = eventData.CustomData.ToString());
				string[] array = text.Split('|');
				for (int i = 0; i < array.Length; i += 2)
				{
					ModInfo item = new ModInfo(array[i], array[i + 1]);
					opponentMods.Add(item);
				}
				Log("Player: " + Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername + " / " + Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId);
				Log("Mods: " + text);
				Actions.TriggerOnModStringRecieved();
			}
		}

		[IteratorStateMachine(typeof(<UpdateTitle>d__52))]
		private static IEnumerator UpdateTitle(PlayerNameTag __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateTitle>d__52(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<WaitForTitleLoad>d__53))]
		private static IEnumerator WaitForTitleLoad(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForTitleLoad>d__53(0)
			{
				player = player
			};
		}
	}
}
namespace RumbleModdingAPI.RMAPI
{
	public class Actions
	{
		[CompilerGenerated]
		private sealed class <HealthWatcher>d__46 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public int sceneNumber;

			private int <i>5__1;

			private int <i>5__2;

			private int <i>5__3;

			private Exception <e>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_0423: Unknown result type (might be due to invalid IL or missing references)
				//IL_042d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					RumbleModdingAPI.Log("HealthWatcher Started", useDebug: true);
					<>2__current = (object)new WaitForSeconds(3.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					RumbleModdingAPI.Log("HealthWatcher Waited 3.2 Seconds", useDebug: true);
					playerCount = Singleton<PlayerManager>.instance.AllPlayers.Count;
					healths = new int[playerCount];
					<i>5__1 = 0;
					while (<i>5__1 < playerCount)
					{
						healths[<i>5__1] = Singleton<PlayerManager>.instance.AllPlayers[<i>5__1].Data.HealthPoints;
						<i>5__1++;
					}
					waitForMatchStart = false;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (sceneNumber == sceneCount)
				{
					if (waitForMatchStart)
					{
						goto IL_0422;
					}
					try
					{
						if (playerCount == Singleton<PlayerManager>.instance.AllPlayers.Count)
						{
							goto IL_0214;
						}
						playerCount = Singleton<PlayerManager>.instance.AllPlayers.Count;
						if (!matchStarted || playerCount != 1 || (!(RumbleModdingAPI.currentScene == "Map0") && !(RumbleModdingAPI.currentScene == "Map1")))
						{
							healths = new int[playerCount];
							<i>5__2 = 0;
							while (<i>5__2 < playerCount)
							{
								healths[<i>5__2] = Singleton<PlayerManager>.instance.AllPlayers[<i>5__2].Data.HealthPoints;
								<i>5__2++;
							}
							goto IL_0214;
						}
						RumbleModdingAPI.Log("Ending Match due to 1 Player", useDebug: true);
						RumbleModdingAPI.Log("onRoundEnded Running", useDebug: true);
						TriggerOnRoundEnded();
						RumbleModdingAPI.Log("onMatchEnded Running", useDebug: true);
						TriggerOnMatchEnded();
						matchStarted = false;
						goto end_IL_00fc;
						IL_0214:
						<i>5__3 = 0;
						while (<i>5__3 < playerCount)
						{
							if (healths[<i>5__3] != Singleton<PlayerManager>.instance.AllPlayers[<i>5__3].Data.HealthPoints)
							{
								RumbleModdingAPI.Log("onPlayerHealthChanged Running (" + Singleton<PlayerManager>.instance.AllPlayers[<i>5__3].Data.GeneralData.PublicUsername + ", " + (Singleton<PlayerManager>.instance.AllPlayers[<i>5__3].Data.HealthPoints - healths[<i>5__3]) + ")", useDebug: true);
								TriggerOnPlayerHealthChanged(Singleton<PlayerManager>.instance.AllPlayers[<i>5__3], healths[<i>5__3] - Singleton<PlayerManager>.instance.AllPlayers[<i>5__3].Data.HealthPoints);
								healths[<i>5__3] = Singleton<PlayerManager>.instance.AllPlayers[<i>5__3].Data.HealthPoints;
								if ((RumbleModdingAPI.currentScene == "Map0" || RumbleModdingAPI.currentScene == "Map1") && healths[<i>5__3] <= 0 && !waitForMatchStart)
								{
									if (Singleton<PlayerManager>.instance.AllPlayers.Count > 1)
									{
										RumbleModdingAPI.Log("onRoundEnded Running (HP hit 0)", useDebug: true);
										TriggerOnRoundEnded();
									}
									MelonCoroutines.Start((IEnumerator)WaitForRoundStart(<i>5__3, sceneNumber));
								}
							}
							<i>5__3++;
						}
						goto IL_0422;
						end_IL_00fc:;
					}
					catch (Exception ex)
					{
						<e>5__4 = ex;
						RumbleModdingAPI.Error(<e>5__4);
						goto IL_0422;
					}
				}
				RumbleModdingAPI.Log("HealthWatcher Ending, Scene Changed", useDebug: true);
				return false;
				IL_0422:
				<>2__current = (object)new WaitForFixedUpdate();
				<>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 <StartActionWatcher>d__45 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private bool <gotPlayer>5__1;

			private GameObject <localPlayerGameObject>5__2;

			private Exception <e>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Expected O, but got Unknown
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Expected O, but got Unknown
				//IL_0247: Unknown result type (might be due to invalid IL or missing references)
				//IL_0251: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<gotPlayer>5__1 = false;
					<localPlayerGameObject>5__2 = null;
					break;
				case 2:
					<>1__state = -1;
					break;
				case 3:
					<>1__state = -1;
					break;
				}
				if (!<gotPlayer>5__1)
				{
					try
					{
						<localPlayerGameObject>5__2 = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject;
						RumbleModdingAPI.Log("grabbed Local Player", useDebug: true);
					}
					catch
					{
					}
					if ((Object)(object)<localPlayerGameObject>5__2 == (Object)null)
					{
						RumbleModdingAPI.Log("Local Player Null", useDebug: true);
						<>2__current = (object)new WaitForFixedUpdate();
						<>1__state = 2;
						return true;
					}
					if ((Object)(object)<localPlayerGameObject>5__2 != (Object)null)
					{
						RumbleModdingAPI.Log("Local Player != null", useDebug: true);
						<gotPlayer>5__1 = true;
						try
						{
							RumbleModdingAPI.Log("onMapInitialized Running: " + RumbleModdingAPI.currentScene, useDebug: true);
							TriggerOnMapInitialized();
							RumbleModdingAPI.Log("onMapInitialized Complete", useDebug: true);
							RumbleModdingAPI.GetMods();
							if (Singleton<PlayerManager>.instance.AllPlayers.Count > 1)
							{
								RumbleModdingAPI.Log("More than 1 Player", useDebug: true);
								if (RumbleModdingAPI.currentScene == "Map0")
								{
									RumbleModdingAPI.Log("Grabbing SlabOne MatchFormCanvas", useDebug: true);
									matchSlab = GameObjects.Map0.Logic.MatchSlabOne.MatchSlab.Slabbuddymatchvariant.MatchForm.MatchFormCanvas.GetGameObject();
								}
								else if (RumbleModdingAPI.currentScene == "Map1")
								{
									RumbleModdingAPI.Log("Grabbing SlabTwo MatchFormCanvas", useDebug: true);
									matchSlab = GameObjects.Map1.Logic.MatchSlabTwo.MatchSlab.Slabbuddymatchvariant.MatchForm.MatchFormCanvas.GetGameObject();
								}
								matchStarted = true;
								RumbleModdingAPI.Log("Get Health Current Scene: " + RumbleModdingAPI.currentScene, useDebug: true);
								if (RumbleModdingAPI.currentScene == "Map0" || RumbleModdingAPI.currentScene == "Map1")
								{
									RumbleModdingAPI.Log("onMatchStarted Running", useDebug: true);
									TriggerOnMatchStarted();
									RumbleModdingAPI.Log("onRoundStarted Running", useDebug: true);
									TriggerOnRoundStarted();
								}
							}
							MelonCoroutines.Start(HealthWatcher(sceneCount));
						}
						catch (Exception ex)
						{
							<e>5__3 = ex;
							RumbleModdingAPI.Error(<e>5__3);
						}
						return false;
					}
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 3;
					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 <WaitForRoundStart>d__48 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private WaitForSeconds <>2__current;

			public int playerNumber;

			public int sceneNumber;

			private bool <matchEnded>5__1;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Expected O, but got Unknown
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					RumbleModdingAPI.Log("Waiting for Round to Start", useDebug: true);
					<>2__current = new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					RumbleModdingAPI.Log("WaitForSeconds(0.5f) Finished", useDebug: true);
					waitForMatchStart = true;
					<matchEnded>5__1 = false;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (waitForMatchStart && sceneCount == sceneNumber && playerNumber < Singleton<PlayerManager>.instance.AllPlayers.Count)
				{
					try
					{
						if (Singleton<PlayerManager>.instance.AllPlayers[playerNumber].Data.HealthPoints == 20)
						{
							<i>5__2 = 0;
							while (<i>5__2 < playerCount)
							{
								healths[<i>5__2] = Singleton<PlayerManager>.instance.AllPlayers[<i>5__2].Data.HealthPoints;
								<i>5__2++;
							}
							waitForMatchStart = false;
							if (Singleton<PlayerManager>.instance.AllPlayers.Count > 1 && (RumbleModdingAPI.currentScene == "Map0" || RumbleModdingAPI.currentScene == "Map1"))
							{
								RumbleModdingAPI.Log("onRoundStarted Running (Normal Round Start Mid Match)", useDebug: true);
								TriggerOnRoundStarted();
							}
						}
						if (Singleton<PlayerManager>.instance.AllPlayers.Count > 1 && (RumbleModdingAPI.currentScene == "Map0" || RumbleModdingAPI.currentScene == "Map1") && !<matchEnded>5__1 && matchSlab.activeSelf)
						{
							<matchEnded>5__1 = true;
							matchStarted = false;
							RumbleModdingAPI.Log("onMatchEnded Running (Normal End)", useDebug: true);
							TriggerOnMatchEnded();
						}
					}
					catch
					{
					}
					<>2__current = new WaitForSeconds(0.02f);
					<>1__state = 2;
					return true;
				}
				RumbleModdingAPI.Log("WaitForRoundStart Finished", useDebug: true);
				return false;
			}

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

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

		private static int[] healths;

		private static int playerCount;

		private static bool waitForMatchStart;

		internal static int sceneCount;

		internal static bool matchStarted;

		internal static GameObject matchSlab;

		public static event Action onModStringRecieved;

		public static event Action onMyModsGathered;

		public static event Action<string> onMapInitialized;

		public static event Action<Player> onPlayerSpawned;

		public static event Action onMatchStarted;

		public static event Action onMatchEnded;

		public static event Action onRoundStarted;

		public static event Action onRoundEnded;

		public static event Action<Player, int> onPlayerHealthChanged;

		private static void TriggerAction(Action action)
		{
			Delegate[] array = action?.GetInvocationList();
			if (array == null)
			{
				return;
			}
			Delegate[] array2 = array;
			foreach (Delegate @delegate in array2)
			{
				try
				{
					@delegate.DynamicInvoke();
				}
				catch (Exception e)
				{
					RumbleModdingAPI.Log("Error for Mod: " + @delegate.Target);
					RumbleModdingAPI.Error(e);
				}
			}
		}

		private static void TriggerAction(Action<string> action, string msg)
		{
			Delegate[] array = action?.GetInvocationList();
			if (array == null)
			{
				return;
			}
			Delegate[] array2 = array;
			foreach (Delegate @delegate in array2)
			{
				try
				{
					@delegate.DynamicInvoke(msg);
				}
				catch (Exception e)
				{
					RumbleModdingAPI.Log("Error for Mod: " + @delegate.Target);
					RumbleModdingAPI.Error(e);
				}
			}
		}

		private static void TriggerAction(Action<Player> action, Player player)
		{
			Delegate[] array = action?.GetInvocationList();
			if (array == null)
			{
				return;
			}
			Delegate[] array2 = array;
			foreach (Delegate @delegate in array2)
			{
				try
				{
					@delegate.DynamicInvoke(player);
				}
				catch (Exception e)
				{
					RumbleModdingAPI.Log("Error for Mod: " + @delegate.Target);
					RumbleModdingAPI.Error(e);
				}
			}
		}

		private static void TriggerAction(Action<Player, int> action, Player player, int amount)
		{
			Delegate[] array = action?.GetInvocationList();
			if (array == null)
			{
				return;
			}
			Delegate[] array2 = array;
			foreach (Delegate @delegate in array2)
			{
				try
				{
					@delegate.DynamicInvoke(player, amount);
				}
				catch (Exception e)
				{
					RumbleModdingAPI.Log("Error for Mod: " + @delegate.Target);
					RumbleModdingAPI.Error(e);
				}
			}
		}

		internal static void TriggerOnModStringRecieved()
		{
			TriggerAction(Actions.onModStringRecieved);
		}

		internal static void TriggerOnMyModsGathered()
		{
			TriggerAction(Actions.onMyModsGathered);
		}

		internal static void TriggerOnMapInitialized()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Action<string> action = Actions.onMapInitialized;
			Scene activeScene = SceneManager.GetActiveScene();
			TriggerAction(action, ((Scene)(ref activeScene)).name);
		}

		internal static void TriggerOnPlayerSpawned(Player player)
		{
			TriggerAction(Actions.onPlayerSpawned, player);
		}

		internal static void TriggerOnMatchStarted()
		{
			TriggerAction(Actions.onMatchStarted);
		}

		internal static void TriggerOnMatchEnded()
		{
			TriggerAction(Actions.onMatchEnded);
		}

		internal static void TriggerOnRoundStarted()
		{
			TriggerAction(Actions.onRoundStarted);
		}

		internal static void TriggerOnRoundEnded()
		{
			TriggerAction(Actions.onRoundEnded);
		}

		internal static void TriggerOnPlayerHealthChanged(Player player, int amount)
		{
			TriggerAction(Actions.onPlayerHealthChanged, player, amount);
		}

		[IteratorStateMachine(typeof(<StartActionWatcher>d__45))]
		internal static IEnumerator StartActionWatcher()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartActionWatcher>d__45(0);
		}

		[IteratorStateMachine(typeof(<HealthWatcher>d__46))]
		internal static IEnumerator HealthWatcher(int sceneNumber)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HealthWatcher>d__46(0)
			{
				sceneNumber = sceneNumber
			};
		}

		[IteratorStateMachine(typeof(<WaitForRoundStart>d__48))]
		private static IEnumerator<WaitForSeconds> WaitForRoundStart(int playerNumber, int sceneNumber)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForRoundStart>d__48(0)
			{
				playerNumber = playerNumber,
				sceneNumber = sceneNumber
			};
		}
	}
	public class AssetBundles
	{
		private static Stream ConvertToIl2CppStream(Stream stream)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			MemoryStream val = new MemoryStream();
			byte[] array = new byte[4096];
			Il2CppStructArray<byte> val2 = new Il2CppStructArray<byte>(array);
			int num;
			while ((num = stream.Read(array, 0, array.Length)) > 0)
			{
				val2 = Il2CppStructArray<byte>.op_Implicit(array);
				((Stream)val).Write(val2, 0, num);
			}
			((Stream)val).Flush();
			return (Stream)(object)val;
		}

		private static MemoryStream StreamFromFile(string path)
		{
			byte[] buffer = File.ReadAllBytes(path);
			return new MemoryStream(buffer);
		}

		public static GameObject LoadAssetBundleGameObjectFromFile(string filePath, string assetName)
		{
			Stream stream = StreamFromFile(filePath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			GameObject result = Object.Instantiate<GameObject>(val2.LoadAsset<GameObject>(assetName));
			stream.Close();
			val.Close();
			val2.Unload(false);
			return result;
		}

		public static AssetBundle LoadAssetBundleFromFile(string filePath)
		{
			Stream stream = StreamFromFile(filePath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle result = AssetBundle.LoadFromStream(val);
			stream.Close();
			val.Close();
			return result;
		}

		public static T LoadAssetFromFile<T>(string filePath, string assetName) where T : Object
		{
			Stream stream = StreamFromFile(filePath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			T result = val2.LoadAsset<T>(assetName);
			stream.Close();
			val.Close();
			val2.Unload(false);
			return result;
		}

		public static List<T> LoadAllOfTypeFromFile<T>(string filePath) where T : Object
		{
			Stream stream = StreamFromFile(filePath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			List<T> list = new List<T>();
			foreach (T item in val2.LoadAll<T>())
			{
				list.Add(item);
			}
			stream.Close();
			val.Close();
			val2.Unload(false);
			return list;
		}

		public static AssetBundle LoadAssetBundleFromStream(string modName, string modAuthor, string assetPath)
		{
			using Stream stream = MelonBase.FindMelon(modName, modAuthor).MelonAssembly.Assembly.GetManifestResourceStream(assetPath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle result = AssetBundle.LoadFromStream(val);
			val.Close();
			return result;
		}

		public static AssetBundle LoadAssetBundleFromStream(MelonMod instance, string assetPath)
		{
			using Stream stream = ((MelonBase)instance).MelonAssembly.Assembly.GetManifestResourceStream(assetPath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle result = AssetBundle.LoadFromStream(val);
			val.Close();
			return result;
		}

		public static T LoadAssetFromStream<T>(MelonMod instance, string path, string assetName) where T : Object
		{
			using Stream stream = ((MelonBase)instance).MelonAssembly.Assembly.GetManifestResourceStream(path);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			val.Close();
			T result = val2.LoadAsset<T>(assetName);
			val2.Unload(false);
			return result;
		}

		public static List<T> LoadAllOfTypeFromStream<T>(MelonMod instance, string path) where T : Object
		{
			using Stream stream = ((MelonBase)instance).MelonAssembly.Assembly.GetManifestResourceStream(path);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			List<T> list = new List<T>();
			Il2CppArrayBase<T> val3 = val2.LoadAll<T>();
			foreach (T item in val3)
			{
				list.Add(item);
			}
			val.Close();
			val2.Unload(false);
			return list;
		}

		public static T LoadAssetFromStream<T>(string modName, string modAuthor, string path, string assetName) where T : Object
		{
			using Stream stream = MelonBase.FindMelon(modName, modAuthor).MelonAssembly.Assembly.GetManifestResourceStream(path);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			val.Close();
			T result = val2.LoadAsset<T>(assetName);
			val2.Unload(false);
			return result;
		}
	}
	public static class AudioManager
	{
		public static AudioClip LoadWavFile(string filePath)
		{
			if (!File.Exists(filePath))
			{
				return null;
			}
			byte[] fileBytes = File.ReadAllBytes(filePath);
			return LoadWavFromBytes(fileBytes, Path.GetFileNameWithoutExtension(filePath));
		}

		private static AudioClip LoadWavFromBytes(byte[] fileBytes, string name)
		{
			int i = 12;
			int num = -1;
			int num2 = 0;
			int num3;
			for (; i < fileBytes.Length - 8; i += 8 + num3)
			{
				string @string = Encoding.ASCII.GetString(fileBytes, i, 4);
				num3 = BitConverter.ToInt32(fileBytes, i + 4);
				if (@string == "data")
				{
					num = i + 8;
					num2 = num3;
					break;
				}
			}
			if (num == -1)
			{
				return null;
			}
			int num4 = fileBytes[22];
			int num5 = BitConverter.ToInt32(fileBytes, 24);
			int num6 = num2 / 2 / num4;
			float[] array = new float[num6 * num4];
			for (int j = 0; j < num6 * num4; j++)
			{
				short num7 = BitConverter.ToInt16(fileBytes, num + j * 2);
				array[j] = (float)num7 / 32768f;
			}
			AudioClip val = AudioClip.Create(name, num6, num4, num5, false);
			val.SetData(Il2CppStructArray<float>.op_Implicit(array), 0);
			return val;
		}

		public static PooledAudioSource PlaySound(AudioCall audioCall, Vector3 position, bool isLooping = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return Singleton<AudioManager>.instance.Play(audioCall, position, isLooping);
		}

		public static AudioCall CreateAudioCall(string filePath, float volume)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			string name = filePath.Replace(".wav", "").Split('\\')[^1];
			if (File.Exists(filePath))
			{
				AudioCall val = ScriptableObject.CreateInstance<AudioCall>();
				((Object)val).name = name;
				GeneralAudioSettings val2 = new GeneralAudioSettings();
				val2.SetVolume(volume);
				val2.Pitch = 1f;
				val.generalSettings = val2;
				SpatialAudioSettings val3 = new SpatialAudioSettings();
				val3.CustomReverbZoneMixCurve = new AnimationCurve();
				val3.CustomRolloffCurve = new AnimationCurve();
				val3.CustomSpatialBlendCurve = new AnimationCurve();
				val3.CustomSpreadCurve = new AnimationCurve();
				val.spatialSettings = val3;
				WeightedClip val4 = new WeightedClip();
				AudioClip val5 = LoadWavFile(filePath);
				if ((Object)(object)val5 == (Object)null)
				{
					bool flag = false;
					return null;
				}
				((Object)val5).name = name;
				((Object)val5).hideFlags = (HideFlags)61;
				val5.LoadAudioData();
				val4.Clip = val5;
				WeightedClip[] array = (WeightedClip[])(object)new WeightedClip[1] { val4 };
				array[0].Weight = 1f;
				val.clips = Il2CppReferenceArray<WeightedClip>.op_Implicit(array);
				((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0] = val.GetRandomClip();
				((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0].Clip = val5;
				((Object)val).hideFlags = (HideFlags)61;
				((Object)((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0].Clip).hideFlags = (HideFlags)61;
				return val;
			}
			return null;
		}

		public static AudioCall[] CreateAudioCalls(string[] filePaths, float volume)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			AudioCall[] array = (AudioCall[])(object)new AudioCall[filePaths.Length];
			for (int i = 0; i < filePaths.Length; i++)
			{
				string name = filePaths[i].Replace(".wav", "").Split('\\')[^1];
				if (File.Exists(filePaths[i]))
				{
					AudioCall val = ScriptableObject.CreateInstance<AudioCall>();
					((Object)val).name = name;
					GeneralAudioSettings val2 = new GeneralAudioSettings();
					val2.SetVolume(volume);
					val2.Pitch = 1f;
					val.generalSettings = val2;
					SpatialAudioSettings val3 = new SpatialAudioSettings();
					val3.CustomReverbZoneMixCurve = new AnimationCurve();
					val3.CustomRolloffCurve = new AnimationCurve();
					val3.CustomSpatialBlendCurve = new AnimationCurve();
					val3.CustomSpreadCurve = new AnimationCurve();
					val.spatialSettings = val3;
					WeightedClip val4 = new WeightedClip();
					AudioClip val5 = LoadWavFile(filePaths[i]);
					if ((Object)(object)val5 == (Object)null)
					{
						bool flag = false;
						array[i] = null;
						continue;
					}
					((Object)val5).name = name;
					((Object)val5).hideFlags = (HideFlags)61;
					val5.LoadAudioData();
					val4.Clip = val5;
					WeightedClip[] array2 = (WeightedClip[])(object)new WeightedClip[1] { val4 };
					array2[0].Weight = 1f;
					val.clips = Il2CppReferenceArray<WeightedClip>.op_Implicit(array2);
					((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0] = val.GetRandomClip();
					((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0].Clip = val5;
					((Object)val).hideFlags = (HideFlags)61;
					((Object)((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0].Clip).hideFlags = (HideFlags)61;
					array[i] = val;
				}
				else
				{
					array[i] = null;
				}
			}
			return array;
		}
	}
	public class Calls
	{
		public class Matchmaking
		{
			public static string getMatchmakingTypeAsString()
			{
				if (RumbleModdingAPI.currentScene != "Map0" && RumbleModdingAPI.currentScene != "Map1")
				{
					return "NULL";
				}
				string result = "";
				switch (RumbleModdingAPI.matchmakingType)
				{
				case 0:
					result = "Any Rank";
					break;
				case 1:
					result = "Same Rank";
					break;
				case 2:
					result = "Friends Only";
					break;
				}
				return result;
			}

			public static int getMatchmakingTypeAsInt()
			{
				if (RumbleModdingAPI.currentScene != "Map0" && RumbleModdingAPI.currentScene != "Map1")
				{
					return -1;
				}
				return RumbleModdingAPI.matchmakingType;
			}
		}

		public class Mods
		{
			public static string getMyModString()
			{
				return RumbleModdingAPI.myModString;
			}

			public static string getOpponentModString()
			{
				return RumbleModdingAPI.opponentModString;
			}

			public static List<ModInfo> getMyMods()
			{
				return RumbleModdingAPI.myMods;
			}

			public static List<ModInfo> getOpponentMods()
			{
				return RumbleModdingAPI.opponentMods;
			}

			public static bool doesOpponentHaveMod(string modName, string ModVersion, bool matchVersion = true)
			{
				for (int i = 0; i < RumbleModdingAPI.opponentMods.Count; i++)
				{
					if (modName == RumbleModdingAPI.opponentMods[i].ModName)
					{
						if (matchVersion)
						{
							return ModVersion == RumbleModdingAPI.opponentMods[i].ModVersion;
						}
						return true;
					}
				}
				return false;
			}

			public static bool findOwnMod(string modName, string ModVersion, bool matchVersion = true)
			{
				for (int i = 0; i < RumbleModdingAPI.myMods.Count; i++)
				{
					if (modName == RumbleModdingAPI.myMods[i].ModName)
					{
						if (matchVersion)
						{
							return ModVersion == RumbleModdingAPI.myMods[i].ModVersion;
						}
						return true;
					}
				}
				return false;
			}
		}

		public class ControllerMap
		{
			public class RightController
			{
				public static float GetTrigger()
				{
					return RumbleModdingAPI.rightTrigger.ReadValue<float>();
				}

				public static float GetGrip()
				{
					return RumbleModdingAPI.rightGrip.ReadValue<float>();
				}

				public static float GetPrimary()
				{
					return RumbleModdingAPI.rightPrimary.ReadValue<float>();
				}

				public static float GetSecondary()
				{
					return RumbleModdingAPI.rightSecondary.ReadValue<float>();
				}

				public static Vector2 GetJoystick()
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000b: 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)
					return RumbleModdingAPI.rightJoystick.ReadValue<Vector2>();
				}

				public static float GetJoystickClick()
				{
					return RumbleModdingAPI.rightJoystickClick.ReadValue<float>();
				}
			}

			public class LeftController
			{
				public static float GetTrigger()
				{
					return RumbleModdingAPI.leftTrigger.ReadValue<float>();
				}

				public static float GetGrip()
				{
					return RumbleModdingAPI.leftGrip.ReadValue<float>();
				}

				public static float GetPrimary()
				{
					return RumbleModdingAPI.leftPrimary.ReadValue<float>();
				}

				public static float GetSecondary()
				{
					return RumbleModdingAPI.leftSecondary.ReadValue<float>();
				}

				public static Vector2 GetJoystick()
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000b: 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)
					return RumbleModdingAPI.leftJoystick.ReadValue<Vector2>();
				}

				public static float GetJoystickClick()
				{
					return RumbleModdingAPI.leftJoystickClick.ReadValue<float>();
				}
			}
		}

		public class Scene
		{
			public static string GetSceneName()
			{
				return RumbleModdingAPI.currentScene;
			}

			public static string GetLastSceneName()
			{
				return RumbleModdingAPI.lastScene;
			}
		}

		public class Players
		{
			public static bool IsHost()
			{
				return PhotonNetwork.IsMasterClient;
			}

			public static List<Player> GetAllPlayers()
			{
				return Singleton<PlayerManager>.instance.AllPlayers;
			}

			public static Player GetLocalPlayer()
			{
				return Singleton<PlayerManager>.instance.localPlayer;
			}

			public static PlayerController GetLocalPlayerController()
			{
				return Singleton<PlayerManager>.instance.localPlayer.Controller;
			}

			public static List<Player> GetEnemyPlayers()
			{
				List<Player> list = new List<Player>();
				for (int i = 1; i < Singleton<PlayerManager>.instance.AllPlayers.Count; i++)
				{
					list.Add(Singleton<PlayerManager>.instance.AllPlayers[i]);
				}
				return list;
			}

			public static Player GetClosestPlayer(Vector3 position, bool ignoreLocalController)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return Singleton<PlayerManager>.instance.GetClosestPlayer(position, ignoreLocalController);
			}

			public static Player GetClosestPlayer(Vector3 position, PlayerController ignoreController)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return Singleton<PlayerManager>.instance.GetClosestPlayer(position, ignoreController);
			}

			public static Player GetPlayerByControllerType(ControllerType controllerType)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return Singleton<PlayerManager>.instance.GetPlayer(controllerType);
			}

			public static Player GetPlayerByActorNo(int actorNumber)
			{
				return Singleton<PlayerManager>.instance.GetPlayerByActorNo(actorNumber);
			}

			public static List<Player> GetPlayersInActorNoOrder()
			{
				bool flag = false;
				List<Player> list = new List<Player>();
				for (int i = 1; i < Singleton<PlayerManager>.instance.AllPlayers.Count; i++)
				{
					if (!flag && Singleton<PlayerManager>.instance.AllPlayers[0].Data.GeneralData.ActorNo < Singleton<PlayerManager>.instance.AllPlayers[i].Data.GeneralData.ActorNo)
					{
						list.Add(Singleton<PlayerManager>.instance.AllPlayers[0]);
						flag = true;
					}
					list.Add(Singleton<PlayerManager>.instance.AllPlayers[i]);
				}
				return list;
			}
		}

		public static bool IsInitialized()
		{
			return RumbleModdingAPI.init;
		}

		public static bool IsMapInitialized()
		{
			return RumbleModdingAPI.mapInit;
		}
	}
	public class Create
	{
		public static GameObject newTextGameObject;

		public static GameObject newButtonGameObject;

		public static GameObject NewText()
		{
			GameObject val = Object.Instantiate<GameObject>(newTextGameObject);
			val.SetActive(true);
			((TMP_Text)val.GetComponent<TextMeshPro>()).autoSizeTextContainer = true;
			return val;
		}

		public static GameObject NewText(string text, float textSize, Color textColor, Vector3 textPosition, Quaternion textRotation)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(newTextGameObject);
			val.SetActive(true);
			TextMeshPro component = val.GetComponent<TextMeshPro>();
			((TMP_Text)component).text = text;
			((TMP_Text)component).fontSize = textSize;
			((TMP_Text)component).color = textColor;
			((TMP_Text)component).autoSizeTextContainer = true;
			newTextGameObject.transform.position = textPosition;
			newTextGameObject.transform.rotation = textRotation;
			return val;
		}

		public static GameObject NewButton()
		{
			GameObject val = Object.Instantiate<GameObject>(newButtonGameObject);
			val.SetActive(true);
			return val;
		}

		public static GameObject NewButton(Vector3 buttonPosition, Quaternion buttonRotation)
		{
			//IL_0012: 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)
			GameObject val = Object.Instantiate<GameObject>(newButtonGameObject);
			val.transform.position = buttonPosition;
			val.transform.rotation = buttonRotation;
			val.SetActive(true);
			return val;
		}

		public static GameObject NewButton(Action action)
		{
			GameObject val = Object.Instantiate<GameObject>(newButtonGameObject);
			val.SetActive(true);
			((Component)val.transform.GetChild(0)).gameObject.GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit(action));
			return val;
		}

		public static GameObject NewButton(Vector3 buttonPosition, Quaternion buttonRotation, Action action)
		{
			//IL_0012: 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)
			GameObject val = Object.Instantiate<GameObject>(newButtonGameObject);
			val.transform.position = buttonPosition;
			val.transform.rotation = buttonRotation;
			val.SetActive(true);
			((Component)val.transform.GetChild(0)).gameObject.GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit(action));
			return val;
		}

		internal static void SetupAPIItems()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)RumbleModdingAPI.parentAPIItems == (Object)null)
			{
				RumbleModdingAPI.parentAPIItems = new GameObject();
				((Object)RumbleModdingAPI.parentAPIItems).name = "APIItems";
				Object.DontDestroyOnLoad((Object)(object)RumbleModdingAPI.parentAPIItems);
			}
			if ((Object)(object)newTextGameObject == (Object)null)
			{
				newTextGameObject = Object.Instantiate<GameObject>(GameObjects.Gym.INTERACTABLES.Leaderboard.PlayerTags.HighscoreTag.Nr.GetGameObject());
				TextMeshPro component = newTextGameObject.GetComponent<TextMeshPro>();
				((Object)newTextGameObject).name = "NewTextGameObject";
				((TMP_Text)component).text = "new Text";
				((TMP_Text)component).color = Color.black;
				newTextGameObject.SetActive(false);
				newTextGameObject.transform.parent = RumbleModdingAPI.parentAPIItems.transform;
			}
			if ((Object)(object)newButtonGameObject == (Object)null)
			{
				newButtonGameObject = Object.Instantiate<GameObject>(GameObjects.Gym.TUTORIAL.Statictutorials.RUMBLEStarterGuide.NextPageButton.InteractionButton.GetGameObject());
				((Object)newButtonGameObject).name = "newButton";
				newButtonGameObject.SetActive(false);
				newButtonGameObject.transform.parent = RumbleModdingAPI.parentAPIItems.transform;
			}
		}
	}
	public class GameObjects
	{
		public class DDOL
		{
			public class LanguageManager
			{
				public static GameObject GetGameObject()
				{
					return RumbleModdingAPI.allBaseDDOLGameObjects[0];
				}
			}

			public class PhotonMono
			{
				public static GameObject GetGameObject()
				{
					return RumbleModdingAPI.allBaseDDOLGameObjects[1];
				}
			}

			public class GameInstance
			{
				public class PreInitializable
				{
					public class AudioManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)PreInitializable.GetGameObject().transform.GetChild(0)).gameObject;
						}
					}

					public class PoolManager
					{
						public class PoolWrappedWallRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(0)).gameObject;
							}
						}

						public class PoolPrisonedPillarRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(1)).gameObject;
							}
						}

						public class PoolDockedDiskRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(2)).gameObject;
							}
						}

						public class PoolCageCubeRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(3)).gameObject;
							}
						}

						public class PoolFruitFatRUMBLEEnvironmentFruit
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(4)).gameObject;
							}
						}

						public class PoolFruitLongRUMBLEEnvironmentFruit
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(5)).gameObject;
							}
						}

						public class PoolFruitRUMBLEEnvironmentFruit
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(6)).gameObject;
							}
						}

						public class PoolBoulderballScoredVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(7)).gameObject;
							}
						}

						public class PoolMinigameConfettiVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(8)).gameObject;
							}
						}

						public class PoolMatchpedestalRUMBLEPoolsPooledMonoBehaviour
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(9)).gameObject;
							}
						}

						public class PoolInfoSlabRUMBLEPoolsPooledMonoBehaviour
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(10)).gameObject;
							}
						}

						public class PoolMatchSlabRUMBLEPoolsPooledMonoBehaviour
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(11)).gameObject;
							}
						}

						public class PoolGearCoinVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(12)).gameObject;
							}
						}

						public class PoolStructureTargetRUMBLEMoveSystemStructureTarget
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(13)).gameObject;
							}
						}

						public class PoolVFXDustStructureTargetRespawnRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(14)).gameObject;
							}
						}

						public class PoolPooledAudioSourceManualRUMBLEPoolsPooledAudioSource
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(15)).gameObject;
							}
						}

						public class PoolChargestoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(16)).gameObject;
							}
						}

						public class PoolRockCamDespawnVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(17)).gameObject;
							}
						}

						public class PoolRockCamSpawnVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(18)).gameObject;
							}
						}

						public class PoolOnPlayerVisualsChangedVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(19)).gameObject;
							}
						}

						public class PoolFistbumpCoinRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(20)).gameObject;
							}
						}

						public class PoolVigorstoneBurstVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(21)).gameObject;
							}
						}

						public class PoolBoulderBallRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(22)).gameObject;
							}
						}

						public class PoolGuardstoneTutorialGuardStoneTutorial
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(23)).gameObject;
							}
						}

						public class PoolVolatileStoneRUMBLECombatShiftStonesVolatileStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(24)).gameObject;
							}
						}

						public class PoolChargeStoneRUMBLECombatShiftStonesChargeStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(25)).gameObject;
							}
						}

						public class PoolSurgeStoneRUMBLECombatShiftStonesCounterStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(26)).gameObject;
							}
						}

						public class PoolFlowStoneRUMBLECombatShiftStonesFlowStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(27)).gameObject;
							}
						}

						public class PoolGuardStoneRUMBLECombatShiftStonesGuardStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(28)).gameObject;
							}
						}

						public class PoolStubbornStoneRUMBLECombatShiftStonesStubbornStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(29)).gameObject;
							}
						}

						public class PoolAdamantStoneRUMBLECombatShiftStonesUnyieldingStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(30)).gameObject;
							}
						}

						public class PoolVigorStoneRUMBLECombatShiftStonesVigorStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(31)).gameObject;
							}
						}

						public class PoolSurgestoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(32)).gameObject;
							}
						}

						public class PoolGuardstoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(33)).gameObject;
							}
						}

						public class PoolStubbornstoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(34)).gameObject;
							}
						}

						public class PoolAdamantstoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(35)).gameObject;
							}
						}

						public class PoolVigorstoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(36)).gameObject;
							}
						}

						public class PoolSmallRockRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(37)).gameObject;
							}
						}

						public class PoolLargeRockRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(38)).gameObject;
							}
						}

						public class PoolFlickVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(39)).gameObject;
							}
						}

						public class PoolPlayerBoxInteractionVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(40)).gameObject;
							}
						}

						public class PoolExplodeActivationVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(41)).gameObject;
							}
						}

						public class PoolExplodeFinaleVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(42)).gameObject;
							}
						}

						public class PoolExplodeStatusVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(43)).gameObject;
							}
						}

						public class PoolVFXDustModifierDashRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(44)).gameObject;
							}
						}

						public class PoolVFXDustPlayerKnockbackRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(45)).gameObject;
							}
						}

						public class PoolHitmarkerRUMBLEPlayersSubsystemsPlayerHitmarker
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(46)).gameObject;
							}
						}

						public class PoolVFXDustModifierGroundRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(47)).gameObject;
							}
						}

						public class PoolStructureCollisionVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(48)).gameObject;
							}
						}

						public class PoolVFXDustModifierFreeRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(49)).gameObject;
							}
						}

						public class PoolVFXDustModifierJumpRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(50)).gameObject;
							}
						}

						public class PoolPosePerformedVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(51)).gameObject;
							}
						}

						public class PoolMovePerformedVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(52)).gameObject;
							}
						}

						public class PoolRicochetVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(53)).gameObject;
							}
						}

						public class PoolParryVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(54)).gameObject;
							}
						}

						public class PoolHoldVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(55)).gameObject;
							}
						}

						public class PoolUppercutVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(56)).gameObject;
							}
						}

						public class PoolStraightVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(57)).gameObject;
							}
						}

						public class PoolKickVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(58)).gameObject;
							}
						}

						public class PoolStompVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(59)).gameObject;
							}
						}

						public class PoolVFXDustPlayerFootstepRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(60)).gameObject;
							}
						}

						public class PoolPillarRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(61)).gameObject;
							}
						}

						public class PoolDiscRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(62)).gameObject;
							}
						}

						public class PoolVFXDustStructureSpawnRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(63)).gameObject;
							}
						}

						public class PoolVFXDustStructureBreakRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(64)).gameObject;
							}
						}

						public class PoolVFXDustStructureImpactRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(65)).gameObject;
							}
						}

						public class PoolJointControlRUMBLEPhysicsJointControl
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(66)).gameObject;
							}
						}

						public class PoolWallRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(67)).gameObject;
							}
						}

						public class PoolRockCubeRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(68)).gameObject;
							}
						}

						public class PoolBallRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(69)).gameObject;
							}
						}

						public class PoolPooledAudioSourceRUMBLEPoolsPooledAudioSource
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(70)).gameObject;
							}
						}

						public class PoolVFXDustStructureFrictionRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(71)).gameObject;
							}
						}

						public static GameObject GetGameObject()
						{
							return ((Component)PreInitializable.GetGameObject().transform.GetChild(1)).gameObject;
						}
					}

					public class PlayFabHandler
					{
						public static GameObject GetGameObject()
						{
							return ((Component)PreInitializable.GetGameObject().transform.GetChild(2)).gameObject;
						}
					}

					public static GameObject GetGameObject()
					{
						return ((Component)GameInstance.GetGameObject().transform.GetChild(0)).gameObject;
					}
				}

				public class Initializable
				{
					public class NetworkManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(0)).gameObject;
						}
					}

					public class PlayerManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(1)).gameObject;
						}
					}

					public class SceneManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(2)).gameObject;
						}
					}

					public class NotificationManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(3)).gameObject;
						}
					}

					public class StackManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(4)).gameObject;
						}
					}

					public class GraphicsManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(5)).gameObject;
						}
					}

					public class SocialHandler
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(6)).gameObject;
						}
					}

					public class SlabManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(7)).gameObject;
						}
					}

					public class RecordingCamera
					{
						public class FadeScreenRenderer
						{
							public static GameObject GetGameObject()
							{
								return ((Component)RecordingCamera.GetGameObject().transform.GetChild(0)).gameObject;
							}
						}

						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(8)).gameObject;
						}
					}

					public class CatalogHandler
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(9)).gameObject;
						}
					}

					public class EconomyHandler
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(10)).gameObject;
						}
					}

					public class InputManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(11)).gameObject;
						}
					}

					public static GameObject GetGameObject()
					{
						return ((Component)GameInstance.GetGameObject().transform.GetChild(1)).gameObject;
					}
				}

				public class Other
				{
					public class RaiseEventHandler
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Other.GetGameObject().transform.GetChild(0)).gameObject;
						}
					}

					public class Layermasks
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Other.GetGameObject().transform.GetChild(1)).gameObject;
						}
					}

					public class CombatManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Other.GetGameObject().transform.GetChild(2)).gameObject;
						}
					}

					public static GameObject GetGameObject()
					{
						return ((Component)GameInstance.GetGameObject().transform.GetChild(2)).gameObject;
					}
				}

				public class UI
				{
					public class RecordingUI
					{
						public class Panel
						{
							public class RotationSmoothing
							{
								public class Label
								{
									public static GameObject GetGameObject()
									{
										return ((Component)RotationSmoothing.GetGameObject().transform.GetChild(0)).gameObject;
									}
								}

								public class Minlabel
								{
									public static GameObject GetGameObject()
									{
										return ((Component)RotationSmoothing.GetGameObject().transform.GetChild(1)).gameObject;
									}
								}

								public class maxLabel
								{
									public static GameObject GetGameObject()
									{
										return ((Component)RotationSmoothing.GetGameObject().transform.GetChild(2)).gameObject;
									}
								}

								public class SliderOutline
								{
									public class Background
									{
										public static GameObject GetGameObject()
										{
											return ((Component)SliderOutline.GetGameObject().transform.GetChild(0)).gameObject;
										}
									}

									public class FillArea
									{
										public class Fill
										{
											public static GameObject GetGameObject()
											{
												return ((Component)FillArea.GetGameObject().transform.GetChild(0)).gameObject;
											}
										}

										public static GameObject GetGameObject()
										{
											return ((Component)SliderOutline.GetGameObject().transform.GetChild(1)).gameObject;
										}
									}

									public class HandleSlideArea
									{
										public class Handle
										{
											public class Current
											{
												public static GameObject GetGameObject()
												{
													return ((Component)Handle.GetGameObject().transform.GetChild(0)).gameObject;
												}
											}

											public static GameObject GetGameObject()
											{
												return ((Component)HandleSlideArea.GetGameObject().transform.GetChild(0)).gameObject;
											}
										}

										public static GameObject GetGameObject()
										{
											return ((Component)SliderOutline.GetGameObject().transform.GetChild(2)).gameObject;
										}
									}

									public static GameObject GetGameObject()
									{
										return ((Component)RotationSmoothing.GetGameObject().transform.GetChild(3)).gameObject;
									}
								}

								public static GameObject GetGameObject()
								{
									return ((Component)Panel.GetGameObject().transform.GetChild(0)).gameObject;
								}
							}

							public class PositionSmoothing
							{
								public class Label
								{
									public static GameObject GetGameObject()
									{
										return ((Component)PositionSmoothing.GetGameObject().transform.GetChild(0)).gameObject;
									}
								}

								public class Minlabel
								{
									public static GameObject GetGameObject()
									{
										return ((Component)PositionSmoothing.GetGameObject().transform.GetChild(1)).gameObject;
									}
								}

								public class maxLabel
								{
									public static GameObject GetGameObject()
									{
										return ((Component)PositionSmoothing.GetGameObject().transform.GetChild(2)).gameObject;
									}
								}

								public class SliderOutline
								{
									public class Background
									{
										public static GameObject GetGameObject()
										{
											return ((Component)SliderOutline.GetGameObject().transform.GetChild(0)).gameObject;
										}
									}

									public class FillArea
									{
										public class Fill
										{
											public static GameObject GetGameObject()
											{
												return ((Component)FillArea.GetGameObject().transform.GetChild(0)).gameObject;
											}
										}

										public static GameObject GetGameObject()
										{
											return ((Component)SliderOutline.GetGameObject().transform.GetChild(1)).gameObject;
										}
									}

									public class HandleSlideArea
									{
										public class Handle
										{
											public class Current
											{
												public static GameObject GetGameObject()
												{
													return ((Component)Handle.GetGameObject().transform.GetChild(0)).gameObject;
												}
											}

											public static GameObject GetGameObject()
											{
												return ((Component)HandleSlideArea.GetGameObject().transform.GetChild(0)).gameObject;
											}
										}

										public static GameObject GetGameObject()
										{
											return ((Component)SliderOutline.GetGameObject().transform.GetChild(2)).gameObject;
										}
									}

									public static GameObject GetGameObject()
									{
										return ((Component)PositionSmoothing.GetGameObject().transform.GetChild(3)).gameObject;
									}
								}

								public static GameObject GetGameObject()
								{
									return ((Component)Panel.GetGameObject().transform.GetChild(1)).gameObject;
								}
							}

							public class FieldOfView
							{
								public class Label
								{
									public static GameObject GetGameObject()
									{
										return ((Component)FieldOfView.GetGameObject().transform.GetChild(0)).gameObject;
									}
								}

								public class Minlabel
								{
									public static GameObject GetGameObject()
									{
										return ((Component)FieldOfView.GetGameObject().transform.GetChild(1)).gameObject;
									}
								}

								public class maxLabel
								{
									public static GameObject GetGameObject()
									{
										return ((Component)FieldOfView.GetGameObject().transform.GetChild(2)).gameObject;
									}
								}

								public class SliderOutline
								{
									public class Background
									{
										public static GameObject GetGameObject()
										{
											return ((Component)SliderOutline.GetGameObject().transform.GetChild(0)).gameObject;
										}
									}

									public class FillArea
									{
										public class Fill
										{
											public static GameObject GetGameObject()
											{
												return ((Component)FillArea.GetGameObject().transform.GetChild(0)).gameObject;
											}
										}

										public static GameObject GetGameObject()
										{
											return ((Component)SliderOutline.GetGameObject().transform.GetChild(1)).gameObject;
										}
									}

									public class HandleSlideArea
									{
										public class Handle
										{
											public class Current
											{
												public static GameObject GetGameObject()
												{
													return ((Component)Handle.GetGameObject().transform.GetChild(0)).gameObject;
												}
											}

											public static GameObject GetGameObject()
											{
												return ((Component)HandleSlideArea.GetGameObject().transform.GetChild(0)).gameObject;
											}
										}

										public static GameObject GetGameObject()
										{
											return ((Component)SliderOutline.GetGameObject().transform.GetChild(2)).gameObject;
										}
									}

									public static GameObject GetGameObject()
									{
										return ((Component)FieldOfView.GetGameObject().transform.GetChild(3)).gameObject;
									}
								}

								public static GameObject GetGameObject()
								{
									return ((Component)Panel.GetGameObject().transform.GetChild(2)).gameObject;
								}
							}

							public class Enabled
							{
								public class Label
								{
									public static GameObject GetGameObject()
									{
										return ((Component)Enabled.GetGameObject().transform.GetChild(0)).gameObject;
									}
								}

								public class ToggleStandard
								{
									public class Check
									{
										public class Checkmark
										{
											public static GameObject GetGameObject()
											{
												return ((Component)Check.GetGameObject().transform.GetChild(0)).gameObject;
											}
										}

										public class Filled
										{
											public static GameObject GetGameObject()
											{
												return ((Component)Check.GetGameObject().transform.GetChild(1)).gameObject;
											}
										}

										public static GameObject GetGameObject()
										{
											return ((Component)ToggleStandard.GetGameObject().transform.GetChild(0)).gameObject;
										}
									}

									public class LabelOn
									{
										public static GameObject GetGameObject()
										{
											return ((Component)ToggleStandard.GetGameObject().transform.GetChild(1)).gameObject;
										}
									}

									public static GameObject GetGameObject()
									{
										return ((Component)Enabled.GetGameObject().transform.GetChild(1)).gameObject;
									}
								}

								public static GameObject GetGameObject()
								{
									return ((Component)Panel.GetGameObject().transform.GetChild(3)).gameObject;
								}
							}

							public class ToggleLabel
							{
								public static GameObject GetGameObject()
								{
									return ((Component)Panel.GetGameObject().transform.GetChild(4)).gameObject;
								}
							}

							public class RockCamWarning
							{
								public static GameObject GetGameObject()
								{
									return ((Component)Panel.GetGameObject().transform.GetChild(5)).gameObject;
								}
							}

							public class LIVsetupmanualbutton
							{
								public class Text
								{
									public static GameObject GetGameObject()
									{
										return ((Component)LIVsetupmanualbutton.GetGameObject().transform.GetChild(0)).gameObject;
									}
								}

								public class Ripple
								{
									public static GameObject GetGameObject()
									{
										return ((Component)LIVsetupmanualbutton.GetGameObject().transform.GetChild(1)).gameObject;
									}
								}

								public static GameObject GetGameObject()
								{
									return ((Component)Panel.GetGameObject().transform.GetChild(6)).gameObject;
								}
							}

							public class LIVLabel
							{
								public static GameObject GetGameObject()
								{
									return ((Component)Panel.GetGameObject().transform.GetChild(7)).gameObject;
								}
							}

							public static GameObject GetGameObject()
							{
								return ((Component)RecordingUI.GetGameObject().transform.GetChild(0)).gameObject;
							}
						}

						public class CameraDisableWarning
						{
							public class TooltipRect
							{
								public class Content
								{
									public class Shadow
									{
										public static GameObject GetGameObject()
										{
											return ((Component)Content.GetGameObject().transform.GetChild(0)).gameObject;
										}
									}

									public class Background
									{
										public static GameObject GetGameObject()
										{
											return ((Component)Content.GetGameObject().transform.GetChild(1)).gameObject;
										}
									}

									public class Description
									{
										public static GameObject GetGameObject()
										{
											return ((Component)Content.GetGameObject().transform.GetChild(2)).gameObject;
										}
									}

									public static GameObject GetGameObject()
									{
										return ((Component)TooltipRect.GetGameObject().transform.GetChild(0)).gameObject;
									}
								}

								public static GameObject GetGameObject()
								{
									return ((Component)CameraDisableWarning.GetGameObject().transform.GetChild(0)).gameObject;
								}
							}

							public static GameObject GetGameObject()
							{
								return ((Component)RecordingUI.GetGameObject().transform.GetChild(1)).gameObject;
							}
						}

						public static GameObject GetGameObject()
						{
							return ((Component)UI.GetGameObject().transform.GetChild(0)).gameObject;
						}
					}

					public class EventSystem
					{
						public static GameObject GetGameObject()
						{
							return ((Component)UI.GetGameObject().transform.GetChild(1)).gameObject;
						}
					}

					public static GameObject GetGameObject()
					{
						return ((Component)GameInstance.GetGameObject().transform.GetChild(3)).gameObject;
					}
				}

				public class External
				{
					public class LanguageManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)External.GetGameObject().transform.GetChild(0)).gameObject;
						}
					}

					public class LCKStatusUtility
					{
						public static GameObject GetGameObject()
						{
							return ((Component)External.GetGameObject().transform.GetChild(1)).gameObject;
						}
					}

					public class PunVoiceClient
					{
						public static GameObject GetGameOb