using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Diagnostics.SymbolStore;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Timers;
using System.Xml;
using System.Xml.Serialization;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CinematicUnityExplorer.Cinematic;
using CinematicUnityExplorer.Inspectors;
using CinematicUnityExplorer.LineDrawing;
using CinematicUnityExplorer.Patches;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mono.CSharp;
using Mono.CSharp.IL2CPP;
using Mono.CSharp.Linq;
using Mono.CSharp.Nullable;
using Mono.CSharp.yyParser;
using Mono.CSharp.yydebug;
using Mono.CompilerServices.SymbolWriter;
using MonoMod.RuntimeDetour;
using Tomlet;
using Tomlet.Attributes;
using Tomlet.Exceptions;
using Tomlet.Models;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityExplorer;
using UnityExplorer.CSConsole;
using UnityExplorer.CSConsole.Lexers;
using UnityExplorer.CacheObject;
using UnityExplorer.CacheObject.IValues;
using UnityExplorer.CacheObject.Views;
using UnityExplorer.CatmullRom;
using UnityExplorer.Config;
using UnityExplorer.Hooks;
using UnityExplorer.Inspectors;
using UnityExplorer.Inspectors.MouseInspectors;
using UnityExplorer.Loader.BIE;
using UnityExplorer.ObjectExplorer;
using UnityExplorer.Runtime;
using UnityExplorer.Serializers;
using UnityExplorer.UI;
using UnityExplorer.UI.Panels;
using UnityExplorer.UI.Widgets;
using UnityExplorer.UI.Widgets.AutoComplete;
using UnityExplorerPlus.ParseUtility;
using UniverseLib;
using UniverseLib.Config;
using UniverseLib.Input;
using UniverseLib.Runtime;
using UniverseLib.UI;
using UniverseLib.UI.Models;
using UniverseLib.UI.ObjectPool;
using UniverseLib.UI.Panels;
using UniverseLib.UI.Widgets;
using UniverseLib.UI.Widgets.ButtonList;
using UniverseLib.UI.Widgets.ScrollView;
using UniverseLib.Utility;

[assembly: AssemblyTitle("CinematicUnityExplorer")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: ComVisible(false)]
[assembly: Guid("b21dbde3-5d6f-4726-93ab-cc3cc68bae7d")]
[assembly: AssemblyFileVersion("1.4.0")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCompany("originalnicodr, Sinai, yukieiji")]
[assembly: AssemblyProduct("CinematicUnityExplorer")]
[assembly: AssemblyCopyright("")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<ea549b1f-d2b1-43fc-b732-d20c4d3ca6f0>Embedded]
	internal sealed class <ea549b1f-d2b1-43fc-b732-d20c4d3ca6f0>EmbeddedAttribute : System.Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<ea549b1f-d2b1-43fc-b732-d20c4d3ca6f0>Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace UnityExplorerPlus.ParseUtility
{
	public static class ParseManager
	{
		private static readonly Dictionary<string, Func<object, string>> customToStringsByFullName = new Dictionary<string, Func<object, string>>();

		private static readonly Dictionary<Type, Func<object, string>> customToStrings = new Dictionary<Type, Func<object, string>>();

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

		private static Type GetCachedType(string typeFullName)
		{
			if (typeCache.TryGetValue(typeFullName, out var value))
			{
				return value;
			}
			Type type = AccessTools.TypeByName(typeFullName);
			if ((object)type != null)
			{
				typeCache[typeFullName] = type;
			}
			return type;
		}

		public static string TryGetCustomToString(object value)
		{
			if (UnityHelpers.IsNullOrDestroyed(value, true))
			{
				return null;
			}
			Type type = value.GetType();
			if (customToStrings.TryGetValue(type, out var value2))
			{
				return value2(value);
			}
			return customToStrings.FirstOrDefault((KeyValuePair<Type, Func<object, string>> x) => x.Key.IsInstanceOfType(value)).Value?.Invoke(value);
		}

		public static bool IsTypeRegisteredForToString(Type type)
		{
			return customToStrings.ContainsKey(type) || customToStrings.Any((KeyValuePair<Type, Func<object, string>> x) => x.Key.IsInstanceOfType(type));
		}

		public static void RegisterToString(string typeFullName, Func<object, string> toString)
		{
			if (customToStringsByFullName.ContainsKey(typeFullName))
			{
			}
			customToStringsByFullName[typeFullName] = toString;
			Type cachedType = GetCachedType(typeFullName);
			if ((object)cachedType != null)
			{
				customToStrings[cachedType] = toString;
			}
		}

		public static void RegisterToString<T>(Func<T, string> toString)
		{
			RegisterToString(typeof(T).FullName, (object val) => toString((T)val));
		}

		public static void Init()
		{
			RegisterToString("tk2dSpriteAnimationClip", delegate(object clip)
			{
				string text11 = ((clip?.GetType().GetField("name"))?.GetValue(clip) as string) ?? "UnnamedClip";
				return "<color=grey>tk2dSpriteAnimationClip: </color><color=green>" + text11 + "</color>";
			});
			RegisterToString("tk2dSpriteDefinition", delegate(object def)
			{
				string text10 = ((def?.GetType().GetField("name"))?.GetValue(def) as string) ?? "UnnamedDefinition";
				return "<color=grey>tk2dSpriteDefinition: </color><color=green>" + text10 + "</color>";
			});
			RegisterToString("tk2dSpriteAnimationFrame", delegate(object frame)
			{
				string text9 = (frame?.GetType().GetField("spriteId"))?.GetValue(frame)?.ToString() ?? "UnnamedSpriteId";
				return "<color=grey>tk2dSpriteAnimationFrame: </color><color=green>" + text9 + "</color>";
			});
			RegisterToString("HutongGames.PlayMaker.FsmState", delegate(object state)
			{
				string text8 = ((state?.GetType().GetProperty("Name"))?.GetValue(state, null) as string) ?? "UnnamedState";
				return "<color=grey>Fsm State: </color><color=green>" + text8 + "</color>";
			});
			RegisterToString("HutongGames.PlayMaker.FsmTransition", delegate(object tran)
			{
				Type type2 = tran?.GetType();
				object obj2 = (type2?.GetProperty("FsmEvent"))?.GetValue(tran, null);
				string text4 = null;
				if (obj2 != null)
				{
					text4 = obj2.GetType().GetProperty("Name")?.GetValue(obj2, null) as string;
				}
				string text5 = (type2?.GetProperty("EventName"))?.GetValue(tran, null) as string;
				object obj3 = (type2?.GetProperty("ToFsmState"))?.GetValue(tran, null);
				string text6 = null;
				if (obj3 != null)
				{
					text6 = obj3.GetType().GetProperty("Name")?.GetValue(obj3, null) as string;
				}
				string text7 = (type2?.GetProperty("ToState"))?.GetValue(tran, null) as string;
				return "<color=grey>Fsm Transition: </color><color=green>" + (text4 ?? text5) + "</color><color=grey> -> </color><color=green>" + (text6 ?? text7) + "</color>";
			});
			RegisterToString("HutongGames.PlayMaker.FsmEvent", delegate(object ev)
			{
				string text3 = ((ev?.GetType().GetProperty("Name"))?.GetValue(ev, null) as string) ?? "UnnamedEvent";
				return "<color=grey>Fsm Event: </color><color=green>" + text3 + "</color>";
			});
			RegisterToString("HutongGames.PlayMaker.NamedVariable", delegate(object v)
			{
				Type type = v?.GetType();
				string text = (type?.GetProperty("VariableType"))?.GetValue(v, null)?.ToString() ?? "Unknown";
				string text2 = ((type?.GetProperty("Name"))?.GetValue(v, null) as string) ?? "Unnamed";
				object obj = (type?.GetProperty("Value"))?.GetValue(v, null);
				return "<color=grey>Fsm Variable(</color><color=green>" + text + "</color><color=grey>): </color><color=green>" + text2 + "</color> | " + ToStringUtility.ToStringWithType(obj, typeof(object), true);
			});
		}
	}
}
namespace System.Runtime.CompilerServices
{
	internal static class IsExternalInit
	{
	}
}
namespace CinematicUnityExplorer
{
	public static class Drawing
	{
		private static Texture2D aaLineTex;

		private static Texture2D lineTex;

		private static Material blitMaterial;

		private static Material blendMaterial;

		private static Rect lineRect;

		public static void DrawLine(Vector2 pointA, Vector2 pointB, Color color, float width, bool antiAlias)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			float num = pointB.x - pointA.x;
			float num2 = pointB.y - pointA.y;
			float num3 = Mathf.Sqrt(num * num + num2 * num2);
			if (!(num3 < 0.001f))
			{
				Texture2D val;
				Material val2;
				if (antiAlias)
				{
					width *= 3f;
					val = aaLineTex;
					val2 = blendMaterial;
				}
				else
				{
					val = lineTex;
					val2 = blitMaterial;
				}
				float num4 = width * num2 / num3;
				float num5 = width * num / num3;
				Matrix4x4 identity = Matrix4x4.identity;
				identity.m00 = num;
				identity.m01 = 0f - num4;
				identity.m03 = pointA.x + 0.5f * num4;
				identity.m10 = num2;
				identity.m11 = num5;
				identity.m13 = pointA.y - 0.5f * num5;
				GL.PushMatrix();
				GL.MultMatrix(identity);
				Graphics.DrawTexture(lineRect, (Texture)(object)val, lineRect, 0, 0, 0, 0, color, val2);
				if (antiAlias)
				{
					Graphics.DrawTexture(lineRect, (Texture)(object)val, lineRect, 0, 0, 0, 0, color, val2);
				}
				GL.PopMatrix();
			}
		}

		public static void DrawCircle(Vector2 center, int radius, Color color, float width, int segmentsPerQuarter)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			DrawCircle(center, radius, color, width, antiAlias: false, segmentsPerQuarter);
		}

		public static void DrawCircle(Vector2 center, int radius, Color color, float width, bool antiAlias, int segmentsPerQuarter)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)radius * 0.55191505f;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(center.x, center.y - (float)radius);
			Vector2 endTangent = default(Vector2);
			((Vector2)(ref endTangent))..ctor(center.x - num, center.y - (float)radius);
			Vector2 startTangent = default(Vector2);
			((Vector2)(ref startTangent))..ctor(center.x + num, center.y - (float)radius);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(center.x + (float)radius, center.y);
			Vector2 endTangent2 = default(Vector2);
			((Vector2)(ref endTangent2))..ctor(center.x + (float)radius, center.y - num);
			Vector2 startTangent2 = default(Vector2);
			((Vector2)(ref startTangent2))..ctor(center.x + (float)radius, center.y + num);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(center.x, center.y + (float)radius);
			Vector2 startTangent3 = default(Vector2);
			((Vector2)(ref startTangent3))..ctor(center.x - num, center.y + (float)radius);
			Vector2 endTangent3 = default(Vector2);
			((Vector2)(ref endTangent3))..ctor(center.x + num, center.y + (float)radius);
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor(center.x - (float)radius, center.y);
			Vector2 startTangent4 = default(Vector2);
			((Vector2)(ref startTangent4))..ctor(center.x - (float)radius, center.y - num);
			Vector2 endTangent4 = default(Vector2);
			((Vector2)(ref endTangent4))..ctor(center.x - (float)radius, center.y + num);
			DrawBezierLine(val, startTangent, val2, endTangent2, color, width, antiAlias, segmentsPerQuarter);
			DrawBezierLine(val2, startTangent2, val3, endTangent3, color, width, antiAlias, segmentsPerQuarter);
			DrawBezierLine(val3, startTangent3, val4, endTangent4, color, width, antiAlias, segmentsPerQuarter);
			DrawBezierLine(val4, startTangent4, val, endTangent, color, width, antiAlias, segmentsPerQuarter);
		}

		public static void DrawBezierLine(Vector2 start, Vector2 startTangent, Vector2 end, Vector2 endTangent, Color color, float width, bool antiAlias, int segments)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Vector2 pointA = CubeBezier(start, startTangent, end, endTangent, 0f);
			for (int i = 1; i < segments + 1; i++)
			{
				Vector2 val = CubeBezier(start, startTangent, end, endTangent, (float)i / (float)segments);
				DrawLine(pointA, val, color, width, antiAlias);
				pointA = val;
			}
		}

		private static Vector2 CubeBezier(Vector2 s, Vector2 st, Vector2 e, Vector2 et, float t)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			float num = 1f - t;
			return num * num * num * s + 3f * num * num * t * st + 3f * num * t * t * et + t * t * t * e;
		}

		static Drawing()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			aaLineTex = null;
			lineTex = null;
			blitMaterial = null;
			blendMaterial = null;
			lineRect = new Rect(0f, 0f, 1f, 1f);
			Initialize();
		}

		private static void Initialize()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)lineTex == (Object)null)
			{
				lineTex = new Texture2D(1, 1, (TextureFormat)5, false);
				lineTex.SetPixel(0, 1, Color.white);
				lineTex.Apply();
			}
			if ((Object)(object)aaLineTex == (Object)null)
			{
				aaLineTex = new Texture2D(1, 3, (TextureFormat)5, false);
				aaLineTex.SetPixel(0, 0, new Color(1f, 1f, 1f, 0f));
				aaLineTex.SetPixel(0, 1, Color.white);
				aaLineTex.SetPixel(0, 2, new Color(1f, 1f, 1f, 0f));
				aaLineTex.Apply();
			}
			blitMaterial = (Material)typeof(GUI).GetMethod("get_blitMaterial", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, null);
			blendMaterial = (Material)typeof(GUI).GetMethod("get_blendMaterial", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, null);
		}
	}
	public abstract class SingleMonoBehaviour<T> : MonoBehaviour where T : SingleMonoBehaviour<T>
	{
		private static T _instance;

		public static T Instance
		{
			get
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					_instance = Object.FindObjectOfType<T>();
					if ((Object)(object)_instance == (Object)null)
					{
						GameObject val = new GameObject(typeof(T).Name);
						_instance = val.AddComponent<T>();
					}
				}
				return _instance;
			}
		}

		protected virtual void Awake()
		{
			if ((Object)(object)_instance != (Object)null && (Object)(object)_instance != (Object)(object)this)
			{
				Debug.LogWarning((object)("Another instance of " + typeof(T).Name + " already exists. Destroying this one."));
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				_instance = (T)this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
		}

		protected virtual void OnDestroy()
		{
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
		}
	}
}
namespace CinematicUnityExplorer.Patches
{
	[HarmonyPatch]
	public static class CinematicUnityExplorerPatches
	{
		private static Type _playMakerFSMType;

		private static Type GetPlayMakerFSMType()
		{
			if ((object)_playMakerFSMType == null)
			{
				_playMakerFSMType = ReflectionUtility.GetTypeByName("PlayMakerFSM");
				if ((object)_playMakerFSMType != null)
				{
				}
			}
			return _playMakerFSMType;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ToStringUtility), "ToStringWithType")]
		public static bool ToStringWithType_Prefix(object value, Type fallbackType, bool includeNamespace, ref string __result)
		{
			string text = ParseManager.TryGetCustomToString(value);
			if (text != null)
			{
				__result = text;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(CacheObjectBase), "SetDataToCell")]
		[HarmonyPostfix]
		public static void CacheObjectBase_SetDataToCell_Postfix(CacheObjectBase __instance, CacheObjectCell cell)
		{
			if (__instance.Value == null || !ParseManager.IsTypeRegisteredForToString(__instance.Value.GetType()))
			{
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(CacheObjectBase), "SetValueState", (Type[])null, (Type[])null);
			if ((object)methodInfo != null)
			{
				Type type = AccessTools.Inner(typeof(CacheObjectBase), "ValueState");
				if ((object)type != null)
				{
					object obj = Activator.CreateInstance(type, true, __instance.CanWrite, __instance.CanWrite, true);
					methodInfo.Invoke(__instance, new object[2] { cell, obj });
				}
			}
		}

		[HarmonyPatch(typeof(ComponentList), "SetComponentCell")]
		[HarmonyPostfix]
		public static void ComponentList_SetComponentCell_Postfix(ComponentList __instance, ComponentCell cell, int index)
		{
			GameObjectInspector parent = __instance.Parent;
			if (parent == null)
			{
				return;
			}
			GameObject target = parent.Target;
			if (!((Object)(object)target != (Object)null))
			{
				return;
			}
			Component[] components = target.GetComponents<Component>();
			if (index < 0 || index >= components.Length)
			{
				return;
			}
			Component val = components[index];
			Type playMakerFSMType = GetPlayMakerFSMType();
			if ((object)playMakerFSMType == null || !playMakerFSMType.IsInstanceOfType(val))
			{
				return;
			}
			try
			{
				PropertyInfo property = playMakerFSMType.GetProperty("FsmName", BindingFlags.Instance | BindingFlags.Public);
				if ((object)property != null)
				{
					object value = property.GetValue(val, null);
					string text = value as string;
					if (!string.IsNullOrEmpty(text))
					{
						((ButtonCell)cell).Button.ButtonText.text = ((ButtonCell)cell).Button.ButtonText.text + "<color=grey>(</color><color=#7FFF00>" + text + "</color><color=grey>)</color>";
					}
				}
			}
			catch (Exception)
			{
			}
		}
	}
}
namespace CinematicUnityExplorer.Inspectors
{
	public struct TriangleVertices
	{
		public Vector3 VertexA;

		public Vector3 VertexB;

		public Vector3 VertexC;

		public TriangleVertices(Vector3 a, Vector3 b, Vector3 c)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			VertexA = a;
			VertexB = b;
			VertexC = c;
		}

		public void Deconstruct(out Vector3 a, out Vector3 b, out Vector3 c)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			a = VertexA;
			b = VertexB;
			c = VertexC;
		}
	}
	public static class TransformExtensions
	{
		public static float GetScaleX(this Transform transform)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return transform.localScale.x;
		}

		public static float GetScaleY(this Transform transform)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return transform.localScale.y;
		}

		public static string GetTransformPath(this Transform transform, bool includeSelf = true)
		{
			string text = (includeSelf ? ((Object)transform).name : "");
			Transform parent = transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}
	}
	public static class VectorExtensions
	{
		public static Vector3 MultiplyElements(this Vector3 a, Vector3 b)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(a.x * b.x, a.y * b.y, a.z * b.z);
		}

		public static Vector2 MultiplyElements(this Vector2 a, Vector2 b)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(a.x * b.x, a.y * b.y);
		}
	}
}
namespace CinematicUnityExplorer.LineDrawing
{
	public class LineData
	{
		public Vector2 Start { get; }

		public Vector2 End { get; }

		public Color Color { get; }

		public int Depth { get; }

		public float Width { get; }

		public LineData(Vector2 start, Vector2 end, Color color, int depth, float width = 0.7f)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Start = start;
			End = end;
			Color = color;
			Depth = depth;
			Width = width;
		}
	}
	internal interface ILineProvider
	{
		List<LineData> Lines { get; }
	}
	internal class LineRenderer2 : SingleMonoBehaviour<LineRenderer2>
	{
		public List<ILineProvider> providers = new List<ILineProvider>();

		private void OnGUI()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Event current = Event.current;
			if (current == null || (int)current.type != 7)
			{
				return;
			}
			foreach (ILineProvider provider in providers)
			{
				foreach (LineData line in provider.Lines)
				{
					int depth = GUI.depth;
					GUI.depth = line.Depth;
					Drawing.DrawLine(line.Start, line.End, line.Color, line.Width, antiAlias: false);
					GUI.depth = depth;
				}
			}
		}
	}
	public struct Triangle
	{
		public Vector3 A;

		public Vector3 B;

		public Vector3 C;

		public Triangle(Vector3 a, Vector3 b, Vector3 c)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			A = a;
			B = b;
			C = c;
		}
	}
}
namespace CinematicUnityExplorer.Cinematic
{
	internal static class NativeMethods
	{
		[DllImport("kernel32.dll")]
		public static extern IntPtr LoadLibrary(string dll);

		[DllImport("kernel32.dll")]
		public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
	}
	public class UnityIGCSConnector
	{
		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate void MoveCameraCallback(float step_left, float step_up, float fov, int from_start);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate void SessionCallback();

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate IntPtr U_IGCS_Initialize(MoveCameraCallback callback, SessionCallback start_cb, SessionCallback end_cb);

		private Mono.CSharp.Tuple<Vector3, Quaternion> position = null;

		private Mono.CSharp.Tuple<Vector3, Quaternion> endSessionPosition = null;

		private readonly bool isValid = false;

		private bool _isActive = false;

		private readonly List<System.Delegate> delegates = new List<System.Delegate>();

		private readonly Queue<Mono.CSharp.Tuple<float, float>> commands = new Queue<Mono.CSharp.Tuple<float, float>>();

		private IntPtr CameraStatus = IntPtr.Zero;

		public bool IsActive => isValid && _isActive;

		public void UpdateFreecamStatus(bool enabled)
		{
			if (!(CameraStatus == IntPtr.Zero))
			{
				Marshal.WriteByte(CameraStatus, (byte)(enabled ? 1 : 0));
			}
		}

		public void ExecuteCameraCommand(Camera cam)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)cam).transform;
			ShouldMoveToOriginalPosition(transform);
			if (!_isActive || position == null)
			{
				position = new Mono.CSharp.Tuple<Vector3, Quaternion>(transform.position, transform.rotation);
			}
			if (!_isActive || position == null)
			{
				return;
			}
			Mono.CSharp.Tuple<float, float> tuple = null;
			lock (commands)
			{
				if (commands.Count <= 0)
				{
					return;
				}
				tuple = commands.Dequeue();
			}
			transform.position = position.Item1;
			transform.rotation = position.Item2;
			transform.Translate(tuple.Item1, tuple.Item2, 0f);
		}

		private void MoveCamera(float stepLeft, float stepUp, float fov, int fromStart)
		{
			lock (commands)
			{
				commands.Enqueue(new Mono.CSharp.Tuple<float, float>(stepLeft, stepUp));
			}
		}

		private void StartSession()
		{
			_isActive = true;
		}

		public void ShouldMoveToOriginalPosition(Transform transform)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (isValid && endSessionPosition != null)
			{
				transform.position = endSessionPosition.Item1;
				transform.rotation = endSessionPosition.Item2;
				endSessionPosition = null;
			}
		}

		private void EndSession()
		{
			endSessionPosition = position;
			position = null;
			_isActive = false;
			lock (commands)
			{
				commands.Clear();
			}
		}

		public UnityIGCSConnector()
		{
			string text = ((IntPtr.Size == 8) ? "UnityIGCSConnector.dll" : "UnityIGCSConnector.32.dll");
			IntPtr intPtr = NativeMethods.LoadLibrary(text);
			if (intPtr == IntPtr.Zero)
			{
				ExplorerCore.LogWarning(text + " was not found so IGCSDof will not be available");
				return;
			}
			IntPtr procAddress = NativeMethods.GetProcAddress(intPtr, "U_IGCS_Initialize");
			if (procAddress == IntPtr.Zero)
			{
				throw new EntryPointNotFoundException("Failed to find 'U_IGCS_Initialize' which means you can have a corrupt UnityIGCSConnector.dll.");
			}
			U_IGCS_Initialize u_IGCS_Initialize = (U_IGCS_Initialize)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(U_IGCS_Initialize));
			delegates.Add(new MoveCameraCallback(MoveCamera));
			delegates.Add(new SessionCallback(StartSession));
			delegates.Add(new SessionCallback(EndSession));
			CameraStatus = u_IGCS_Initialize((MoveCameraCallback)delegates[0], (SessionCallback)delegates[1], (SessionCallback)delegates[2]);
			if (CameraStatus == IntPtr.Zero)
			{
				throw new Exception("IGCSDof returned an invalid pointer which means something went wrong");
			}
			isValid = true;
		}
	}
}
namespace UniverseLib.Input
{
	public static class IGamepadInputInterceptor
	{
		private static bool _isEnabled = false;

		private static int _targetGamepadIndex = 0;

		private static Type _gamepadType;

		private static Type _buttonControlType;

		private static Type _axisControlType;

		private static Type _vector2ControlType;

		private static Type _inputControlType;

		private static PropertyInfo _basePathProp;

		private static PropertyInfo _buttonIsPressedProp;

		private static PropertyInfo _buttonWasPressedProp;

		private static PropertyInfo _buttonWasReleasedProp;

		private static MethodInfo _axisReadValueMethod;

		private static MethodInfo _vector2ReadValueMethod;

		private static PropertyInfo _deviceProp;

		private static PropertyInfo _vector2XProp;

		private static PropertyInfo _vector2YProp;

		private static PropertyInfo _gamepadAllProp;

		private static PropertyInfo _gamepadCurrentProp;

		private static PropertyInfo _gamepadLeftStickProp;

		private static PropertyInfo _gamepadRightStickProp;

		private static readonly Dictionary<string, string> _vendorPrefixMap = new Dictionary<string, string>
		{
			{ "/xinputcontrollerwindows", "/gamepad" },
			{ "/xinputcontroller", "/gamepad" },
			{ "/dualshockgamepad", "/gamepad" },
			{ "/dualsensegamepad", "/gamepad" },
			{ "/dualshock4gamepadhid", "/gamepad" },
			{ "/dualshock3gamepadhid", "/gamepad" },
			{ "/androidgamepad", "/gamepad" },
			{ "/switchprocontrollerhid", "/gamepad" }
		};

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

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

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

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

		public static void Init()
		{
			try
			{
				LoadReflectedTypes();
				if ((object)_gamepadType != null && (object)_axisControlType != null)
				{
					PatchAnalogControls();
					DiscoverGamepadControls();
					_isEnabled = true;
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Init failed: " + ex.Message + "\n" + ex.StackTrace);
			}
		}

		public static void Enable()
		{
			_isEnabled = true;
		}

		public static void Disable()
		{
			_isEnabled = false;
		}

		public static void SetTargetGamepad(int index)
		{
			_targetGamepadIndex = index;
			ClearControlCaches();
			DiscoverGamepadControls();
		}

		private static void LoadReflectedTypes()
		{
			_gamepadType = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Gamepad, Unity.InputSystem");
			_buttonControlType = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.ButtonControl, Unity.InputSystem");
			_axisControlType = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.AxisControl, Unity.InputSystem");
			_vector2ControlType = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.Vector2Control, Unity.InputSystem");
			_inputControlType = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.InputControl, Unity.InputSystem");
			_basePathProp = _inputControlType?.GetProperty("path", BindingFlags.Instance | BindingFlags.Public);
			_buttonIsPressedProp = _buttonControlType?.GetProperty("isPressed", BindingFlags.Instance | BindingFlags.Public);
			_buttonWasPressedProp = _buttonControlType?.GetProperty("wasPressedThisFrame", BindingFlags.Instance | BindingFlags.Public);
			_buttonWasReleasedProp = _buttonControlType?.GetProperty("wasReleasedThisFrame", BindingFlags.Instance | BindingFlags.Public);
			_axisReadValueMethod = _axisControlType?.GetMethod("ReadValue", Type.EmptyTypes);
			_vector2ReadValueMethod = _vector2ControlType?.GetMethod("ReadValue", Type.EmptyTypes);
			_deviceProp = _inputControlType?.GetProperty("device", BindingFlags.Instance | BindingFlags.Public);
			_vector2XProp = _vector2ControlType?.GetProperty("x", BindingFlags.Instance | BindingFlags.Public);
			_vector2YProp = _vector2ControlType?.GetProperty("y", BindingFlags.Instance | BindingFlags.Public);
			_gamepadAllProp = _gamepadType?.GetProperty("all", BindingFlags.Static | BindingFlags.Public);
			_gamepadCurrentProp = _gamepadType?.GetProperty("current", BindingFlags.Static | BindingFlags.Public);
			_gamepadLeftStickProp = _gamepadType?.GetProperty("leftStick", BindingFlags.Instance | BindingFlags.Public);
			_gamepadRightStickProp = _gamepadType?.GetProperty("rightStick", BindingFlags.Instance | BindingFlags.Public);
		}

		private static void LogLoadedType(string name, Type type)
		{
			if ((object)type != null)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Loaded type: " + name);
			}
			else
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to load type: " + name);
			}
		}

		private static void PatchAnalogControls()
		{
			try
			{
				if ((object)_vector2ControlType != null)
				{
					MethodInfo method = _vector2ControlType.GetMethod("ReadValue", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
					if ((object)method == null)
					{
						Type baseType = _vector2ControlType.BaseType;
						if ((object)baseType != null && baseType.IsGenericType)
						{
							method = baseType.GetMethod("ReadValue", BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
						}
					}
					if ((object)method != null)
					{
						PatchMethod(method, null, "Postfix_Vector2ReadValue");
					}
				}
				if ((object)_axisControlType == null)
				{
					return;
				}
				MethodInfo method2 = _axisControlType.GetMethod("ReadValue", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
				if ((object)method2 == null)
				{
					Type baseType2 = _axisControlType.BaseType;
					if ((object)baseType2 != null && baseType2.IsGenericType)
					{
						method2 = baseType2.GetMethod("ReadValue", BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
					}
				}
				if ((object)method2 != null)
				{
					PatchMethod(method2, null, "Postfix_AxisReadValue");
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Error during patching: " + ex.Message);
			}
		}

		private static void PatchMethod(MethodInfo method, string prefixName, string postfixName)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((object)method != null)
				{
					MethodInfo methodInfo = ((prefixName != null) ? AccessTools.Method(typeof(IGamepadInputInterceptor), prefixName, (Type[])null, (Type[])null) : null);
					MethodInfo methodInfo2 = ((postfixName != null) ? AccessTools.Method(typeof(IGamepadInputInterceptor), postfixName, (Type[])null, (Type[])null) : null);
					object obj = ExplorerCore.Harmony;
					obj = method;
					obj = (object)(((object)methodInfo == null) ? ((HarmonyMethod)null) : new HarmonyMethod(methodInfo));
					obj = (object)(((object)methodInfo2 == null) ? ((HarmonyMethod)null) : new HarmonyMethod(methodInfo2));
					((Harmony)obj).Patch((MethodBase)obj, (HarmonyMethod)obj, (HarmonyMethod)obj, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to patch method: " + ex.Message);
			}
		}

		private static void DiscoverGamepadControls()
		{
			try
			{
				object gamepadInstance = GetGamepadInstance(_targetGamepadIndex);
				if (gamepadInstance == null)
				{
					return;
				}
				string[] array = new string[12]
				{
					"buttonSouth", "buttonNorth", "buttonWest", "buttonEast", "leftStickButton", "rightStickButton", "leftShoulder", "rightShoulder", "startButton", "selectButton",
					"leftTrigger", "rightTrigger"
				};
				string[] array2 = new string[2] { "leftStick", "rightStick" };
				string[] array3 = array;
				foreach (string text in array3)
				{
					try
					{
						PropertyInfo property = _gamepadType.GetProperty(text, BindingFlags.Instance | BindingFlags.Public);
						if ((object)property == null)
						{
							continue;
						}
						object value = property.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value != null)
						{
							string text2 = ExtractAndNormalizePath(value);
							if (!string.IsNullOrEmpty(text2))
							{
								INewInputSystem.gamepadButtonControls[text2] = value;
							}
						}
					}
					catch (Exception ex)
					{
						ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access button " + text + ": " + ex.Message);
					}
				}
				try
				{
					PropertyInfo property2 = _gamepadType.GetProperty("dpad", BindingFlags.Instance | BindingFlags.Public);
					if ((object)property2 != null)
					{
						object value2 = property2.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value2 != null)
						{
							string[] array4 = new string[4] { "up", "down", "left", "right" };
							string[] array5 = array4;
							foreach (string text3 in array5)
							{
								try
								{
									PropertyInfo property3 = value2.GetType().GetProperty(text3, BindingFlags.Instance | BindingFlags.Public);
									if ((object)property3 == null)
									{
										continue;
									}
									object value3 = property3.GetValue(value2, BindingFlags.Default, null, null, null);
									if (value3 != null)
									{
										string text4 = ExtractAndNormalizePath(value3);
										if (!string.IsNullOrEmpty(text4))
										{
											INewInputSystem.gamepadButtonControls[text4] = value3;
										}
									}
								}
								catch (Exception ex2)
								{
									ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access dpad." + text3 + ": " + ex2.Message);
								}
							}
						}
					}
				}
				catch (Exception ex3)
				{
					ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access dpad: " + ex3.Message);
				}
				string[] array6 = array2;
				foreach (string text5 in array6)
				{
					try
					{
						PropertyInfo property4 = _gamepadType.GetProperty(text5, BindingFlags.Instance | BindingFlags.Public);
						if ((object)property4 == null)
						{
							continue;
						}
						object value4 = property4.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value4 == null)
						{
							continue;
						}
						string text6 = ExtractAndNormalizePath(value4);
						if (!string.IsNullOrEmpty(text6))
						{
							_vector2Controls[text6] = value4;
						}
						string[] array7 = new string[2] { "x", "y" };
						string[] array8 = array7;
						foreach (string text7 in array8)
						{
							try
							{
								PropertyInfo property5 = value4.GetType().GetProperty(text7, BindingFlags.Instance | BindingFlags.Public);
								if ((object)property5 == null)
								{
									continue;
								}
								object value5 = property5.GetValue(value4, BindingFlags.Default, null, null, null);
								if (value5 != null)
								{
									string value6 = ExtractAndNormalizePath(value5);
									if (!string.IsNullOrEmpty(value6))
									{
										string text8 = text5.ToLowerInvariant();
										string key = "/gamepad/" + text8 + "/" + text7;
										_axisControls[key] = value5;
									}
								}
							}
							catch (Exception ex4)
							{
								ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access " + text5 + "." + text7 + ": " + ex4.Message);
							}
						}
					}
					catch (Exception ex5)
					{
						ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access vector2 " + text5 + ": " + ex5.Message);
					}
				}
				string[] array9 = new string[2] { "leftTrigger", "rightTrigger" };
				string[] array10 = array9;
				foreach (string text9 in array10)
				{
					try
					{
						PropertyInfo property6 = _gamepadType.GetProperty(text9, BindingFlags.Instance | BindingFlags.Public);
						if ((object)property6 == null)
						{
							continue;
						}
						object value7 = property6.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value7 != null)
						{
							string text10 = ExtractAndNormalizePath(value7);
							if (!string.IsNullOrEmpty(text10))
							{
								_axisControls[text10] = value7;
							}
						}
					}
					catch (Exception ex6)
					{
						ExplorerCore.LogWarning("[IGamepadInputInterceptor] Failed to access " + text9 + ": " + ex6.Message);
					}
				}
				int num = INewInputSystem.gamepadButtonControls.Count + _axisControls.Count + _vector2Controls.Count;
			}
			catch (Exception ex7)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Error discovering controls: " + ex7.Message + "\n" + ex7.StackTrace);
			}
		}

		private static object GetGamepadInstance(int index)
		{
			try
			{
				if ((object)_gamepadAllProp != null)
				{
					object value = _gamepadAllProp.GetValue(null, BindingFlags.Default, null, null, null);
					if (value != null)
					{
						Type type = value.GetType();
						PropertyInfo property = type.GetProperty("Count", BindingFlags.Instance | BindingFlags.Public);
						PropertyInfo property2 = type.GetProperty("Item", BindingFlags.Instance | BindingFlags.Public);
						if ((object)property != null && (object)property2 != null)
						{
							int num = (int)property.GetValue(value, BindingFlags.Default, null, null, null);
							if (index >= 0 && index < num)
							{
								return property2.GetValue(value, new object[1] { index });
							}
						}
					}
				}
				if ((object)_gamepadCurrentProp != null)
				{
					return _gamepadCurrentProp.GetValue(null, BindingFlags.Default, null, null, null);
				}
				return null;
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Error getting gamepad instance: " + ex.Message);
				return null;
			}
		}

		private static string ExtractAndNormalizePath(object control)
		{
			if (control == null)
			{
				return null;
			}
			string text = null;
			try
			{
				string text2 = control.ToString();
				if (!string.IsNullOrEmpty(text2))
				{
					int num = text2.IndexOf('/');
					if (num >= 0)
					{
						int num2 = text2.IndexOf('}', num);
						if (num2 >= 0)
						{
							text = text2.Substring(num, num2 - num);
						}
					}
				}
			}
			catch
			{
			}
			if (string.IsNullOrEmpty(text))
			{
				try
				{
					PropertyInfo property = control.GetType().GetProperty("name", BindingFlags.Instance | BindingFlags.Public);
					if ((object)property != null)
					{
						string text3 = property.GetValue(control, BindingFlags.Default, null, null, null) as string;
						if (!string.IsNullOrEmpty(text3))
						{
							text = "/gamepad/" + text3;
						}
					}
				}
				catch
				{
				}
			}
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			return NormalizeControlPath(text);
		}

		public static string NormalizeControlPath(string rawPath)
		{
			if (string.IsNullOrEmpty(rawPath))
			{
				return rawPath;
			}
			string text = rawPath.ToLowerInvariant().Trim();
			foreach (KeyValuePair<string, string> item in _vendorPrefixMap)
			{
				if (text.StartsWith(item.Key))
				{
					text = item.Value + text.Substring(item.Key.Length);
					break;
				}
			}
			int length = "/gamepad".Length;
			if (text.StartsWith("/gamepad") && text.Length > length && char.IsDigit(text[length]))
			{
				text = "/gamepad" + text.Substring(length + 1);
			}
			switch (text)
			{
			default:
				if (!(text == "/gamepad/right"))
				{
					break;
				}
				goto case "/gamepad/up";
			case "/gamepad/up":
			case "/gamepad/down":
			case "/gamepad/left":
			{
				string text2 = text.Substring("/gamepad/".Length);
				text = "/gamepad/dpad/" + text2;
				break;
			}
			}
			return text;
		}

		private static void ClearControlCaches()
		{
			INewInputSystem.gamepadButtonControls.Clear();
			_axisControls.Clear();
			_vector2Controls.Clear();
			_axisValues.Clear();
			_vector2Values.Clear();
		}

		public static bool IsButtonPressed(string buttonPath)
		{
			if (!_isEnabled)
			{
				return false;
			}
			string key = buttonPath.ToLower();
			if (INewInputSystem.gamepadButtonControls.TryGetValue(key, out var value) && (object)_buttonIsPressedProp != null)
			{
				_buttonIsPressedProp.GetValue(value, BindingFlags.Default, null, null, null);
			}
			bool value2;
			return INewInputSystem.buttonPressedStates.TryGetValue(key, out value2) && value2;
		}

		public static bool WasButtonPressedThisFrame(string buttonPath)
		{
			if (!_isEnabled)
			{
				return false;
			}
			string key = buttonPath.ToLower();
			if (INewInputSystem.gamepadButtonControls.TryGetValue(key, out var value) && (object)_buttonWasPressedProp != null)
			{
				_buttonWasPressedProp.GetValue(value, BindingFlags.Default, null, null, null);
			}
			bool value2;
			return INewInputSystem.buttonWasPressedStates.TryGetValue(key, out value2) && value2;
		}

		public static bool WasButtonReleasedThisFrame(string buttonPath)
		{
			if (!_isEnabled)
			{
				return false;
			}
			string key = buttonPath.ToLower();
			if (INewInputSystem.gamepadButtonControls.TryGetValue(key, out var value) && (object)_buttonWasReleasedProp != null)
			{
				_buttonWasReleasedProp.GetValue(value, BindingFlags.Default, null, null, null);
			}
			bool value2;
			return INewInputSystem.buttonWasReleasedStates.TryGetValue(key, out value2) && value2;
		}

		public static float GetAxisValue(string axisPath)
		{
			if (!_isEnabled)
			{
				return 0f;
			}
			string key = NormalizeControlPath(axisPath ?? "");
			if (_axisControls.TryGetValue(key, out var value) && (object)_axisReadValueMethod != null)
			{
				_axisReadValueMethod.Invoke(value, null);
			}
			float value2;
			return _axisValues.TryGetValue(key, out value2) ? value2 : 0f;
		}

		public static Vector2 GetVector2Value(string vectorPath)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (!_isEnabled)
			{
				return new Vector2(0f, 0f);
			}
			string key = NormalizeControlPath(vectorPath ?? "");
			if (_vector2Controls.TryGetValue(key, out var value) && (object)_vector2ReadValueMethod != null)
			{
				_vector2ReadValueMethod.Invoke(value, null);
			}
			Vector2 value2;
			return (Vector2)(_vector2Values.TryGetValue(key, out value2) ? value2 : new Vector2(0f, 0f));
		}

		public static IEnumerable<string> GetRegisteredButtonPaths()
		{
			return INewInputSystem.gamepadButtonControls.Keys;
		}

		public static IEnumerable<string> GetRegisteredAxisPaths()
		{
			return _axisControls.Keys;
		}

		public static IEnumerable<string> GetRegisteredVector2Paths()
		{
			return _vector2Controls.Keys;
		}

		private static void Postfix_Vector2ReadValue(object __instance, ref object __result)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (__instance == null || __result == null)
			{
				return;
			}
			try
			{
				if ((object)_deviceProp != null)
				{
					object value = _deviceProp.GetValue(__instance, BindingFlags.Default, null, null, null);
					if (value == null)
					{
						return;
					}
				}
			}
			catch
			{
				return;
			}
			string text = ExtractAndNormalizePath(__instance);
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			try
			{
				if ((object)_vector2XProp != null && (object)_vector2YProp != null)
				{
					float num = (float)_vector2XProp.GetValue(__result, BindingFlags.Default, null, null, null);
					float num2 = (float)_vector2YProp.GetValue(__result, BindingFlags.Default, null, null, null);
					_vector2Values[text] = new Vector2(num, num2);
					if (_isEnabled && FreeCamPanel.ShouldOverrideInput() && _vector2XProp.CanWrite && _vector2YProp.CanWrite)
					{
						_vector2XProp.SetValue(__result, 0f, BindingFlags.Default, null, null, null);
						_vector2YProp.SetValue(__result, 0f, BindingFlags.Default, null, null, null);
					}
				}
			}
			catch
			{
			}
		}

		private static void Postfix_AxisReadValue(object __instance, ref float __result)
		{
			if (__instance == null)
			{
				return;
			}
			try
			{
				if ((object)_deviceProp != null)
				{
					object value = _deviceProp.GetValue(__instance, BindingFlags.Default, null, null, null);
					if (value == null)
					{
						return;
					}
				}
			}
			catch
			{
				return;
			}
			string text = ExtractAndNormalizePath(__instance);
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			string text2 = text;
			try
			{
				object gamepadInstance = GetGamepadInstance(_targetGamepadIndex);
				if (gamepadInstance != null)
				{
					if ((object)_gamepadLeftStickProp != null)
					{
						object value2 = _gamepadLeftStickProp.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value2 != null)
						{
							PropertyInfo property = value2.GetType().GetProperty("x", BindingFlags.Instance | BindingFlags.Public);
							PropertyInfo property2 = value2.GetType().GetProperty("y", BindingFlags.Instance | BindingFlags.Public);
							object obj2 = property?.GetValue(value2, BindingFlags.Default, null, null, null);
							object obj3 = property2?.GetValue(value2, BindingFlags.Default, null, null, null);
							if (__instance == obj2 || __instance == obj3)
							{
								text2 = text.Replace("/gamepad/x", "/gamepad/leftstick/x").Replace("/gamepad/y", "/gamepad/leftstick/y");
							}
						}
					}
					if (text2 == text && (object)_gamepadRightStickProp != null)
					{
						object value3 = _gamepadRightStickProp.GetValue(gamepadInstance, BindingFlags.Default, null, null, null);
						if (value3 != null)
						{
							PropertyInfo property3 = value3.GetType().GetProperty("x", BindingFlags.Instance | BindingFlags.Public);
							PropertyInfo property4 = value3.GetType().GetProperty("y", BindingFlags.Instance | BindingFlags.Public);
							object obj4 = property3?.GetValue(value3, BindingFlags.Default, null, null, null);
							object obj5 = property4?.GetValue(value3, BindingFlags.Default, null, null, null);
							if (__instance == obj4 || __instance == obj5)
							{
								text2 = text.Replace("/gamepad/x", "/gamepad/rightstick/x").Replace("/gamepad/y", "/gamepad/rightstick/y");
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("[IGamepadInputInterceptor] Error identifying stick axis: " + ex.Message);
			}
			_axisValues[text2] = __result;
			if (_isEnabled && FreeCamPanel.ShouldOverrideInput())
			{
				__result = 0f;
			}
		}
	}
	public static class IInputManager
	{
		private static InputType currentInputType;

		public static Vector3 MousePosition => InputManager.MousePosition;

		public static void Setup()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected I4, but got Unknown
			currentInputType = InputManager.CurrentType;
			InputType val = currentInputType;
			InputType val2 = val;
			switch ((int)val2)
			{
			case 1:
				ILegacyInput.Init();
				break;
			case 0:
				INewInputSystem.Init();
				break;
			case 2:
				break;
			}
		}

		public static bool GetKey(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			InputType val = currentInputType;
			InputType val2 = val;
			return (int)val2 switch
			{
				1 => ILegacyInput.GetKey(key), 
				0 => INewInputSystem.GetKey(key), 
				_ => InputManager.GetKey(key), 
			};
		}

		public static bool GetKeyDown(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			InputType val = currentInputType;
			InputType val2 = val;
			switch ((int)val2)
			{
			case 1:
				return ILegacyInput.GetKeyDown(key);
			case 0:
			{
				string buttonName = ("/keyboard/" + ((object)(KeyCode)(ref key)).ToString()).ToLower();
				return INewInputSystem.GetButtonWasPressed(buttonName);
			}
			default:
				return InputManager.GetKeyDown(key);
			}
		}

		public static bool GetKeyUp(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			InputType val = currentInputType;
			InputType val2 = val;
			switch ((int)val2)
			{
			case 1:
				return ILegacyInput.GetKeyUp(key);
			case 0:
			{
				string buttonName = ("/keyboard/" + ((object)(KeyCode)(ref key)).ToString()).ToLower();
				return INewInputSystem.GetButtonWasReleased(buttonName);
			}
			default:
				return InputManager.GetKeyUp(key);
			}
		}

		public static bool GetMouseButton(int button)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			InputType val = currentInputType;
			InputType val2 = val;
			return (int)val2 switch
			{
				1 => ILegacyInput.GetMouseButton(button), 
				0 => INewInputSystem.GetMouseButton(button), 
				_ => InputManager.GetMouseButton(button), 
			};
		}

		public static bool GetMouseButtonDown(int button)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			InputType val = currentInputType;
			InputType val2 = val;
			return (int)val2 switch
			{
				1 => ILegacyInput.GetMouseButtonDown(button), 
				0 => INewInputSystem.GetMouseButtonDown(button), 
				_ => InputManager.GetMouseButtonDown(button), 
			};
		}
	}
	public static class ILegacyInput
	{
		public static Dictionary<KeyCode, bool> getKeyDict = new Dictionary<KeyCode, bool>();

		public static Dictionary<KeyCode, bool> getKeyDownDict = new Dictionary<KeyCode, bool>();

		public static Dictionary<KeyCode, bool> getKeyUpDict = new Dictionary<KeyCode, bool>();

		public static Dictionary<int, bool> getMouseButton = new Dictionary<int, bool>();

		public static Dictionary<int, bool> getMouseButtonDown = new Dictionary<int, bool>();

		public static bool GetKey(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key == 0)
			{
				return false;
			}
			InputManager.GetKey(key);
			return getKeyDict[key];
		}

		public static bool GetKeyDown(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key == 0)
			{
				return false;
			}
			InputManager.GetKeyDown(key);
			return getKeyDownDict[key];
		}

		public static bool GetKeyUp(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key == 0)
			{
				return false;
			}
			InputManager.GetKeyUp(key);
			return getKeyUpDict[key];
		}

		public static bool GetMouseButton(int button)
		{
			InputManager.GetMouseButton(button);
			return getMouseButton[button];
		}

		public static bool GetMouseButtonDown(int button)
		{
			InputManager.GetMouseButtonDown(button);
			return getMouseButtonDown[button];
		}

		public static void Init()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected O, but got Unknown
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Expected O, but got Unknown
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Expected O, but got Unknown
			Type typeByName = ReflectionUtility.GetTypeByName("UnityEngine.Input");
			try
			{
				MethodInfo method = typeByName.GetMethod("GetKey", new Type[1] { typeof(string) });
				ExplorerCore.Harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyString", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method2 = typeByName.GetMethod("GetKey", new Type[1] { typeof(KeyCode) });
				ExplorerCore.Harmony.Patch((MethodBase)method2, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyKeyCode", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method3 = typeByName.GetMethod("GetKeyDown", new Type[1] { typeof(string) });
				ExplorerCore.Harmony.Patch((MethodBase)method3, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyDownString", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method4 = typeByName.GetMethod("GetKeyDown", new Type[1] { typeof(KeyCode) });
				ExplorerCore.Harmony.Patch((MethodBase)method4, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyDownKeyCode", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method5 = typeByName.GetMethod("GetKeyUp", new Type[1] { typeof(string) });
				ExplorerCore.Harmony.Patch((MethodBase)method5, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyUpString", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method6 = typeByName.GetMethod("GetKeyUp", new Type[1] { typeof(KeyCode) });
				ExplorerCore.Harmony.Patch((MethodBase)method6, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideKeyUpKeyCode", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method7 = typeByName.GetMethod("GetMouseButton", new Type[1] { typeof(int) });
				ExplorerCore.Harmony.Patch((MethodBase)method7, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideMouseButton", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
			try
			{
				MethodInfo method8 = typeByName.GetMethod("GetMouseButtonDown", new Type[1] { typeof(int) });
				ExplorerCore.Harmony.Patch((MethodBase)method8, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(ILegacyInput), "OverrideMouseButtonDown", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
		}

		public static void OverrideKeyString(ref bool __result, ref string name)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			KeyCode key = (KeyCode)System.Enum.Parse(typeof(KeyCode), name);
			getKeyDict[key] = __result;
			if (FreeCamPanel.ShouldOverrideInput())
			{
				__result = false;
			}
		}

		public static void OverrideKeyKeyCode(ref bool __result, ref KeyCode key)
		{
			if (key)
			{
				getKeyDict[key] = __result;
				if (FreeCamPanel.ShouldOverrideInput())
				{
					__result = false;
				}
			}
		}

		public static void OverrideKeyDownString(ref bool __result, ref string name)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			KeyCode key = (KeyCode)System.Enum.Parse(typeof(KeyCode), name);
			getKeyDownDict[key] = __result;
			if (FreeCamPanel.ShouldOverrideInput())
			{
				__result = false;
			}
		}

		public static void OverrideKeyDownKeyCode(ref bool __result, ref KeyCode key)
		{
			if (key)
			{
				getKeyDownDict[key] = __result;
				if (FreeCamPanel.ShouldOverrideInput())
				{
					__result = false;
				}
			}
		}

		public static void OverrideKeyUpString(ref bool __result, ref string name)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			KeyCode key = (KeyCode)System.Enum.Parse(typeof(KeyCode), name);
			getKeyUpDict[key] = __result;
			if (FreeCamPanel.ShouldOverrideInput())
			{
				__result = false;
			}
		}

		public static void OverrideKeyUpKeyCode(ref bool __result, ref KeyCode key)
		{
			if (key)
			{
				getKeyUpDict[key] = __result;
				if (FreeCamPanel.ShouldOverrideInput())
				{
					__result = false;
				}
			}
		}

		public static void OverrideMouseButton(ref bool __result, ref int button)
		{
			getMouseButton[button] = __result;
			if (FreeCamPanel.ShouldOverrideInput() && (button != 0 || !UIManager.ShowMenu))
			{
				__result = false;
			}
		}

		public static void OverrideMouseButtonDown(ref bool __result, ref int button)
		{
			getMouseButtonDown[button] = __result;
			if (FreeCamPanel.ShouldOverrideInput() && (button != 0 || !UIManager.ShowMenu))
			{
				__result = false;
			}
		}
	}
	public static class INewInputSystem
	{
		private static PropertyInfo isPressedProp;

		private static PropertyInfo wasPressedProp;

		private static PropertyInfo wasReleasedProp;

		private static MethodInfo isValueConsideredPressed;

		private static MethodInfo isPressedMethod;

		private static MethodInfo isInProgressMethod;

		private static MethodInfo wasPressedMethod;

		private static MethodInfo wasPerformedMethod;

		internal static readonly Dictionary<string, object> buttonControls = new Dictionary<string, object>();

		internal static readonly Dictionary<string, object> gamepadButtonControls = new Dictionary<string, object>();

		internal static readonly Dictionary<string, bool> buttonPressedStates = new Dictionary<string, bool>();

		internal static readonly Dictionary<string, bool> buttonWasPressedStates = new Dictionary<string, bool>();

		internal static readonly Dictionary<string, bool> buttonWasReleasedStates = new Dictionary<string, bool>();

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

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

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

		public static void Init()
		{
			Type typeByName = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.ButtonControl, Unity.InputSystem");
			Type typeByName2 = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.InputAction, Unity.InputSystem");
			if ((object)typeByName == null || (object)typeByName2 == null)
			{
				ExplorerCore.LogWarning("Unity.InputSystem types not found; InputSystem integration disabled.");
				return;
			}
			PatchButtonControl(typeByName);
			PatchInputAction(typeByName2);
			GetButtonControls();
			IGamepadInputInterceptor.Init();
		}

		private static void PatchButtonControl(Type buttonControlType)
		{
			isPressedProp = buttonControlType.GetProperty("isPressed");
			wasPressedProp = buttonControlType.GetProperty("wasPressedThisFrame");
			wasReleasedProp = buttonControlType.GetProperty("wasReleasedThisFrame");
			isValueConsideredPressed = buttonControlType.GetMethod("IsValueConsideredPressed");
			PatchPropertyGetter(isPressedProp, "Postfix_IsPressed");
			PatchPropertyGetter(wasPressedProp, "Postfix_WasPressedThisFrame");
			PatchPropertyGetter(wasReleasedProp, "Postfix_WasReleasedThisFrame");
			PatchPropertyGetter(wasReleasedProp, "Postfix_IsValueConsideredPressed");
		}

		private static void PatchInputAction(Type inputActionType)
		{
			isPressedMethod = inputActionType.GetMethod("IsPressed");
			isInProgressMethod = inputActionType.GetMethod("IsInProgress");
			wasPressedMethod = inputActionType.GetMethod("WasPressedThisFrame");
			wasPerformedMethod = inputActionType.GetMethod("WasPerformedThisFrame");
			PatchMethod(isPressedMethod, "Postfix_IsPressed");
			PatchMethod(isInProgressMethod, "Postfix_IsInProgress");
			PatchMethod(wasPressedMethod, "Postfix_WasPressedThisFrame");
			PatchMethod(wasPerformedMethod, "Postfix_WasPerformedThisFrame");
		}

		private static void PatchPropertyGetter(PropertyInfo prop, string postfixName)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if ((object)prop?.GetGetMethod() != null)
			{
				ExplorerCore.Harmony.Patch((MethodBase)prop.GetGetMethod(), (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(INewInputSystem), postfixName, (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void PatchMethod(MethodInfo method, string postfixName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if ((object)method != null)
			{
				ExplorerCore.Harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(INewInputSystem), postfixName, (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		public static void GetButtonControls()
		{
			PropertyInfo pathProp = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.ButtonControl, Unity.InputSystem")?.GetProperty("path", BindingFlags.Instance | BindingFlags.Public);
			RegisterDeviceControls("UnityEngine.InputSystem.Keyboard", "UnityEngine.InputSystem.Controls.KeyControl", pathProp);
			RegisterDeviceControls("UnityEngine.InputSystem.Mouse", "UnityEngine.InputSystem.Controls.ButtonControl", pathProp);
		}

		internal static void RegisterDeviceControls(string deviceTypeName, string controlTypeName, PropertyInfo pathProp)
		{
			Type typeByName = ReflectionUtility.GetTypeByName(deviceTypeName + ", Unity.InputSystem");
			if ((object)typeByName == null)
			{
				return;
			}
			object obj = typeByName.GetProperty("current", BindingFlags.Static | BindingFlags.Public)?.GetValue(null, null);
			if (obj == null)
			{
				return;
			}
			PropertyInfo[] properties = typeByName.GetProperties(BindingFlags.Instance | BindingFlags.Public);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.GetIndexParameters().Length != 0 || !(propertyInfo.PropertyType.FullName == controlTypeName))
				{
					continue;
				}
				object value = propertyInfo.GetValue(obj, null);
				if (value != null)
				{
					string text = pathProp?.GetValue(value, null) as string;
					if (!string.IsNullOrEmpty(text))
					{
						buttonControls[text.ToLower()] = value;
					}
				}
			}
		}

		public static bool GetKey(KeyCode key)
		{
			string buttonName = PropToKeycode(("/keyboard/" + ((object)(KeyCode)(ref key)).ToString()).ToLower());
			return GetButtonPressed(buttonName);
		}

		public static bool GetButtonPressed(string buttonName)
		{
			string key = buttonName.ToLower();
			if (buttonControls.TryGetValue(key, out var value))
			{
				isPressedProp?.GetValue(value, null);
				bool value2;
				return buttonPressedStates.TryGetValue(key, out value2) && value2;
			}
			return false;
		}

		public static bool GetButtonWasPressed(string buttonName)
		{
			string key = buttonName.ToLower();
			if (buttonControls.TryGetValue(key, out var value))
			{
				wasPressedProp?.GetValue(value, null);
				bool value2;
				return buttonWasPressedStates.TryGetValue(key, out value2) && value2;
			}
			return false;
		}

		public static bool GetButtonWasReleased(string buttonName)
		{
			string key = buttonName.ToLower();
			if (buttonControls.TryGetValue(key, out var value))
			{
				wasReleasedProp?.GetValue(value, null);
				bool value2;
				return buttonWasReleasedStates.TryGetValue(key, out value2) && value2;
			}
			return false;
		}

		public static bool GetMouseButton(int button)
		{
			return GetButtonPressed(button switch
			{
				0 => "/mouse/leftbutton", 
				1 => "/mouse/rightbutton", 
				2 => "/mouse/middlebutton", 
				3 => "/mouse/forwardbutton", 
				4 => "/mouse/backbutton", 
				_ => $"/mouse/button{button}", 
			});
		}

		public static bool GetMouseButtonDown(int button)
		{
			return GetButtonWasPressed(button switch
			{
				0 => "/mouse/leftbutton", 
				1 => "/mouse/rightbutton", 
				2 => "/mouse/middlebutton", 
				3 => "/mouse/forwardbutton", 
				4 => "/mouse/backbutton", 
				_ => $"/mouse/button{button}", 
			});
		}

		private static void Postfix_IsPressed(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, buttonPressedStates);
		}

		private static void Postfix_WasPressedThisFrame(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, buttonWasPressedStates);
		}

		private static void Postfix_WasReleasedThisFrame(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, buttonWasReleasedStates);
		}

		private static void Postfix_IsValueConsideredPressed(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, buttonIsValueConsideredPressedStates);
		}

		private static void Postfix_IsInProgress(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, actionInProgressStates);
		}

		private static void Postfix_WasPerformedThisFrame(object __instance, ref bool __result)
		{
			StoreState(__instance, ref __result, actionWasPerformedStates);
		}

		private static void StoreState(object __instance, ref bool __result, Dictionary<string, bool> dict)
		{
			try
			{
				Type type = __instance.GetType();
				string rawPath = ((type.GetProperty("path") ?? type.GetProperty("name"))?.GetValue(__instance, null)?.ToString() ?? string.Empty).ToLower();
				rawPath = IGamepadInputInterceptor.NormalizeControlPath(rawPath);
				dict[rawPath] = __result;
				if (FreeCamPanel.ShouldOverrideInput())
				{
					__result = false;
				}
			}
			catch (Exception ex)
			{
				ExplorerCore.LogWarning("Failed to store state: " + ex.Message);
			}
		}

		public static string PropToKeycode(string propName)
		{
			return propName switch
			{
				"/keyboard/leftcontrol" => "/keyboard/leftctrl", 
				"/keyboard/rightcontrol" => "/keyboard/rightctrl", 
				"/keyboard/keypad0" => "/keyboard/numpad0", 
				"/keyboard/keypad1" => "/keyboard/numpad1", 
				"/keyboard/keypad2" => "/keyboard/numpad2", 
				"/keyboard/keypad3" => "/keyboard/numpad3", 
				"/keyboard/keypad4" => "/keyboard/numpad4", 
				"/keyboard/keypad5" => "/keyboard/numpad5", 
				"/keyboard/keypad6" => "/keyboard/numpad6", 
				"/keyboard/keypad7" => "/keyboard/numpad7", 
				"/keyboard/keypad8" => "/keyboard/numpad8", 
				"/keyboard/keypad9" => "/keyboard/numpad9", 
				"/keyboard/keypaddivide" => "/keyboard/numpaddivide", 
				"/keyboard/keypadmultiply" => "/keyboard/numpadmultiply", 
				"/keyboard/keypadminus" => "/keyboard/numpadminus", 
				"/keyboard/keypadplus" => "/keyboard/numpadplus", 
				"/keyboard/keypadperiod" => "/keyboard/numpadperiod", 
				"/keyboard/keypadequals" => "/keyboard/numpadequals", 
				"/keyboard/keypadenter" => "/keyboard/numpadenter", 
				"/keyboard/alpha0" => "/keyboard/0", 
				"/keyboard/alpha1" => "/keyboard/1", 
				"/keyboard/alpha2" => "/keyboard/2", 
				"/keyboard/alpha3" => "/keyboard/3", 
				"/keyboard/alpha4" => "/keyboard/4", 
				"/keyboard/alpha5" => "/keyboard/5", 
				"/keyboard/alpha6" => "/keyboard/6", 
				"/keyboard/alpha7" => "/keyboard/7", 
				"/keyboard/alpha8" => "/keyboard/8", 
				"/keyboard/alpha9" => "/keyboard/9", 
				"/keyboard/print" => "/keyboard/printscreen", 
				_ => propName, 
			};
		}
	}
}
namespace UnityExplorer
{
	public class ArrowGenerator
	{
		public static GameObject CreateArrow(Vector3 arrowPosition, Quaternion arrowRotation, Color color)
		{
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				float value = ConfigManager.Arrow_Size.Value;
				Vector3 localScale = default(Vector3);
				((Vector3)(ref localScale))..ctor(Math.Max(value, 0.1f), Math.Max(value, 0.1f), Math.Max(value, 0.1f));
				GameObject val = GameObject.CreatePrimitive((PrimitiveType)2);
				val.GetComponent<Collider>().enabled = false;
				val.GetComponent<MeshFilter>().mesh = CreateCylinderMesh(0.01f, 20, 2);
				val.transform.rotation = Quaternion.LookRotation(Vector3.down, Vector3.up);
				Renderer component = val.GetComponent<Renderer>();
				component.material = new Material(Shader.Find("Sprites/Default"));
				component.material.color = color;
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)0);
				val2.GetComponent<Collider>().enabled = false;
				val2.GetComponent<MeshFilter>().mesh = CreateConeMesh(10, 0.05f, 0.1f);
				val2.transform.SetParent(val.transform, true);
				Renderer component2 = val2.GetComponent<Renderer>();
				component2.material = new Material(Shader.Find("Sprites/Default"));
				component2.material.color = color;
				val.transform.rotation = Quaternion.LookRotation(Vector3.back, Vector3.up);
				GameObject val3 = new GameObject("CUE-Arrow");
				val.transform.SetParent(val3.transform, true);
				val3.transform.localScale = localScale;
				val3.transform.position = arrowPosition;
				val3.transform.rotation = arrowRotation;
				Transform transform = val3.transform;
				transform.position += 0.5f * val3.transform.forward;
				return val3;
			}
			catch
			{
				return FallbackArrow(arrowPosition, arrowRotation, color);
			}
		}

		private static GameObject FallbackArrow(Vector3 arrowPosition, Quaternion arrowRotation, Color color)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)2);
			val.GetComponent<Collider>().enabled = false;
			Renderer component = val.GetComponent<Renderer>();
			component.material = new Material(Shader.Find("Sprites/Default"));
			component.material.color = color;
			val.transform.localScale = new Vector3(0.025f, 0.15f, 0.025f);
			GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)0);
			val2.GetComponent<Collider>().enabled = false;
			val2.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
			val2.transform.position = new Vector3(0f, 0.15f, 0f);
			val2.transform.SetParent(val.transform, true);
			Renderer component2 = val2.GetComponent<Renderer>();
			component2.material = new Material(Shader.Find("Sprites/Default"));
			component2.material.color = color;
			GameObject val3 = new GameObject("CUE-Arrow");
			val.transform.SetParent(val3.transform, true);
			val3.transform.position = arrowPosition;
			Vector3 eulerAngles = ((Quaternion)(ref arrowRotation)).eulerAngles;
			eulerAngles.x += 90f;
			val3.transform.rotation = Quaternion.Euler(eulerAngles);
			Transform transform = val3.transform;
			transform.position += 0.15f * val3.transform.up;
			return val3;
		}

		public static void PatchLights()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			try
			{
				PropertyInfo property = typeof(Light).GetProperty("color");
				MethodInfo setMethod = property.GetSetMethod();
				ExplorerCore.Harmony.Patch((MethodBase)setMethod, new HarmonyMethod(AccessTools.Method(typeof(ArrowGenerator), "ChangeArrowColor", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
		}

		private static void ChangeArrowColor(Light __instance, Color __0)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)__instance).name.Contains("CUE - Light"))
			{
				Renderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Renderer>();
				Renderer[] array = componentsInChildren;
				foreach (Renderer val in array)
				{
					val.material.color = __0;
				}
			}
		}

		private static Mesh CreateConeMesh(int subdivisions, float radius, float height)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			Mesh val = new Mesh();
			Vector3[] array = (Vector3[])(object)new Vector3[subdivisions + 2];
			Vector2[] array2 = (Vector2[])(object)new Vector2[array.Length];
			int[] array3 = new int[subdivisions * 2 * 3];
			array[0] = Vector3.zero;
			array2[0] = new Vector2(0.5f, 0f);
			int i = 0;
			int num = subdivisions - 1;
			for (; i < subdivisions; i++)
			{
				float num2 = (float)i / (float)num;
				float num3 = num2 * ((float)Math.PI * 2f);
				float num4 = Mathf.Cos(num3) * radius;
				float num5 = Mathf.Sin(num3) * radius;
				array[i + 1] = new Vector3(num4, 0f, num5);
				array2[i + 1] = new Vector2(num2, 0f);
			}
			array[subdivisions + 1] = new Vector3(0f, height, 0f);
			array2[subdivisions + 1] = new Vector2(0.5f, 1f);
			int j = 0;
			for (int num6 = subdivisions - 1; j < num6; j++)
			{
				int num7 = j * 3;
				array3[num7] = 0;
				array3[num7 + 1] = j + 1;
				array3[num7 + 2] = j + 2;
			}
			int num8 = subdivisions * 3;
			int k = 0;
			for (int num9 = subdivisions - 1; k < num9; k++)
			{
				int num10 = k * 3 + num8;
				array3[num10] = k + 1;
				array3[num10 + 1] = subdivisions + 1;
				array3[num10 + 2] = k + 2;
			}
			val.vertices = array;
			val.uv = array2;
			val.triangles = array3;
			val.RecalculateBounds();
			val.RecalculateNormals();
			return val;
		}

		private static Mesh CreateCylinderMesh(float radius = 1f, int iterations = 50, int lenggth = 10, float gap = 0.5f)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			float num2 = 0f;
			int i = 0;
			Vector3[] array = (Vector3[])(object)new Vector3[iterations * lenggth + 2];
			int num3 = 0;
			array[^2] = Vector3.zero;
			for (; i < lenggth; i++)
			{
				int num4 = 0;
				while (num4 < iterations)
				{
					float num5 = (float)num4 * 1f / (float)iterations * (float)Math.PI * 2f;
					float num6 = Mathf.Sin(num5) * radius;
					float num7 = Mathf.Cos(num5) * radius;
					array[num3] = new Vector3(num6, num7, num2);
					num4++;
					num++;
					num3++;
				}
				num2 += gap;
			}
			array[^1] = new Vector3(0f, 0f, array[^3].z);
			Mesh val = new Mesh();
			val.vertices = array;
			int j = 0;
			Vector3[] array2 = (Vector3[])(object)new Vector3[num + 2];
			for (; j < num; j++)
			{
				array2[j] = Vector3.forward;
			}
			val.normals = array2;
			j = 0;
			int[] array3 = new int[3 * (lenggth - 1) * iterations * 2 + 3];
			for (; j < (lenggth - 1) * iterations; j++)
			{
				array3[j * 3] = j;
				if ((j + 1) % iterations == 0)
				{
					array3[j * 3 + 1] = 1 + j - iterations;
				}
				else
				{
					array3[j * 3 + 1] = 1 + j;
				}
				array3[j * 3 + 2] = iterations + j;
			}
			int num8 = -1;
			for (int k = (array3.Length - 3) / 2; k < array3.Length - 6; k += 3)
			{
				if ((num8 + 2) % iterations == 0)
				{
					array3[k] = num8 + iterations * 2 + 1;
				}
				else
				{
					array3[k] = num8 + iterations + 1;
				}
				array3[k + 1] = num8 + 2;
				array3[k + 2] = num8 + iterations + 2;
				num8++;
			}
			array3[^3] = 0;
			array3[^2] = iterations * 2 - 1;
			array3[^1] = iterations;
			int[] array4 = new int[iterations * 3 * 2];
			int num9 = 0;
			for (int l = 0; l < array4.Length / 2; l += 3)
			{
				array4[l] = num9;
				if (num9 + 1 != iterations)
				{
					array4[l + 1] = num9 + 1;
				}
				else
				{
					array4[l + 1] = 0;
				}
				array4[l + 2] = array.Length - 2;
				num9++;
			}
			num9 = iterations * (lenggth - 1);
			for (int m = array4.Length / 2; m < array4.Length; m += 3)
			{
				array4[m] = num9;
				if (num9 + 1 != iterations * (lenggth - 1))
				{
					array4[m + 1] = num9 + 1;
				}
				else
				{
					array4[m + 1] = iterations * (lenggth - 1);
				}
				array4[m + 2] = array.Length - 1;
				num9++;
			}
			array4[^3] = iterations * (lenggth - 1);
			array4[^2] = array.Length - 3;
			array4[^1] = array.Length - 1;
			int[] array5 = new int[array3.Length + array4.Length];
			int num10 = 0;
			int num11 = 0;
			num10 = 0;
			num11 = 0;
			for (; num10 < array3.Length; num10++)
			{
				array5[num11++] = array3[num10];
			}
			for (num10 = 0; num10 < array4.Length; num10++)
			{
				array5[num11++] = array4[num10];
			}
			val.triangles = array5;
			val.Optimize();
			val.RecalculateNormals();
			return val;
		}
	}
	public class ExplorerBehaviour : MonoBehaviour
	{
		internal bool quitting;

		internal static ExplorerBehaviour Instance { get; private set; }

		internal static void Setup()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("ExplorerBehaviour");
			Object.DontDestroyOnLoad((Object)(object)val);
			((Object)val).hideFlags = (HideFlags)61;
			Instance = val.AddComponent<ExplorerBehaviour>();
		}

		internal void Update()
		{
			ExplorerCore.Update();
		}

		internal void OnDestroy()
		{
			OnApplicationQuit();
		}

		internal void OnApplicationQuit()
		{
			if (!quitting)
			{
				quitting = true;
				if (Object.op_Implicit((Object)(object)UIManager.UIRoot))
				{
					TryDestroy(((Component)UIManager.UIRoot.transform.root).gameObject);
				}
				object? value = typeof(Universe).Assembly.GetType("UniverseLib.UniversalBehaviour").GetProperty("Instance", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null, null);
				TryDestroy(((Component)((value is Component) ? value : null)).gameObject);
				TryDestroy(((Component)this).gameObject);
			}
		}

		internal void TryDestroy(GameObject obj)
		{
			try
			{
				if (Object.op_Implicit((Object)(object)obj))
				{
					Object.Destroy((Object)(object)obj);
				}
			}
			catch
			{
			}
		}
	}
	public class KeypressListener : MonoBehaviour
	{
		private bool frameSkip;

		internal static KeypressListener Instance { get; private set; }

		internal static void Setup()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("KeypressListener");
			Object.DontDestroyOnLoad((Object)(object)val);
			((Object)val).hideFlags = (HideFlags)61;
			Instance = val.AddComponent<KeypressListener>();
		}

		public void Update()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid I