using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Loader;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading;
using GDWeave.Godot;
using GDWeave.Godot.Variants;
using GDWeave.Modding;
using Iced.Intel;
using Reloaded.Hooks;
using Reloaded.Hooks.Definitions;
using Reloaded.Memory.Sigscan;
using Reloaded.Memory.Sigscan.Definitions.Structs;
using Serilog;
using Serilog.Core;
using Serilog.Events;
using Serilog.Sinks.File;
using Serilog.Sinks.SystemConsole.Themes;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName = ".NET 8.0")]
[assembly: AssemblyCompany("GDWeave")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.0.14.0")]
[assembly: AssemblyInformationalVersion("2.0.14.0+30f7a5233b08874f5ea55a9a43486cb8678bc312")]
[assembly: AssemblyProduct("GDWeave")]
[assembly: AssemblyTitle("GDWeave")]
[assembly: SecurityPermission(8, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.14.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace GDWeave
{
	internal class ConsoleFixer
	{
		[DllImport("kernel32.dll", SetLastError = true)]
		[return: MarshalAs(2)]
		private static extern bool AllocConsole();

		[DllImport("kernel32.dll")]
		[return: MarshalAs(2)]
		private static extern bool AttachConsole(int pid);

		public static void Init()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0034: 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_0045: Expected O, but got Unknown
			if (Environment.GetEnvironmentVariable("GDWEAVE_CONSOLE") != null)
			{
				AllocConsole();
				AttachConsole(-1);
			}
			Console.SetOut((TextWriter)new StreamWriter(Console.OpenStandardOutput())
			{
				AutoFlush = true
			});
			Console.SetError((TextWriter)new StreamWriter(Console.OpenStandardError())
			{
				AutoFlush = true
			});
		}
	}
	internal class GDWeave
	{
		public delegate void MainDelegate();

		public static readonly Assembly Assembly = Assembly.GetExecutingAssembly();

		public static readonly string Version = ((object)Assembly.GetName().Version).ToString();

		public static string GameDir = null;

		public static string GDWeaveDir = null;

		public static ILogger Logger = null;

		public static ModLoader ModLoader = null;

		public static Interop Interop = null;

		public static Hooks Hooks = null;

		public static JsonSerializerOptions JsonSerializerOptions;

		public static void Main()
		{
			try
			{
				Init();
			}
			catch (global::System.Exception ex)
			{
				if (Logger != null)
				{
					Logger.Error(ex, "GDWeave failed to initialize");
				}
				else
				{
					Console.WriteLine("GDWeave failed to initialize: " + ex.Message);
				}
			}
		}

		private static void Init()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			ConsoleFixer.Init();
			GameDir = Path.GetDirectoryName(Environment.ProcessPath);
			GDWeaveDir = Environment.GetEnvironmentVariable("GDWEAVE_FOLDER_OVERRIDE") ?? Path.Combine(GameDir, "GDWeave");
			string text = Path.Combine(GDWeaveDir, "GDWeave.log");
			if (File.Exists(text))
			{
				File.Delete(text);
			}
			LoggerConfiguration val = ConsoleLoggerConfigurationExtensions.Console(FileLoggerConfigurationExtensions.File(new LoggerConfiguration().WriteTo, text, (LogEventLevel)0, "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}", (IFormatProvider)null, (long?)1073741824L, (LoggingLevelSwitch)null, false, false, (TimeSpan?)null, (RollingInterval)0, false, (int?)31, (Encoding)null, (FileLifecycleHooks)null, (TimeSpan?)null).WriteTo, (LogEventLevel)0, "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}", (IFormatProvider)null, (LoggingLevelSwitch)null, (LogEventLevel?)null, (ConsoleTheme)null, false, (object)null);
			if (Environment.GetEnvironmentVariable("GDWEAVE_DEBUG") != null)
			{
				val.MinimumLevel.Verbose();
			}
			else
			{
				val.MinimumLevel.Information();
			}
			Logger = (ILogger)(object)val.CreateLogger();
			Log.Logger = Logger;
			Logger.Information<string, string>("This is GDWeave {Version} - {GitHub}", Version, "https://github.com/NotNite/GDWeave");
			ModLoader = new ModLoader();
			Interop = new Interop();
			List<IScriptMod> scriptMods = ModLoader.ScriptMods;
			int count = scriptMods.Count;
			List<IScriptMod> val2 = new List<IScriptMod>(count);
			CollectionsMarshal.SetCount<IScriptMod>(val2, count);
			global::System.Span<IScriptMod> span = CollectionsMarshal.AsSpan<IScriptMod>(val2);
			int num = 0;
			global::System.Span<IScriptMod> span2 = CollectionsMarshal.AsSpan<IScriptMod>(scriptMods);
			span2.CopyTo(span.Slice(num, span2.Length));
			num += span2.Length;
			List<IScriptMod> val3 = val2;
			List<LoadedMod> val4 = Enumerable.ToList<LoadedMod>(Enumerable.Where<LoadedMod>((global::System.Collections.Generic.IEnumerable<LoadedMod>)ModLoader.LoadedMods, (Func<LoadedMod, bool>)((LoadedMod m) => m.PackPath != null)));
			if (val4.Count > 0)
			{
				val3.Add((IScriptMod)new PackFileLoader(val4));
			}
			Hooks = new Hooks(new ScriptModder(val3), Interop);
		}

		static GDWeave()
		{
			//IL_0047: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0068: Expected O, but got Unknown
			JsonSerializerOptions val = new JsonSerializerOptions
			{
				WriteIndented = true
			};
			((global::System.Collections.Generic.ICollection<JsonConverter>)val.Converters).Add((JsonConverter)new JsonStringEnumConverter());
			JsonSerializerOptions = val;
		}
	}
	internal class Hooks
	{
		private unsafe delegate nint LoadByteCodeDelegate(nint gdscript, GodotString* path);

		private unsafe delegate nint SetCodeBufferDelegate(nint tokenizerBuffer, GodotVector* codeBuffer);

		private delegate nint SetUnhandledExceptionFilterDelegate(nint filter);

		private unsafe delegate nint UnhandledExceptionFilterDelegate(ExceptionPointersStruct* exceptionInfo);

		private enum PatternType
		{
			LoadByteCode,
			SetCode
		}

		[StructLayout(2, Pack = 1, Size = 8)]
		public struct CowData : global::System.IDisposable
		{
			[FieldOffset(0)]
			public nint Value;

			public unsafe int RefCount => *(int*)(Value - 8);

			public unsafe int Size => *(int*)(Value - 4);

			public unsafe static CowData Ctor(global::System.ReadOnlySpan<byte> buffer)
			{
				nint num = Marshal.AllocHGlobal(8 + buffer.Length);
				*(int*)num = 1;
				*(int*)(num + 4) = buffer.Length;
				buffer.CopyTo(new global::System.Span<byte>((void*)(num + 8), buffer.Length));
				CowData result = default(CowData);
				result.Value = num + 8;
				return result;
			}

			public void Dispose()
			{
				Marshal.FreeHGlobal((global::System.IntPtr)(Value - 8));
			}
		}

		[StructLayout(2, Pack = 1)]
		public struct GodotString
		{
			[FieldOffset(0)]
			public CowData CowData;

			public string Value
			{
				get
				{
					string str = Marshal.PtrToStringUni((global::System.IntPtr)CowData.Value, CowData.Size);
					MemoryUtils.TrimNullTerminator(ref str);
					return str;
				}
			}

			public unsafe static GodotString* Ctor(string value)
			{
				GodotString* ptr = (GodotString*)Marshal.AllocHGlobal(sizeof(GodotString));
				ptr->CowData = CowData.Ctor(global::System.ReadOnlySpan<byte>.op_Implicit(Encoding.Unicode.GetBytes(value + "\0")));
				return ptr;
			}

			public unsafe static void Dtor(GodotString* str)
			{
				str->CowData.Dispose();
				Marshal.FreeHGlobal((global::System.IntPtr)(nint)str);
			}
		}

		public class GodotStringWrapper : global::System.IDisposable
		{
			public unsafe readonly GodotString* String = GodotString.Ctor(value);

			public unsafe GodotStringWrapper(string value)
			{
			}

			public unsafe void Dispose()
			{
				GodotString.Dtor(String);
			}
		}

		[StructLayout(2, Pack = 1)]
		public struct GodotVector
		{
			[FieldOffset(8)]
			public CowData CowData;

			public unsafe global::System.ReadOnlySpan<byte> Data => new global::System.ReadOnlySpan<byte>((void*)CowData.Value, CowData.Size);

			public unsafe static GodotVector* Ctor(global::System.ReadOnlySpan<byte> buffer)
			{
				GodotVector* ptr = (GodotVector*)Marshal.AllocHGlobal(sizeof(GodotVector));
				ptr->CowData = CowData.Ctor(buffer);
				return ptr;
			}

			public unsafe static void Dtor(GodotVector* vector)
			{
				vector->CowData.Dispose();
				Marshal.FreeHGlobal((global::System.IntPtr)(nint)vector);
			}
		}

		public class GodotVectorWrapper : global::System.IDisposable
		{
			public unsafe readonly GodotVector* Vector = GodotVector.Ctor(buffer);

			public unsafe GodotVectorWrapper(global::System.ReadOnlySpan<byte> buffer)
			{
			}

			public unsafe void Dispose()
			{
				GodotVector.Dtor(Vector);
			}
		}

		private struct ExceptionPointersStruct
		{
			public unsafe ExceptionRecordStruct* ExceptionRecord;
		}

		private struct ExceptionRecordStruct
		{
			public uint ExceptionCode;

			public uint ExceptionFlags;

			public nint ExceptionRecord;

			public nint ExceptionAddress;

			public uint NumberParameters;

			[FixedBuffer(typeof(uint), 15)]
			public unsafe fixed uint ExceptionInformation[15];
		}

		private ITrackedHook<SetUnhandledExceptionFilterDelegate> setUnhandledExceptionFilterHook;

		private UnhandledExceptionFilterDelegate unhandledExceptionFilter;

		private ITrackedHook<LoadByteCodeDelegate> loadByteCodeHook;

		private ITrackedHook<SetCodeBufferDelegate> setCodeBufferHook;

		private readonly ILogger logger = GDWeave.Logger.ForContext<Hooks>();

		private readonly ThreadLocal<string> currentPath = new ThreadLocal<string>((Func<string>)(() => string.Empty));

		private readonly ScriptModder modder;

		private bool dumpGdsc = Environment.GetEnvironmentVariable("GDWEAVE_DUMP_GDSC") != null;

		public unsafe Hooks(ScriptModder modder, Interop interop)
		{
			this.modder = modder;
			nint procAddress = GetProcAddress(LoadLibrary("kernel32.dll"), "SetUnhandledExceptionFilter");
			unhandledExceptionFilter = UnhandledExceptionFilter;
			setUnhandledExceptionFilterHook = interop.CreateHook<SetUnhandledExceptionFilterDelegate>(procAddress, SetUnhandledExceptionFilterDetour);
			setUnhandledExceptionFilterHook.Enable();
			Dictionary<PatternType, string[]> val = new Dictionary<PatternType, string[]>
			{
				[PatternType.LoadByteCode] = new string[2] { "E8 ?? ?? ?? ?? 85 C0 0F 84 ?? ?? ?? ?? 48 89 7D ?? 48 8D 35", "48 89 54 24 ?? 48 89 4C 24 ?? 55 53 56 57 41 54 41 55 41 56 41 57 48 8D AC 24 ?? ?? ?? ?? 48 81 EC 78 02 00 00" },
				[PatternType.SetCode] = new string[2] { "E8 ?? ?? ?? ?? 48 89 5D ?? 48 8D 54 24 ?? 48 8D 4D ?? E8 ?? ?? ?? ?? 44 8B E0", "48 89 5C 24 ?? 55 56 57 41 54 41 55 41 56 41 57 48 8D 6C 24 ?? 48 81 EC D0 00 00 00 48 8B 05 ?? ?? ?? ?? 48 33 C4 48 89 45 ?? 4C 8B F9" }
			};
			if (File.Exists("patterns.json"))
			{
				val = JsonSerializer.Deserialize<Dictionary<PatternType, string[]>>(File.ReadAllText("patterns.json"), GDWeave.JsonSerializerOptions);
			}
			nint addr = interop.ScanText(val[PatternType.LoadByteCode]);
			loadByteCodeHook = interop.CreateHook<LoadByteCodeDelegate>(addr, LoadByteCodeDetour);
			loadByteCodeHook.Enable();
			nint addr2 = interop.ScanText(val[PatternType.SetCode]);
			setCodeBufferHook = interop.CreateHook<SetCodeBufferDelegate>(addr2, SetCodeBufferDetour);
			setCodeBufferHook.Enable();
		}

		private nint SetUnhandledExceptionFilterDetour(nint filter)
		{
			return setUnhandledExceptionFilterHook.Original(Marshal.GetFunctionPointerForDelegate<UnhandledExceptionFilterDelegate>(unhandledExceptionFilter));
		}

		private unsafe nint UnhandledExceptionFilter(ExceptionPointersStruct* exceptionInfo)
		{
			logger.Error("========== UNHANDLED EXCEPTION!!!");
			logger.Error<uint>("Exception code: {Code:X8}", exceptionInfo->ExceptionRecord->ExceptionCode);
			logger.Error<nint>("Exception address: {Address:X8}", exceptionInfo->ExceptionRecord->ExceptionAddress);
			MessageBox(global::System.IntPtr.Zero, "The game has crashed. Sorry! :(\r\n\r\nTry disabling some mods and see if the problem persists. It is very likely this issue was not caused by GDWeave itself but rather a mod.\r\n\r\nWhen asking for support, provide the log file in the GDWeave folder in your game install.", "GDWeave", 48u);
			return 0;
		}

		private unsafe nint LoadByteCodeDetour(nint gdscript, GodotString* path)
		{
			currentPath.Value = path->Value;
			return loadByteCodeHook.Original(gdscript, path);
		}

		private unsafe nint SetCodeBufferDetour(nint tokenizerBuffer, GodotVector* codeBuffer)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			global::System.ReadOnlySpan<byte> buffer = codeBuffer->Data;
			string text = currentPath.Value ?? string.Empty;
			bool flag = false;
			try
			{
				MemoryStream val = new MemoryStream(buffer.ToArray());
				try
				{
					BinaryReader val2 = new BinaryReader((Stream)(object)val);
					try
					{
						GodotScriptFile godotScriptFile = new GodotScriptFile(val2);
						if (dumpGdsc)
						{
							DumpGdsc(godotScriptFile, text, "gdc");
						}
						try
						{
							flag = modder.Run(godotScriptFile, text);
						}
						catch (global::System.Exception ex)
						{
							logger.Error<string>(ex, "Failed to run mod on {Path}", text);
						}
						if (dumpGdsc && flag)
						{
							DumpGdsc(godotScriptFile, text, "gdc_modded");
						}
						MemoryStream val3 = new MemoryStream();
						try
						{
							BinaryWriter val4 = new BinaryWriter((Stream)(object)val3);
							try
							{
								godotScriptFile.Write(val4);
								buffer = global::System.ReadOnlySpan<byte>.op_Implicit(val3.ToArray());
							}
							finally
							{
								((global::System.IDisposable)val4)?.Dispose();
							}
						}
						finally
						{
							((global::System.IDisposable)val3)?.Dispose();
						}
					}
					finally
					{
						((global::System.IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((global::System.IDisposable)val)?.Dispose();
				}
			}
			catch (global::System.Exception ex2)
			{
				if (!(ex2 is InvalidDataException))
				{
					logger.Error<string>(ex2, "Failed to parse GDSC file {Path}", text);
				}
			}
			if (!flag)
			{
				return setCodeBufferHook.Original(tokenizerBuffer, codeBuffer);
			}
			using GodotVectorWrapper godotVectorWrapper = new GodotVectorWrapper(buffer);
			return setCodeBufferHook.Original(tokenizerBuffer, godotVectorWrapper.Vector);
		}

		private void DumpGdsc(GodotScriptFile script, string path, string dir)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			try
			{
				string text = Path.Combine(Path.GetDirectoryName(Environment.ProcessPath), dir, path.Replace("res://", ""));
				string directoryName = Path.GetDirectoryName(text);
				if (!Directory.Exists(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				if (File.Exists(text))
				{
					File.Delete(text);
				}
				FileStream val = File.OpenWrite(text);
				try
				{
					BinaryWriter val2 = new BinaryWriter((Stream)(object)val);
					try
					{
						script.Write(val2);
					}
					finally
					{
						((global::System.IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((global::System.IDisposable)val)?.Dispose();
				}
			}
			catch (global::System.Exception ex)
			{
				logger.Warning(ex, "Failed to write GDSC file");
			}
		}

		public unsafe static nint CowDataCtor(global::System.ReadOnlySpan<byte> buffer)
		{
			nint num = Marshal.AllocHGlobal(8 + buffer.Length);
			*(int*)num = 1;
			*(int*)(num + 4) = buffer.Length;
			buffer.CopyTo(new global::System.Span<byte>((void*)(num + 8), buffer.Length));
			return num + 8;
		}

		public static void CowDataDtor(nint cowData)
		{
			Marshal.FreeHGlobal((global::System.IntPtr)(cowData - 8));
		}

		[DllImport("kernel32.dll", CharSet = 3, SetLastError = true)]
		private static extern nint LoadLibrary(string lpFileName);

		[DllImport("kernel32.dll", CharSet = 2, SetLastError = true)]
		private static extern nint GetProcAddress(nint hModule, string lpProcName);

		[DllImport("user32.dll", CharSet = 3, SetLastError = true)]
		private static extern int MessageBox(nint hwnd, string text, string caption, uint type);
	}
	public interface IMod : global::System.IDisposable
	{
	}
	public interface IModInterface
	{
		ILogger Logger { get; }

		string[] LoadedMods { get; }

		T ReadConfig<T>() where T : class, new();

		void WriteConfig<T>(T config) where T : class;

		void RegisterScriptMod(IScriptMod mod);
	}
	public class Interop : global::System.IDisposable
	{
		private class UnsafeCodeReader : CodeReader
		{
			private readonly int length;

			private unsafe readonly byte* address;

			private int pos;

			public bool CanReadByte => pos < length;

			public unsafe UnsafeCodeReader(byte* address, int length)
			{
				this.length = length;
				this.address = address;
			}

			public unsafe override int ReadByte()
			{
				if (pos < length)
				{
					return address[pos++];
				}
				return -1;
			}
		}

		private readonly Process process;

		private readonly Scanner scanner;

		private List<TrackedHook> tracked = new List<TrackedHook>();

		[field: CompilerGenerated]
		public nint BaseAddress
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private init;
		}

		public Interop()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			process = Process.GetCurrentProcess();
			scanner = new Scanner(process, process.MainModule);
			BaseAddress = process.MainModule.BaseAddress;
		}

		public void Dispose()
		{
			tracked.ForEach((Action<TrackedHook>)delegate(TrackedHook x)
			{
				x.Dispose();
			});
			tracked.Clear();
		}

		public nint ScanText(string[] text)
		{
			//IL_0011: 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)
			foreach (string text2 in text)
			{
				PatternScanResult val = scanner.FindPattern(text2);
				if (!((PatternScanResult)(ref val)).Found)
				{
					Console.WriteLine("Failed to match signature {0}", (object)text2);
					continue;
				}
				nint num = (nint)process.MainModule.BaseAddress + ((PatternScanResult)(ref val)).Offset;
				byte b = Marshal.ReadByte((global::System.IntPtr)num);
				if ((uint)(b - 232) > 1u)
				{
					return num;
				}
				return ResolveJmpCall(num);
			}
			throw new global::System.Exception("Failed to match any signatures");
		}

		public unsafe nint GetStaticAddress(string[] sigs, int offset = 0)
		{
			//IL_0023: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			nint num = ScanText(sigs) + offset;
			UnsafeCodeReader unsafeCodeReader = new UnsafeCodeReader((byte*)num, 64);
			Decoder val = Decoder.Create(64, (CodeReader)(object)unsafeCodeReader, (ulong)num, (DecoderOptions)2);
			while (unsafeCodeReader.CanReadByte)
			{
				Instruction val2 = val.Decode();
				if (!((Instruction)(ref val2)).IsInvalid && ((int)((Instruction)(ref val2)).Op0Kind == 24 || (int)((Instruction)(ref val2)).Op1Kind == 24))
				{
					return (nint)((Instruction)(ref val2)).MemoryDisplacement64;
				}
			}
			throw new global::System.Exception("Failed to resolve static address from signature");
		}

		private nint ResolveJmpCall(nint address)
		{
			int num = Marshal.ReadInt32((global::System.IntPtr)(address + 1));
			return address + 5 + num;
		}

		public ITrackedHook<T> CreateHook<T>(nint addr, T detour) where T : global::System.Delegate
		{
			byte[] originalBytes = MemoryUtils.ReadRaw(addr, 50);
			IHook<T> val = ReloadedHooks.Instance.CreateHook<T>(detour, (long)addr);
			val.Activate();
			val.Disable();
			TrackedHook<T> trackedHook = new TrackedHook<T>(addr, originalBytes, val);
			tracked.Add((TrackedHook)trackedHook);
			return trackedHook;
		}
	}
	public interface ITrackedHook : global::System.IDisposable
	{
		nint Address { get; }

		bool Enabled { get; }

		void Enable();

		void Disable();

		bool Toggle();
	}
	public interface ITrackedHook<out T> : ITrackedHook, global::System.IDisposable where T : global::System.Delegate
	{
		T Original { get; }
	}
	public abstract class TrackedHook : ITrackedHook, global::System.IDisposable
	{
		[CompilerGenerated]
		private nint <addr>P;

		[CompilerGenerated]
		private byte[] <originalBytes>P;

		public byte[] OriginalBytes => <originalBytes>P;

		public nint Address => <addr>P;

		public abstract bool Enabled { get; }

		protected TrackedHook(nint addr, byte[] originalBytes)
		{
			<addr>P = addr;
			<originalBytes>P = originalBytes;
			base..ctor();
		}

		public virtual void Dispose()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			MemoryUtils.Unprotect(Address, OriginalBytes.Length, (Action)([CompilerGenerated] () =>
			{
				MemoryUtils.WriteRaw(Address, OriginalBytes);
			}));
		}

		public abstract void Enable();

		public abstract void Disable();

		public abstract bool Toggle();
	}
	public class TrackedHook<T> : TrackedHook, ITrackedHook<T>, ITrackedHook, global::System.IDisposable where T : global::System.Delegate
	{
		[CompilerGenerated]
		private IHook<T> <hook>P;

		public T Original => <hook>P.OriginalFunction;

		public override bool Enabled => <hook>P.IsHookEnabled;

		public TrackedHook(nint addr, byte[] originalBytes, IHook<T> hook)
		{
			<hook>P = hook;
			base..ctor(addr, originalBytes);
		}

		public override void Enable()
		{
			if (!<hook>P.IsHookEnabled)
			{
				<hook>P.Enable();
			}
		}

		public override void Disable()
		{
			if (<hook>P.IsHookEnabled)
			{
				<hook>P.Disable();
			}
		}

		public override bool Toggle()
		{
			if (<hook>P.IsHookEnabled)
			{
				<hook>P.Disable();
				return false;
			}
			<hook>P.Enable();
			return true;
		}

		public override void Dispose()
		{
			Disable();
			base.Dispose();
		}
	}
	[RequiredMember]
	internal class LoadedMod
	{
		[RequiredMember]
		public ModManifest Manifest;

		[RequiredMember]
		public string Directory;

		public IMod? AssemblyMod;

		public string? AssemblyPath;

		public string? PackPath;

		[Obsolete("Constructors of types with required members are not supported in this version of your compiler.", true)]
		[CompilerFeatureRequired("RequiredMembers")]
		public LoadedMod()
		{
		}
	}
	internal class ModInterface : IModInterface
	{
		[CompilerGenerated]
		private string <modId>P;

		[CompilerGenerated]
		private ModLoader <modLoader>P;

		[field: CompilerGenerated]
		public ILogger Logger
		{
			[CompilerGenerated]
			get;
		}

		public string[] LoadedMods => Enumerable.ToArray<string>(Enumerable.Select<LoadedMod, string>((global::System.Collections.Generic.IEnumerable<LoadedMod>)<modLoader>P.LoadedMods, (Func<LoadedMod, string>)((LoadedMod x) => x.Manifest.Id)));

		public ModInterface(string modId, ModLoader modLoader)
		{
			<modId>P = modId;
			<modLoader>P = modLoader;
			Logger = GDWeave.Logger.ForContext("SourceContext", (object)<modId>P, false);
			base..ctor();
		}

		private string GetConfigPath()
		{
			return Path.Combine(GDWeave.GDWeaveDir, "configs", <modId>P + ".json");
		}

		public T ReadConfig<T>() where T : class, new()
		{
			string configPath = GetConfigPath();
			if (!File.Exists(configPath))
			{
				T val = new T();
				WriteConfig(val);
				return val;
			}
			T val2 = JsonSerializer.Deserialize<T>(File.ReadAllText(configPath), GDWeave.JsonSerializerOptions);
			WriteConfig(val2);
			return val2;
		}

		public void WriteConfig<T>(T config) where T : class
		{
			string configPath = GetConfigPath();
			string directoryName = Path.GetDirectoryName(configPath);
			if (!Directory.Exists(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			string text = JsonSerializer.Serialize<T>(config, GDWeave.JsonSerializerOptions);
			File.WriteAllText(configPath, text);
		}

		public void RegisterScriptMod(IScriptMod mod)
		{
			<modLoader>P.RegisterScriptMod(<modId>P, mod);
		}
	}
	public class ModLoadContext : AssemblyLoadContext
	{
		private AssemblyDependencyResolver resolver = new AssemblyDependencyResolver(path);

		public ModLoadContext(string path)
			: base(true)
		{
		}//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown


		protected override Assembly Load(AssemblyName assemblyName)
		{
			AssemblyName assemblyName2 = assemblyName;
			if (assemblyName2.Name == "GDWeave")
			{
				return GDWeave.Assembly;
			}
			AssemblyName val = Enumerable.FirstOrDefault<AssemblyName>((global::System.Collections.Generic.IEnumerable<AssemblyName>)GDWeave.Assembly.GetReferencedAssemblies(), (Func<AssemblyName, bool>)((AssemblyName a) => a.Name == assemblyName2.Name));
			if (val != null)
			{
				return Assembly.Load(val);
			}
			string text = resolver.ResolveAssemblyToPath(assemblyName2);
			if (text == null)
			{
				return null;
			}
			return ((AssemblyLoadContext)this).LoadFromAssemblyPath(text);
		}

		protected override nint LoadUnmanagedDll(string unmanagedDllName)
		{
			string text = resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
			if (text == null)
			{
				return global::System.IntPtr.Zero;
			}
			return ((AssemblyLoadContext)this).LoadUnmanagedDllFromPath(text);
		}
	}
	internal class ModLoader
	{
		public List<LoadedMod> LoadedMods = new List<LoadedMod>();

		private readonly ILogger logger = GDWeave.Logger.ForContext<ModLoader>();

		private readonly Dictionary<string, List<IScriptMod>> scriptMods = new Dictionary<string, List<IScriptMod>>();

		public List<IScriptMod> ScriptMods => Enumerable.ToList<IScriptMod>(Enumerable.SelectMany<List<IScriptMod>, IScriptMod>((global::System.Collections.Generic.IEnumerable<List<IScriptMod>>)scriptMods.Values, (Func<List<IScriptMod>, global::System.Collections.Generic.IEnumerable<IScriptMod>>)((List<IScriptMod> x) => (global::System.Collections.Generic.IEnumerable<IScriptMod>)x)));

		public ModLoader()
		{
			Register();
			Sort();
			LoadAssemblies();
			logger.Information<int, global::System.Collections.Generic.IEnumerable<string>>("Loaded {Count} mods: {ModIds}", LoadedMods.Count, Enumerable.Select<LoadedMod, string>((global::System.Collections.Generic.IEnumerable<LoadedMod>)LoadedMods, (Func<LoadedMod, string>)((LoadedMod x) => x.Manifest.Id)));
		}

		private void Register()
		{
			string text = Path.Combine(GDWeave.GDWeaveDir, "mods");
			if (!Directory.Exists(text))
			{
				return;
			}
			string[] directories = Directory.GetDirectories(text);
			foreach (string text2 in directories)
			{
				try
				{
					string text3 = Path.Combine(text2, "manifest.json");
					if (!File.Exists(text3))
					{
						logger.Warning<string>("Mod at {ModDir} does not have a manifest.json", text2);
						continue;
					}
					ModManifest manifest = JsonSerializer.Deserialize<ModManifest>(File.ReadAllText(text3), (JsonSerializerOptions)null);
					if (Enumerable.Any<LoadedMod>((global::System.Collections.Generic.IEnumerable<LoadedMod>)LoadedMods, (Func<LoadedMod, bool>)((LoadedMod x) => x.Manifest.Id == manifest.Id)))
					{
						logger.Warning<string>("Duplicate mod ID: {ModId}", manifest.Id);
						continue;
					}
					logger.Debug<string, string>("Loading mod {ModId} from {ModDir}", manifest.Id, text2);
					LoadedMod obj = new LoadedMod
					{
						Manifest = manifest,
						Directory = text2,
						AssemblyMod = null
					};
					string assemblyPath = manifest.AssemblyPath;
					obj.AssemblyPath = ((assemblyPath != null) ? Path.Combine(text2, assemblyPath) : null);
					string packPath = manifest.PackPath;
					obj.PackPath = ((packPath != null) ? Path.Combine(text2, packPath) : null);
					LoadedMod loadedMod = obj;
					if (loadedMod.AssemblyPath != null && !File.Exists(loadedMod.AssemblyPath))
					{
						logger.Warning<string>("Assembly at {AssemblyPath} does not exist", loadedMod.AssemblyPath);
					}
					else if (loadedMod.PackPath != null && !File.Exists(loadedMod.PackPath))
					{
						logger.Warning<string>("Pack file at {PackPath} does not exist", loadedMod.PackPath);
					}
					else
					{
						LoadedMods.Add(loadedMod);
					}
				}
				catch (global::System.Exception ex)
				{
					logger.Warning<string>(ex, "Failed to load mod at {ModDir}", text2);
				}
			}
		}

		private void Sort()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: 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_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			while (true)
			{
				List<LoadedMod> val = Enumerable.ToList<LoadedMod>(Enumerable.Where<LoadedMod>((global::System.Collections.Generic.IEnumerable<LoadedMod>)LoadedMods, (Func<LoadedMod, bool>)((LoadedMod x) => Enumerable.Any<string>((global::System.Collections.Generic.IEnumerable<string>)x.Manifest.Dependencies, (Func<string, bool>)((string d) => !Enumerable.Any<LoadedMod>((global::System.Collections.Generic.IEnumerable<LoadedMod>)LoadedMods, (Func<LoadedMod, bool>)((LoadedMod m) => m.Manifest.Id == d)))))));
				if (val.Count == 0)
				{
					break;
				}
				Enumerator<LoadedMod> enumerator = val.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						LoadedMod current = enumerator.Current;
						logger.Warning<string, List<string>>("Mod {ModId} has missing/invalid dependencies: {InvalidDependencies}", current.Manifest.Id, current.Manifest.Dependencies);
						LoadedMods.Remove(current);
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator).Dispose();
				}
			}
			Dictionary<string, List<string>> val2 = Enumerable.ToDictionary<LoadedMod, string, List<string>>((global::System.Collections.Generic.IEnumerable<LoadedMod>)LoadedMods, (Func<LoadedMod, string>)((LoadedMod x) => x.Manifest.Id), (Func<LoadedMod, List<string>>)((LoadedMod x) => x.Manifest.Dependencies));
			List<string> resolvedOrder = new List<string>();
			string text = default(string);
			List<string> val4 = default(List<string>);
			while (val2.Count > 0)
			{
				List<KeyValuePair<string, List<string>>> val3 = Enumerable.ToList<KeyValuePair<string, List<string>>>(Enumerable.Where<KeyValuePair<string, List<string>>>((global::System.Collections.Generic.IEnumerable<KeyValuePair<string, List<string>>>)val2, (Func<KeyValuePair<string, List<string>>, bool>)((KeyValuePair<string, List<string>> x) => x.Value.Count == 0)));
				Enumerator<KeyValuePair<string, List<string>>> enumerator2 = val3.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						enumerator2.Current.Deconstruct(ref text, ref val4);
						string text2 = text;
						resolvedOrder.Add(text2);
						val2.Remove(text2);
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator2).Dispose();
				}
				Enumerator<string, List<string>> enumerator3 = val2.GetEnumerator();
				try
				{
					while (enumerator3.MoveNext())
					{
						enumerator3.Current.Deconstruct(ref text, ref val4);
						List<string> val5 = val4;
						enumerator2 = val3.GetEnumerator();
						try
						{
							while (enumerator2.MoveNext())
							{
								val5.Remove(enumerator2.Current.Key);
							}
						}
						finally
						{
							((global::System.IDisposable)enumerator2).Dispose();
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator3).Dispose();
				}
				if (val3.Count == 0)
				{
					logger.Warning<KeyCollection<string, List<string>>>("Circular dependency detected: {CircularDependency}", val2.Keys);
					break;
				}
			}
			logger.Debug<List<string>>("Resolved mod load order: {ResolvedOrder}", resolvedOrder);
			LoadedMods = Enumerable.ToList<LoadedMod>((global::System.Collections.Generic.IEnumerable<LoadedMod>)Enumerable.OrderBy<LoadedMod, int>((global::System.Collections.Generic.IEnumerable<LoadedMod>)LoadedMods, (Func<LoadedMod, int>)((LoadedMod x) => resolvedOrder.IndexOf(x.Manifest.Id))));
		}

		private void LoadAssemblies()
		{
			//IL_000c: 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_00a3: 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)
			List<LoadedMod> val = new List<LoadedMod>();
			Enumerator<LoadedMod> enumerator = LoadedMods.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					LoadedMod current = enumerator.Current;
					string assemblyPath = current.AssemblyPath;
					if (assemblyPath != null)
					{
						try
						{
							logger.Debug<string, string>("Loading assembly for mod {ModId} from {AssemblyPath}", current.Manifest.Id, assemblyPath);
							IMod assemblyMod = LoadAssembly(current.Manifest.Id, assemblyPath);
							current.AssemblyMod = assemblyMod;
						}
						catch (global::System.Exception ex)
						{
							logger.Warning<string>(ex, "Failed to load assembly for mod {ModId}", current.Manifest.Id);
							val.Add(current);
						}
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator).Dispose();
			}
			enumerator = val.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					LoadedMod current2 = enumerator.Current;
					LoadedMods.Remove(current2);
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator).Dispose();
			}
		}

		private IMod? LoadAssembly(string id, string assemblyPath)
		{
			string fullPath = Path.GetFullPath(assemblyPath);
			global::System.Type type = Enumerable.FirstOrDefault<global::System.Type>((global::System.Collections.Generic.IEnumerable<global::System.Type>)((AssemblyLoadContext)new ModLoadContext(fullPath)).LoadFromAssemblyPath(fullPath).GetTypes(), (Func<global::System.Type, bool>)((global::System.Type t) => Enumerable.FirstOrDefault<global::System.Type>((global::System.Collections.Generic.IEnumerable<global::System.Type>)t.GetInterfaces(), (Func<global::System.Type, bool>)((global::System.Type t) => t.FullName == typeof(IMod).FullName)) != (global::System.Type)null));
			if (type == (global::System.Type)null)
			{
				logger.Warning<string>("Assembly at {AssemblyPath} does not contain a mod", assemblyPath);
				return null;
			}
			ConstructorInfo constructor = type.GetConstructor(new global::System.Type[1] { typeof(IModInterface) });
			if (constructor == null)
			{
				return Activator.CreateInstance(type) as IMod;
			}
			return constructor.Invoke(new object[1]
			{
				new ModInterface(id, this)
			}) as IMod;
		}

		public void RegisterScriptMod(string modId, IScriptMod mod)
		{
			if (!scriptMods.ContainsKey(modId))
			{
				scriptMods[modId] = new List<IScriptMod>();
			}
			scriptMods[modId].Add(mod);
		}
	}
	[RequiredMember]
	internal class ModManifest
	{
		internal class ModMetadata
		{
			[field: CompilerGenerated]
			public string? Name
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				set;
			}

			[field: CompilerGenerated]
			public string? Author
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				set;
			}

			[field: CompilerGenerated]
			public string? Version
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				set;
			}

			[field: CompilerGenerated]
			public string? Description
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				set;
			}

			[field: CompilerGenerated]
			public string? Homepage
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				set;
			}
		}

		[RequiredMember]
		[field: CompilerGenerated]
		public string Id
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}

		[field: CompilerGenerated]
		public string? AssemblyPath
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}

		[field: CompilerGenerated]
		public string? PackPath
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}

		[field: CompilerGenerated]
		public List<string> Dependencies
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		} = new List<string>();


		[field: CompilerGenerated]
		public ModMetadata? Metadata
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}

		[Obsolete("Constructors of types with required members are not supported in this version of your compiler.", true)]
		[CompilerFeatureRequired("RequiredMembers")]
		public ModManifest()
		{
		}
	}
	internal class PackFileLoader : IScriptMod
	{
		[CompilerGenerated]
		private sealed class <Modify>d__4 : global::System.Collections.Generic.IEnumerable<Token>, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerator<Token>, global::System.Collections.IEnumerator, global::System.IDisposable
		{
			private int <>1__state;

			private Token <>2__current;

			private int <>l__initialThreadId;

			private global::System.Collections.Generic.IEnumerable<Token> tokens;

			public global::System.Collections.Generic.IEnumerable<Token> <>3__tokens;

			public PackFileLoader <>4__this;

			private MultiTokenWaiter <readyWaiter>5__2;

			private global::System.Collections.Generic.IEnumerator<Token> <>7__wrap2;

			private Token <token>5__4;

			private Enumerator<LoadedMod> <>7__wrap4;

			private LoadedMod <mod>5__6;

			Token global::System.Collections.Generic.IEnumerator<Token>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			public <Modify>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void global::System.IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) > 1u && (uint)(num - 1) > 49u)
				{
					return;
				}
				try
				{
					if (num != -4 && (uint)(num - 2) > 47u)
					{
						return;
					}
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
				}
				finally
				{
					<>m__Finally1();
				}
			}

			private bool MoveNext()
			{
				//IL_023b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b01: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					int num = <>1__state;
					PackFileLoader packFileLoader = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<readyWaiter>5__2 = new MultiTokenWaiter(new Func<Token, bool>[6]
						{
							(Token t) => t.Type == TokenType.PrFunction,
							(Token t) => t is IdentifierToken identifierToken && identifierToken.Name == "_ready",
							(Token t) => t.Type == TokenType.ParenthesisOpen,
							(Token t) => t.Type == TokenType.ParenthesisClose,
							(Token t) => t.Type == TokenType.Colon,
							(Token t) => t.Type == TokenType.Newline
						});
						<>7__wrap2 = tokens.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<>7__wrap4 = packFileLoader.<mods>P.GetEnumerator();
						<>1__state = -4;
						goto IL_0ae5;
					case 2:
						<>1__state = -4;
						<>2__current = new Token(TokenType.Period);
						<>1__state = 3;
						return true;
					case 3:
						<>1__state = -4;
						<>2__current = new IdentifierToken("load_resource_pack");
						<>1__state = 4;
						return true;
					case 4:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisOpen);
						<>1__state = 5;
						return true;
					case 5:
						<>1__state = -4;
						<>2__current = new ConstantToken(new StringVariant(<mod>5__6.PackPath));
						<>1__state = 6;
						return true;
					case 6:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisClose);
						<>1__state = 7;
						return true;
					case 7:
						<>1__state = -4;
						<>2__current = <token>5__4;
						<>1__state = 8;
						return true;
					case 8:
						<>1__state = -4;
						<>2__current = new Token(TokenType.PrVar);
						<>1__state = 9;
						return true;
					case 9:
						<>1__state = -4;
						<>2__current = new IdentifierToken(<mod>5__6.Manifest.Id ?? "");
						<>1__state = 10;
						return true;
					case 10:
						<>1__state = -4;
						<>2__current = new Token(TokenType.OpAssign);
						<>1__state = 11;
						return true;
					case 11:
						<>1__state = -4;
						<>2__current = new Token(TokenType.BuiltInFunc, 76u);
						<>1__state = 12;
						return true;
					case 12:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisOpen);
						<>1__state = 13;
						return true;
					case 13:
						<>1__state = -4;
						<>2__current = new ConstantToken(new StringVariant("res://mods/" + <mod>5__6.Manifest.Id + "/main.gd"));
						<>1__state = 14;
						return true;
					case 14:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisClose);
						<>1__state = 15;
						return true;
					case 15:
						<>1__state = -4;
						<>2__current = new Token(TokenType.Period);
						<>1__state = 16;
						return true;
					case 16:
						<>1__state = -4;
						<>2__current = new IdentifierToken("new");
						<>1__state = 17;
						return true;
					case 17:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisOpen);
						<>1__state = 18;
						return true;
					case 18:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisClose);
						<>1__state = 19;
						return true;
					case 19:
						<>1__state = -4;
						<>2__current = <token>5__4;
						<>1__state = 20;
						return true;
					case 20:
						<>1__state = -4;
						<>2__current = new IdentifierToken(<mod>5__6.Manifest.Id ?? "");
						<>1__state = 21;
						return true;
					case 21:
						<>1__state = -4;
						<>2__current = new Token(TokenType.Period);
						<>1__state = 22;
						return true;
					case 22:
						<>1__state = -4;
						<>2__current = new IdentifierToken("add_to_group");
						<>1__state = 23;
						return true;
					case 23:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisOpen);
						<>1__state = 24;
						return true;
					case 24:
						<>1__state = -4;
						<>2__current = new ConstantToken(new StringVariant("gdweave_mod"));
						<>1__state = 25;
						return true;
					case 25:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisClose);
						<>1__state = 26;
						return true;
					case 26:
						<>1__state = -4;
						<>2__current = <token>5__4;
						<>1__state = 27;
						return true;
					case 27:
						<>1__state = -4;
						<>2__current = new IdentifierToken(<mod>5__6.Manifest.Id ?? "");
						<>1__state = 28;
						return true;
					case 28:
						<>1__state = -4;
						<>2__current = new Token(TokenType.Period);
						<>1__state = 29;
						return true;
					case 29:
						<>1__state = -4;
						<>2__current = new IdentifierToken("set_name");
						<>1__state = 30;
						return true;
					case 30:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisOpen);
						<>1__state = 31;
						return true;
					case 31:
						<>1__state = -4;
						<>2__current = new ConstantToken(new StringVariant(<mod>5__6.Manifest.Id ?? ""));
						<>1__state = 32;
						return true;
					case 32:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisClose);
						<>1__state = 33;
						return true;
					case 33:
						<>1__state = -4;
						<>2__current = <token>5__4;
						<>1__state = 34;
						return true;
					case 34:
						<>1__state = -4;
						<>2__current = new IdentifierToken("get_tree");
						<>1__state = 35;
						return true;
					case 35:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisOpen);
						<>1__state = 36;
						return true;
					case 36:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisClose);
						<>1__state = 37;
						return true;
					case 37:
						<>1__state = -4;
						<>2__current = new Token(TokenType.Period);
						<>1__state = 38;
						return true;
					case 38:
						<>1__state = -4;
						<>2__current = new IdentifierToken("get_root");
						<>1__state = 39;
						return true;
					case 39:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisOpen);
						<>1__state = 40;
						return true;
					case 40:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisClose);
						<>1__state = 41;
						return true;
					case 41:
						<>1__state = -4;
						<>2__current = new Token(TokenType.Period);
						<>1__state = 42;
						return true;
					case 42:
						<>1__state = -4;
						<>2__current = new IdentifierToken("call_deferred");
						<>1__state = 43;
						return true;
					case 43:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisOpen);
						<>1__state = 44;
						return true;
					case 44:
						<>1__state = -4;
						<>2__current = new ConstantToken(new StringVariant("add_child"));
						<>1__state = 45;
						return true;
					case 45:
						<>1__state = -4;
						<>2__current = new Token(TokenType.Comma);
						<>1__state = 46;
						return true;
					case 46:
						<>1__state = -4;
						<>2__current = new IdentifierToken(<mod>5__6.Manifest.Id ?? "");
						<>1__state = 47;
						return true;
					case 47:
						<>1__state = -4;
						<>2__current = new Token(TokenType.ParenthesisClose);
						<>1__state = 48;
						return true;
					case 48:
						<>1__state = -4;
						<>2__current = <token>5__4;
						<>1__state = 49;
						return true;
					case 49:
						<>1__state = -4;
						<mod>5__6 = null;
						goto IL_0ae5;
					case 50:
						{
							<>1__state = -3;
							goto IL_0b30;
						}
						IL_0ae5:
						while (<>7__wrap4.MoveNext())
						{
							<mod>5__6 = <>7__wrap4.Current;
							if (<mod>5__6.PackPath != null)
							{
								<>2__current = new IdentifierToken("ProjectSettings");
								<>1__state = 2;
								return true;
							}
						}
						<>m__Finally2();
						<>7__wrap4 = default(Enumerator<LoadedMod>);
						packFileLoader.Ran = true;
						goto IL_0b30;
						IL_0b30:
						<token>5__4 = null;
						break;
					}
					if (((global::System.Collections.IEnumerator)<>7__wrap2).MoveNext())
					{
						<token>5__4 = <>7__wrap2.Current;
						if (<readyWaiter>5__2.Check(<token>5__4))
						{
							<>2__current = <token>5__4;
							<>1__state = 1;
							return true;
						}
						<>2__current = <token>5__4;
						<>1__state = 50;
						return true;
					}
					<>m__Finally1();
					<>7__wrap2 = null;
					return false;
				}
				catch
				{
					//try-fault
					((global::System.IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap2 != null)
				{
					((global::System.IDisposable)<>7__wrap2).Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				((global::System.IDisposable)<>7__wrap4).Dispose();
			}

			[DebuggerHidden]
			void global::System.Collections.IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			global::System.Collections.Generic.IEnumerator<Token> global::System.Collections.Generic.IEnumerable<Token>.GetEnumerator()
			{
				<Modify>d__4 <Modify>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Modify>d__ = this;
				}
				else
				{
					<Modify>d__ = new <Modify>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<Modify>d__.tokens = <>3__tokens;
				return <Modify>d__;
			}

			[DebuggerHidden]
			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return (global::System.Collections.IEnumerator)((global::System.Collections.Generic.IEnumerable<Token>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private List<LoadedMod> <mods>P;

		public bool Ran;

		public PackFileLoader(List<LoadedMod> mods)
		{
			<mods>P = mods;
			base..ctor();
		}

		public bool ShouldRun(string path)
		{
			return !Ran;
		}

		[IteratorStateMachine(typeof(<Modify>d__4))]
		public global::System.Collections.Generic.IEnumerable<Token> Modify(string path, global::System.Collections.Generic.IEnumerable<Token> tokens)
		{
			MultiTokenWaiter readyWaiter = new MultiTokenWaiter(new Func<Token, bool>[6]
			{
				(Token t) => t.Type == TokenType.PrFunction,
				(Token t) => t is IdentifierToken identifierToken && identifierToken.Name == "_ready",
				(Token t) => t.Type == TokenType.ParenthesisOpen,
				(Token t) => t.Type == TokenType.ParenthesisClose,
				(Token t) => t.Type == TokenType.Colon,
				(Token t) => t.Type == TokenType.Newline
			});
			global::System.Collections.Generic.IEnumerator<Token> enumerator = tokens.GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					Token token = enumerator.Current;
					if (readyWaiter.Check(token))
					{
						yield return token;
						Enumerator<LoadedMod> enumerator2 = <mods>P.GetEnumerator();
						try
						{
							while (enumerator2.MoveNext())
							{
								LoadedMod mod = enumerator2.Current;
								if (mod.PackPath != null)
								{
									yield return new IdentifierToken("ProjectSettings");
									yield return new Token(TokenType.Period);
									yield return new IdentifierToken("load_resource_pack");
									yield return new Token(TokenType.ParenthesisOpen);
									yield return new ConstantToken(new StringVariant(mod.PackPath));
									yield return new Token(TokenType.ParenthesisClose);
									yield return token;
									yield return new Token(TokenType.PrVar);
									yield return new IdentifierToken(mod.Manifest.Id ?? "");
									yield return new Token(TokenType.OpAssign);
									yield return new Token(TokenType.BuiltInFunc, 76u);
									yield return new Token(TokenType.ParenthesisOpen);
									yield return new ConstantToken(new StringVariant("res://mods/" + mod.Manifest.Id + "/main.gd"));
									yield return new Token(TokenType.ParenthesisClose);
									yield return new Token(TokenType.Period);
									yield return new IdentifierToken("new");
									yield return new Token(TokenType.ParenthesisOpen);
									yield return new Token(TokenType.ParenthesisClose);
									yield return token;
									yield return new IdentifierToken(mod.Manifest.Id ?? "");
									yield return new Token(TokenType.Period);
									yield return new IdentifierToken("add_to_group");
									yield return new Token(TokenType.ParenthesisOpen);
									yield return new ConstantToken(new StringVariant("gdweave_mod"));
									yield return new Token(TokenType.ParenthesisClose);
									yield return token;
									yield return new IdentifierToken(mod.Manifest.Id ?? "");
									yield return new Token(TokenType.Period);
									yield return new IdentifierToken("set_name");
									yield return new Token(TokenType.ParenthesisOpen);
									yield return new ConstantToken(new StringVariant(mod.Manifest.Id ?? ""));
									yield return new Token(TokenType.ParenthesisClose);
									yield return token;
									yield return new IdentifierToken("get_tree");
									yield return new Token(TokenType.ParenthesisOpen);
									yield return new Token(TokenType.ParenthesisClose);
									yield return new Token(TokenType.Period);
									yield return new IdentifierToken("get_root");
									yield return new Token(TokenType.ParenthesisOpen);
									yield return new Token(TokenType.ParenthesisClose);
									yield return new Token(TokenType.Period);
									yield return new IdentifierToken("call_deferred");
									yield return new Token(TokenType.ParenthesisOpen);
									yield return new ConstantToken(new StringVariant("add_child"));
									yield return new Token(TokenType.Comma);
									yield return new IdentifierToken(mod.Manifest.Id ?? "");
									yield return new Token(TokenType.ParenthesisClose);
									yield return token;
								}
							}
						}
						finally
						{
							((global::System.IDisposable)enumerator2).Dispose();
						}
						Ran = true;
					}
					else
					{
						yield return token;
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
		}
	}
	public static class MemoryUtils
	{
		[DllImport("kernel32.dll", SetLastError = true)]
		public static extern bool VirtualProtect(nint address, nint size, uint newProtect, out uint oldProtect);

		public static void Unprotect(nint memoryAddress, int size, Action action)
		{
			VirtualProtect(memoryAddress, size, 64u, out var oldProtect);
			action.Invoke();
			VirtualProtect(memoryAddress, size, oldProtect, out var _);
		}

		public static byte[] ReadRaw(nint memoryAddress, int length)
		{
			byte[] array = new byte[length];
			Marshal.Copy((global::System.IntPtr)memoryAddress, array, 0, array.Length);
			return array;
		}

		public static void WriteRaw(nint memoryAddress, byte[] value)
		{
			Marshal.Copy(value, 0, (global::System.IntPtr)memoryAddress, value.Length);
		}

		public static void TrimNullTerminator(ref string str)
		{
			int num = str.IndexOf('\0');
			if (num != -1)
			{
				str = str.Substring(0, num);
			}
		}
	}
}
namespace GDWeave.Modding
{
	public class FunctionWaiter : IWaiter
	{
		[CompilerGenerated]
		private bool <waitForReady>P;

		private readonly MultiTokenWaiter functionWaiter;

		private bool foundFunction;

		private bool foundColon;

		[field: CompilerGenerated]
		public bool Matched
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public bool Ready
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		public FunctionWaiter(string name, bool waitForReady = false)
		{
			<waitForReady>P = waitForReady;
			string name2 = name;
			functionWaiter = new MultiTokenWaiter(new Func<Token, bool>[2]
			{
				(Token t) => t.Type == TokenType.PrFunction,
				(Token t) => t is IdentifierToken identifierToken && identifierToken.Name == name2
			});
			Ready = !<waitForReady>P;
			base..ctor();
		}

		public void Reset()
		{
			foundFunction = false;
			foundColon = false;
			Matched = false;
			Ready = !<waitForReady>P;
			functionWaiter.Reset();
		}

		public void SetReady()
		{
			Ready = true;
		}

		public bool Check(Token token)
		{
			if (!Ready || Matched)
			{
				return false;
			}
			if (foundColon && token.Type == TokenType.Newline)
			{
				Matched = true;
				return true;
			}
			if (foundFunction && token.Type == TokenType.Colon)
			{
				foundColon = true;
				return false;
			}
			if (functionWaiter.Check(token))
			{
				foundFunction = true;
				return false;
			}
			return false;
		}
	}
	public interface IWaiter
	{
		bool Matched { get; }

		bool Ready { get; }

		void Reset();

		void SetReady();

		bool Check(Token token);
	}
	public class MultiTokenWaiter : IWaiter
	{
		[CompilerGenerated]
		private Func<Token, bool>[] <checks>P;

		[CompilerGenerated]
		private bool <waitForReady>P;

		[CompilerGenerated]
		private bool <allowPartialMatch>P;

		[field: CompilerGenerated]
		public bool Matched
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public bool Ready
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public uint Step
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		public MultiTokenWaiter(Func<Token, bool>[] checks, bool waitForReady = false, bool allowPartialMatch = false)
		{
			<checks>P = checks;
			<waitForReady>P = waitForReady;
			<allowPartialMatch>P = allowPartialMatch;
			Ready = !<waitForReady>P;
			base..ctor();
		}

		public void Reset()
		{
			Matched = false;
			Ready = !<waitForReady>P;
			Step = 0u;
		}

		public void SetReady()
		{
			Ready = true;
		}

		public bool Check(Token token)
		{
			if (!Matched && Ready)
			{
				if (<checks>P[Step].Invoke(token))
				{
					Step++;
					if (Step >= <checks>P.Length)
					{
						Matched = true;
						return true;
					}
				}
				else if (!<allowPartialMatch>P)
				{
					Reset();
				}
			}
			return false;
		}
	}
	public interface IScriptMod
	{
		bool ShouldRun(string path);

		global::System.Collections.Generic.IEnumerable<Token> Modify(string path, global::System.Collections.Generic.IEnumerable<Token> tokens);
	}
	public class ScriptModder
	{
		[CompilerGenerated]
		private List<IScriptMod>? <mods>P;

		public ScriptModder(List<IScriptMod>? mods = null)
		{
			<mods>P = mods;
			base..ctor();
		}

		public bool Run(GodotScriptFile file, string path)
		{
			//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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			List<Token> val = CreateSpecialTokens(file);
			bool flag = false;
			if (<mods>P != null)
			{
				Enumerator<IScriptMod> enumerator = <mods>P.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						IScriptMod current = enumerator.Current;
						if (current.ShouldRun(path))
						{
							flag = true;
							val = Enumerable.ToList<Token>(current.Modify(path, (global::System.Collections.Generic.IEnumerable<Token>)val));
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator).Dispose();
				}
			}
			if (!flag)
			{
				return false;
			}
			file.Tokens.Clear();
			file.Lines.Clear();
			Enumerator<Token> enumerator2 = val.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					Token current2 = enumerator2.Current;
					ConstantToken constantToken = current2 as ConstantToken;
					if (constantToken == null)
					{
						IdentifierToken identifierToken = current2 as IdentifierToken;
						if (identifierToken != null)
						{
							int num = file.Identifiers.FindIndex((Predicate<string>)((string x) => x == identifierToken.Name));
							if (num == -1)
							{
								num = file.Identifiers.Count;
								file.Identifiers.Add(identifierToken.Name);
							}
							identifierToken.AssociatedData = (uint)num;
						}
					}
					else
					{
						int num2 = file.Constants.FindIndex((Predicate<Variant>)((Variant x) => x.Equals(constantToken.Value)));
						if (num2 == -1)
						{
							num2 = file.Constants.Count;
							file.Constants.Add(constantToken.Value);
						}
						constantToken.AssociatedData = (uint)num2;
					}
					file.Tokens.Add(current2);
					uint num3 = (uint)(file.Tokens.Count - 1);
					file.Lines.Add(new ValueTuple<uint, uint>(num3, num3 & 0xFFFFFFu));
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator2).Dispose();
			}
			return true;
		}

		public static List<Token> CreateSpecialTokens(GodotScriptFile file)
		{
			//IL_000c: 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)
			List<Token> val = new List<Token>();
			Enumerator<Token> enumerator = file.Tokens.GetEnumerator();
			try
			{
				Token token;
				Token token2;
				for (; enumerator.MoveNext(); token2 = token, val.Add(token2))
				{
					Token current = enumerator.Current;
					switch (current.Type)
					{
					case TokenType.Identifier:
					{
						uint? associatedData = current.AssociatedData;
						if (associatedData.HasValue)
						{
							token = new IdentifierToken(current.Type, current.AssociatedData, file.Identifiers[(int)current.AssociatedData.GetValueOrDefault()]);
							continue;
						}
						break;
					}
					case TokenType.Constant:
						token = new ConstantToken(current.Type, current.AssociatedData, (Variant)file.Constants[(int)current.AssociatedData.GetValueOrDefault()].Clone());
						continue;
					}
					token = current;
				}
				return val;
			}
			finally
			{
				((global::System.IDisposable)enumerator).Dispose();
			}
		}
	}
	public static class ScriptTokenizer
	{
		[StructLayout(3)]
		[CompilerGenerated]
		private struct <>c__DisplayClass6_0
		{
			public string previous;

			public global::System.Collections.Generic.IEnumerator<string> enumerator;

			public List<Token> finalTokens;

			public List<Token> toFlush;

			public string idName;
		}

		[StructLayout(3)]
		[CompilerGenerated]
		private struct <>c__DisplayClass8_0
		{
			public StringBuilder builder;
		}

		[CompilerGenerated]
		private sealed class <SanitizeInput>d__7 : global::System.Collections.Generic.IEnumerable<string>, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerator<string>, global::System.Collections.IEnumerator, global::System.IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private global::System.Collections.Generic.IEnumerable<string> tokens;

			public global::System.Collections.Generic.IEnumerable<string> <>3__tokens;

			private global::System.Collections.Generic.IEnumerator<string> <>7__wrap1;

			string global::System.Collections.Generic.IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			public <SanitizeInput>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = tokens.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (((global::System.Collections.IEnumerator)<>7__wrap1).MoveNext())
					{
						string current = <>7__wrap1.Current;
						if (!(current != "\n") || !string.IsNullOrWhiteSpace(current))
						{
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((global::System.IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					((global::System.IDisposable)<>7__wrap1).Dispose();
				}
			}

			[DebuggerHidden]
			void global::System.Collections.IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			global::System.Collections.Generic.IEnumerator<string> global::System.Collections.Generic.IEnumerable<string>.GetEnumerator()
			{
				<SanitizeInput>d__7 <SanitizeInput>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SanitizeInput>d__ = this;
				}
				else
				{
					<SanitizeInput>d__ = new <SanitizeInput>d__7(0);
				}
				<SanitizeInput>d__.tokens = <>3__tokens;
				return <SanitizeInput>d__;
			}

			[DebuggerHidden]
			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return (global::System.Collections.IEnumerator)((global::System.Collections.Generic.IEnumerable<string>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <Tokenize>d__6 : global::System.Collections.Generic.IEnumerable<Token>, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerator<Token>, global::System.Collections.IEnumerator, global::System.IDisposable
		{
			private int <>1__state;

			private Token <>2__current;

			private int <>l__initialThreadId;

			private string gdScript;

			public string <>3__gdScript;

			private uint baseIndent;

			public uint <>3__baseIndent;

			private Enumerator<Token> <>7__wrap1;

			Token global::System.Collections.Generic.IEnumerator<Token>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			public <Tokenize>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				//IL_035a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0305: Unknown result type (might be due to invalid IL or missing references)
				//IL_030a: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						<>c__DisplayClass6_0 <>c__DisplayClass6_ = default(<>c__DisplayClass6_0);
						<>c__DisplayClass6_.finalTokens = new List<Token>();
						global::System.Collections.Generic.IEnumerable<string> enumerable = SanitizeInput(TokenizeString(gdScript + " "));
						<>c__DisplayClass6_.previous = string.Empty;
						<>c__DisplayClass6_.idName = string.Empty;
						<>c__DisplayClass6_.toFlush = new List<Token>(2);
						<>c__DisplayClass6_.finalTokens.Add(new Token(TokenType.Newline, baseIndent));
						<>c__DisplayClass6_.enumerator = enumerable.GetEnumerator();
						bool flag = false;
						TokenType type = default(TokenType);
						bool value = default(bool);
						while (flag || ((global::System.Collections.IEnumerator)<>c__DisplayClass6_.enumerator).MoveNext())
						{
							flag = false;
							if (<>c__DisplayClass6_.enumerator.Current == "\n")
							{
								InsertNewLine(<>c__DisplayClass6_.enumerator, baseIndent, <>c__DisplayClass6_.toFlush);
								<Tokenize>g__endAndFlushId|6_1(ref <>c__DisplayClass6_);
							}
							else if (<>c__DisplayClass6_.enumerator.Current == "_")
							{
								BuildIdentifierName(<>c__DisplayClass6_.enumerator, <>c__DisplayClass6_.toFlush, out string found);
								if (found == string.Empty)
								{
									<Tokenize>g__endAndFlushId|6_1(ref <>c__DisplayClass6_);
									continue;
								}
								<>c__DisplayClass6_.idName += found;
								<Tokenize>g__end|6_0(ref <>c__DisplayClass6_);
							}
							else if (<>c__DisplayClass6_.enumerator.Current == "-" || char.IsDigit(<>c__DisplayClass6_.enumerator.Current[0]))
							{
								BuildNumber(<>c__DisplayClass6_.enumerator, <>c__DisplayClass6_.toFlush, out var foundFull);
								flag = !foundFull;
								<Tokenize>g__endAndFlushId|6_1(ref <>c__DisplayClass6_);
							}
							else if (BuiltinFunctions.Contains(<>c__DisplayClass6_.enumerator.Current))
							{
								<>c__DisplayClass6_.toFlush.Add(new Token(TokenType.BuiltInFunc, (uint)BuiltinFunctions.IndexOf(<>c__DisplayClass6_.enumerator.Current)));
								<Tokenize>g__endAndFlushId|6_1(ref <>c__DisplayClass6_);
							}
							else if (Tokens.TryGetValue(<>c__DisplayClass6_.enumerator.Current, ref type))
							{
								<>c__DisplayClass6_.toFlush.Add(new Token(type));
								<Tokenize>g__endAndFlushId|6_1(ref <>c__DisplayClass6_);
							}
							else if (<>c__DisplayClass6_.enumerator.Current.StartsWith('"'))
							{
								string current = <>c__DisplayClass6_.enumerator.Current;
								<>c__DisplayClass6_.toFlush.Add((Token)new ConstantToken(new StringVariant(current.Substring(1, current.Length - 2))));
								<Tokenize>g__endAndFlushId|6_1(ref <>c__DisplayClass6_);
							}
							else if (bool.TryParse(<>c__DisplayClass6_.enumerator.Current, ref value))
							{
								<>c__DisplayClass6_.toFlush.Add((Token)new ConstantToken(new BoolVariant(value)));
								<Tokenize>g__endAndFlushId|6_1(ref <>c__DisplayClass6_);
							}
							else
							{
								<>c__DisplayClass6_.idName += <>c__DisplayClass6_.enumerator.Current;
								<Tokenize>g__end|6_0(ref <>c__DisplayClass6_);
							}
						}
						<>c__DisplayClass6_.finalTokens.Add(new Token(TokenType.Newline, baseIndent));
						<>7__wrap1 = <>c__DisplayClass6_.finalTokens.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						Token current2 = <>7__wrap1.Current;
						<>2__current = current2;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = default(Enumerator<Token>);
					return false;
				}
				catch
				{
					//try-fault
					((global::System.IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((global::System.IDisposable)<>7__wrap1).Dispose();
			}

			[DebuggerHidden]
			void global::System.Collections.IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			global::System.Collections.Generic.IEnumerator<Token> global::System.Collections.Generic.IEnumerable<Token>.GetEnumerator()
			{
				<Tokenize>d__6 <Tokenize>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Tokenize>d__ = this;
				}
				else
				{
					<Tokenize>d__ = new <Tokenize>d__6(0);
				}
				<Tokenize>d__.gdScript = <>3__gdScript;
				<Tokenize>d__.baseIndent = <>3__baseIndent;
				return <Tokenize>d__;
			}

			[DebuggerHidden]
			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return (global::System.Collections.IEnumerator)((global::System.Collections.Generic.IEnumerable<Token>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <TokenizeString>d__8 : global::System.Collections.Generic.IEnumerable<string>, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerator<string>, global::System.Collections.IEnumerator, global::System.IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string text;

			public string <>3__text;

			private <>c__DisplayClass8_0 <>8__1;

			private int <i>5__2;

			private int <start>5__3;

			private Enumerator<string> <>7__wrap3;

			private string <delimiter>5__5;

			string global::System.Collections.Generic.IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			public <TokenizeString>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Expected O, but got Unknown
				//IL_0322: Unknown result type (might be due to invalid IL or missing references)
				//IL_0257: Unknown result type (might be due to invalid IL or missing references)
				//IL_025c: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					bool flag;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>8__1.builder = new StringBuilder(20);
						<i>5__2 = 0;
						goto IL_0399;
					case 1:
						<>1__state = -1;
						<>8__1.builder.Append('"');
						<i>5__2++;
						while (<i>5__2 < text.Length)
						{
							<>8__1.builder.Append(text[<i>5__2]);
							if (text[<i>5__2] == '"')
							{
								break;
							}
							<i>5__2++;
						}
						<>2__current = <TokenizeString>g__ClearBuilder|8_0(ref <>8__1);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						goto IL_0387;
					case 3:
						<>1__state = -1;
						<start>5__3 = <i>5__2;
						<i>5__2++;
						while (<i>5__2 < text.Length && text[<i>5__2] == ' ')
						{
							<i>5__2++;
						}
						<i>5__2--;
						<>2__current = "\n";
						<>1__state = 4;
						return true;
					case 4:
						<>1__state = -1;
						<>2__current = $"{(<i>5__2 - <start>5__3) / 4}";
						<>1__state = 5;
						return true;
					case 5:
						<>1__state = -1;
						goto IL_0387;
					case 6:
						<>1__state = -3;
						<>2__current = <delimiter>5__5;
						<>1__state = 7;
						return true;
					case 7:
						<>1__state = -3;
						<i>5__2 += <delimiter>5__5.Length - 1;
						flag = true;
						goto IL_0316;
					case 8:
						<>1__state = -1;
						goto IL_0387;
					case 9:
						{
							<>1__state = -1;
							return false;
						}
						IL_0399:
						if (<i>5__2 < text.Length)
						{
							switch (text[<i>5__2])
							{
							case '"':
								<>2__current = <TokenizeString>g__ClearBuilder|8_0(ref <>8__1);
								<>1__state = 1;
								return true;
							case '\n':
								<>2__current = <TokenizeString>g__ClearBuilder|8_0(ref <>8__1);
								<>1__state = 3;
								return true;
							}
							flag = false;
							<>7__wrap3 = Symbols.GetEnumerator();
							<>1__state = -3;
							while (<>7__wrap3.MoveNext())
							{
								<delimiter>5__5 = <>7__wrap3.Current;
								if (Match(text, <i>5__2, <delimiter>5__5))
								{
									<>2__current = <TokenizeString>g__ClearBuilder|8_0(ref <>8__1);
									<>1__state = 6;
									return true;
								}
								<delimiter>5__5 = null;
							}
							goto IL_0316;
						}
						<>2__current = "\n";
						<>1__state = 9;
						return true;
						IL_0387:
						<i>5__2++;
						goto IL_0399;
						IL_0316:
						<>m__Finally1();
						<>7__wrap3 = default(Enumerator<string>);
						if (!flag)
						{
							if (text[<i>5__2] == ' ')
							{
								<>2__current = <TokenizeString>g__ClearBuilder|8_0(ref <>8__1);
								<>1__state = 8;
								return true;
							}
							<>8__1.builder.Append(text[<i>5__2]);
						}
						goto IL_0387;
					}
				}
				catch
				{
					//try-fault
					((global::System.IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((global::System.IDisposable)<>7__wrap3).Dispose();
			}

			[DebuggerHidden]
			void global::System.Collections.IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			global::System.Collections.Generic.IEnumerator<string> global::System.Collections.Generic.IEnumerable<string>.GetEnumerator()
			{
				<TokenizeString>d__8 <TokenizeString>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<TokenizeString>d__ = this;
				}
				else
				{
					<TokenizeString>d__ = new <TokenizeString>d__8(0);
				}
				<TokenizeString>d__.text = <>3__text;
				return <TokenizeString>d__;
			}

			[DebuggerHidden]
			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return (global::System.Collections.IEnumerator)((global::System.Collections.Generic.IEnumerable<string>)this).GetEnumerator();
			}
		}

		private static readonly Dictionary<string, TokenType> Tokens;

		private static readonly HashSet<string> Symbols;

		private static readonly List<string> BuiltinFunctions;

		private static void InsertNewLine(global::System.Collections.Generic.IEnumerator<string> enumerator, uint baseIndent, List<Token> toFlush)
		{
			if (((global::System.Collections.IEnumerator)enumerator).MoveNext())
			{
				uint num = uint.Parse(enumerator.Current);
				toFlush.Add(new Token(TokenType.Newline, num + baseIndent));
			}
		}

		private static void BuildIdentifierName(global::System.Collections.Generic.IEnumerator<string> enumerator, List<Token> toFlush, out string? found)
		{
			found = string.Empty;
			if (((global::System.Collections.IEnumerator)enumerator).MoveNext())
			{
				if (enumerator.Current == ":")
				{
					toFlush.Add(new Token(TokenType.Wildcard));
					toFlush.Add(new Token(TokenType.Semicolon));
				}
				else
				{
					found = "_" + enumerator.Current;
				}
			}
		}

		private static void BuildNumber(global::System.Collections.Generic.IEnumerator<string> enumerator, List<Token> toFlush, out bool foundFull)
		{
			foundFull = true;
			int num = 1;
			if (enumerator.Current == "-")
			{
				num = -1;
				if (!((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					return;
				}
			}
			long num2 = default(long);
			if (!long.TryParse(enumerator.Current, ref num2))
			{
				toFlush.Add(new Token(TokenType.OpSub));
				foundFull = false;
			}
			else if (((global::System.Collections.IEnumerator)enumerator).MoveNext())
			{
				long num3 = default(long);
				if (enumerator.Current != ".")
				{
					toFlush.Add((Token)new ConstantToken(new IntVariant(num2 * num)));
					foundFull = false;
				}
				else if (((global::System.Collections.IEnumerator)enumerator).MoveNext() && long.TryParse(enumerator.Current, ref num3))
				{
					double num4 = (double)num2 + (double)num3 / Math.Pow(10.0, (double)num3.ToString().Length);
					toFlush.Add((Token)new ConstantToken(new RealVariant(num4 * (double)num)));
				}
			}
		}

		[IteratorStateMachine(typeof(<Tokenize>d__6))]
		public static global::System.Collections.Generic.IEnumerable<Token> Tokenize(string gdScript, uint baseIndent = 0u)
		{
			List<Token> finalTokens = new List<Token>();
			global::System.Collections.Generic.IEnumerable<string> enumerable = SanitizeInput(TokenizeString(gdScript + " "));
			string previous = string.Empty;
			string idName = string.Empty;
			List<Token> toFlush = new List<Token>(2);
			finalTokens.Add(new Token(TokenType.Newline, baseIndent));
			global::System.Collections.Generic.IEnumerator<string> enumerator = enumerable.GetEnumerator();
			bool flag = false;
			TokenType type = default(TokenType);
			bool value = default(bool);
			while (flag || ((global::System.Collections.IEnumerator)enumerator).MoveNext())
			{
				flag = false;
				if (enumerator.Current == "\n")
				{
					InsertNewLine(enumerator, baseIndent, toFlush);
					endAndFlushId();
				}
				else if (enumerator.Current == "_")
				{
					BuildIdentifierName(enumerator, toFlush, out string found);
					if (found == string.Empty)
					{
						endAndFlushId();
						continue;
					}
					idName += found;
					end();
				}
				else if (enumerator.Current == "-" || char.IsDigit(enumerator.Current[0]))
				{
					BuildNumber(enumerator, toFlush, out var foundFull);
					flag = !foundFull;
					endAndFlushId();
				}
				else if (BuiltinFunctions.Contains(enumerator.Current))
				{
					toFlush.Add(new Token(TokenType.BuiltInFunc, (uint)BuiltinFunctions.IndexOf(enumerator.Current)));
					endAndFlushId();
				}
				else if (Tokens.TryGetValue(enumerator.Current, ref type))
				{
					toFlush.Add(new Token(type));
					endAndFlushId();
				}
				else if (enumerator.Current.StartsWith('"'))
				{
					string current = enumerator.Current;
					toFlush.Add((Token)new ConstantToken(new StringVariant(current.Substring(1, current.Length - 2))));
					endAndFlushId();
				}
				else if (bool.TryParse(enumerator.Current, ref value))
				{
					toFlush.Add((Token)new ConstantToken(new BoolVariant(value)));
					endAndFlushId();
				}
				else
				{
					idName += enumerator.Current;
					end();
				}
			}
			finalTokens.Add(new Token(TokenType.Newline, baseIndent));
			Enumerator<Token> enumerator2 = finalTokens.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					yield return enumerator2.Current;
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator2).Dispose();
			}
			[CompilerGenerated]
			void end()
			{
				previous = enumerator.Current;
				finalTokens.AddRange((global::System.Collections.Generic.IEnumerable<Token>)toFlush);
				toFlush.Clear();
			}
			[CompilerGenerated]
			void endAndFlushId()
			{
				if (idName != string.Empty)
				{
					finalTokens.Add((Token)new IdentifierToken(idName));
					idName = string.Empty;
				}
				end();
			}
		}

		[IteratorStateMachine(typeof(<SanitizeInput>d__7))]
		private static global::System.Collections.Generic.IEnumerable<string> SanitizeInput(global::System.Collections.Generic.IEnumerable<string> tokens)
		{
			global::System.Collections.Generic.IEnumerator<string> enumerator = tokens.GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					string current = enumerator.Current;
					if (!(current != "\n") || !string.IsNullOrWhiteSpace(current))
					{
						yield return current;
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
		}

		[IteratorStateMachine(typeof(<TokenizeString>d__8))]
		private static global::System.Collections.Generic.IEnumerable<string> TokenizeString(string text)
		{
			StringBuilder builder = new StringBuilder(20);
			for (int j = 0; j < text.Length; j++)
			{
				switch (text[j])
				{
				case '"':
					yield return ClearBuilder();
					builder.Append('"');
					for (j++; j < text.Length; j++)
					{
						builder.Append(text[j]);
						if (text[j] == '"')
						{
							break;
						}
					}
					yield return ClearBuilder();
					continue;
				case '\n':
				{
					yield return ClearBuilder();
					int start = j;
					for (j++; j < text.Length && text[j] == ' '; j++)
					{
					}
					j--;
					yield return "\n";
					yield return $"{(j - start) / 4}";
					continue;
				}
				}
				bool flag = false;
				Enumerator<string> enumerator = Symbols.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						string delimiter = enumerator.Current;
						if (Match(text, j, delimiter))
						{
							yield return ClearBuilder();
							yield return delimiter;
							j += delimiter.Length - 1;
							flag = true;
							break;
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator).Dispose();
				}
				if (!flag)
				{
					if (text[j] == ' ')
					{
						yield return ClearBuilder();
					}
					else
					{
						builder.Append(text[j]);
					}
				}
			}
			yield return "\n";
			[CompilerGenerated]
			string ClearBuilder()
			{
				string result = ((object)builder).ToString();
				builder.Clear();
				return result;
			}
		}

		private static bool Match(string text, int index, string match)
		{
			return string.Compare(text, index, match, 0, match.Length) == 0;
		}

		static ScriptTokenizer()
		{
			Dictionary<string, TokenType> obj = new Dictionary<string, TokenType>();
			obj.Add("continue", TokenType.CfContinue);
			obj.Add("return", TokenType.CfReturn);
			obj.Add("break", TokenType.CfBreak);
			obj.Add("match", TokenType.CfMatch);
			obj.Add("while", TokenType.CfWhile);
			obj.Add("elif", TokenType.CfElif);
			obj.Add("else", TokenType.CfElse);
			obj.Add("pass", TokenType.CfPass);
			obj.Add("for", TokenType.CfFor);
			obj.Add("if", TokenType.CfIf);
			obj.Add("const", TokenType.PrConst);
			obj.Add("var", TokenType.PrVar);
			obj.Add("func", TokenType.PrFunction);
			obj.Add("class", TokenType.PrClass);
			obj.Add("extends", TokenType.PrExtends);
			obj.Add("is", TokenType.PrIs);
			obj.Add("as", TokenType.PrAs);
			obj.Add("@onready", TokenType.PrOnready);
			obj.Add("@tool", TokenType.PrTool);
			obj.Add("@export", TokenType.PrExport);
			obj.Add("setget", TokenType.PrSetget);
			obj.Add("static", TokenType.PrStatic);
			obj.Add("void", TokenType.PrVoid);
			obj.Add("enum", TokenType.PrEnum);
			obj.Add("preload", TokenType.PrPreload);
			obj.Add("assert", TokenType.PrAssert);
			obj.Add("signal", TokenType.PrSignal);
			obj.Add("breakpoint", TokenType.PrBreakpoint);
			obj.Add("sync", TokenType.PrSync);
			obj.Add("remote", TokenType.PrRemote);
			obj.Add("master", TokenType.PrMaster);
			obj.Add("slave", TokenType.PrSlave);
			obj.Add("puppet", TokenType.PrPuppet);
			obj.Add("remotesync", TokenType.PrRemotesync);
			obj.Add("mastersync", TokenType.PrMastersync);
			obj.Add("puppetsync", TokenType.PrPuppetsync);
			obj.Add("\n", TokenType.Newline);
			obj.Add("PI", TokenType.ConstPi);
			obj.Add("TAU", TokenType.ConstTau);
			obj.Add("INF", TokenType.ConstInf);
			obj.Add("NAN", TokenType.ConstNan);
			obj.Add("error", TokenType.Error);
			obj.Add("cursor", TokenType.Cursor);
			obj.Add("in", TokenType.OpIn);
			obj.Add("_", TokenType.Wildcard);
			obj.Add("[", TokenType.BracketOpen);
			obj.Add("]", TokenType.BracketClose);
			obj.Add("{", TokenType.CurlyBracketOpen);
			obj.Add("}", TokenType.CurlyBracketOpen);
			obj.Add("(", TokenType.ParenthesisOpen);
			obj.Add(")", TokenType.ParenthesisClose);
			obj.Add(",", TokenType.Comma);
			obj.Add(";", TokenType.Semicolon);
			obj.Add(".", TokenType.Period);
			obj.Add("?", TokenType.QuestionMark);
			obj.Add(":", TokenType.Colon);
			obj.Add("$", TokenType.Dollar);
			obj.Add("->", TokenType.ForwardArrow);
			obj.Add(">>=", TokenType.OpAssignShiftRight);
			obj.Add("<<=", TokenType.OpAssignShiftLeft);
			obj.Add(">>", TokenType.OpShiftRight);
			obj.Add("<<", TokenType.OpShiftLeft);
			obj.Add("==", TokenType.OpEqual);
			obj.Add("!=", TokenType.OpNotEqual);
			obj.Add("&&", TokenType.OpAnd);
			obj.Add("||", TokenType.OpOr);
			obj.Add("!", TokenType.OpNot);
			obj.Add("+=", TokenType.OpAssignAdd);
			obj.Add("-=", TokenType.OpAssignSub);
			obj.Add("*=", TokenType.OpAssignMul);
			obj.Add("/=", TokenType.OpAssignDiv);
			obj.Add("%=", TokenType.OpAssignMod);
			obj.Add("&=", TokenType.OpAssignBitAnd);
			obj.Add("|=", TokenType.OpAssignBitOr);
			obj.Add("^=", TokenType.OpAssignBitXor);
			obj.Add("+", TokenType.OpAdd);
			obj.Add("-", TokenType.OpSub);
			obj.Add("*", TokenType.OpMul);
			obj.Add("/", TokenType.OpDiv);
			obj.Add("%", TokenType.OpMod);
			obj.Add("~", TokenType.OpBitInvert);
			obj.Add("&", TokenType.OpBitAnd);
			obj.Add("|", TokenType.OpBitOr);
			obj.Add("^", TokenType.OpBitXor);
			obj.Add("<=", TokenType.OpLessEqual);
			obj.Add(">=", TokenType.OpGreaterEqual);
			obj.Add("<", TokenType.OpLess);
			obj.Add(">", TokenType.OpGreater);
			obj.Add("=", TokenType.OpAssign);
			Tokens = obj;
			HashSet<string> obj2 = new HashSet<string>();
			obj2.Add("->");
			obj2.Add(">>=");
			obj2.Add("<<=");
			obj2.Add(">>");
			obj2.Add("<<");
			obj2.Add("==");
			obj2.Add("!=");
			obj2.Add("&&");
			obj2.Add("||");
			obj2.Add("!");
			obj2.Add("+=");
			obj2.Add("-=");
			obj2.Add("*=");
			obj2.Add("/=");
			obj2.Add("%=");
			obj2.Add("&=");
			obj2.Add("|=");
			obj2.Add("^=");
			obj2.Add("_");
			obj2.Add("[");
			obj2.Add("]");
			obj2.Add("{");
			obj2.Add("}");
			obj2.Add("(");
			obj2.Add(")");
			obj2.Add(",");
			obj2.Add(";");
			obj2.Add(".");
			obj2.Add("?");
			obj2.Add(":");
			obj2.Add("$");
			obj2.Add("+");
			obj2.Add("-");
			obj2.Add("*");
			obj2.Add("/");
			obj2.Add("%");
			obj2.Add("~");
			obj2.Add("&");
			obj2.Add("|");
			obj2.Add("^");
			obj2.Add("<=");
			obj2.Add(">=");
			obj2.Add("<");
			obj2.Add(">");
			obj2.Add("=");
			Symbols = obj2;
			BuiltinFunctions = Enumerable.ToList<string>((global::System.Collections.Generic.IEnumerable<string>)global::System.Enum.GetNames<BuiltinFunction>());
		}

		[CompilerGenerated]
		internal static void <Tokenize>g__end|6_0(ref <>c__DisplayClass6_0 P_0)
		{
			P_0.previous = P_0.enumerator.Current;
			P_0.finalTokens.AddRange((global::System.Collections.Generic.IEnumerable<Token>)P_0.toFlush);
			P_0.toFlush.Clear();
		}

		[CompilerGenerated]
		internal static void <Tokenize>g__endAndFlushId|6_1(ref <>c__DisplayClass6_0 P_0)
		{
			if (P_0.idName != string.Empty)
			{
				P_0.finalTokens.Add((Token)new IdentifierToken(P_0.idName));
				P_0.idName = string.Empty;
			}
			<Tokenize>g__end|6_0(ref P_0);
		}

		[CompilerGenerated]
		internal static string <TokenizeString>g__ClearBuilder|8_0(ref <>c__DisplayClass8_0 P_0)
		{
			string result = ((object)P_0.builder).ToString();
			P_0.builder.Clear();
			return result;
		}
	}
	public class TokenConsumer : IWaiter
	{
		[CompilerGenerated]
		private Func<Token, bool> <check>P;

		[field: CompilerGenerated]
		public bool Matched
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public bool Ready
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		public TokenConsumer(Func<Token, bool> check)
		{
			<check>P = check;
			base..ctor();
		}

		public void Reset()
		{
			Matched = false;
			Ready = false;
		}

		public void SetReady()
		{
			Ready = true;
		}

		public bool Check(Token token)
		{
			if (!Matched && Ready)
			{
				if (<check>P.Invoke(token))
				{
					Matched = true;
					return false;
				}
				return true;
			}
			return false;
		}
	}
	public class TokenWaiter : IWaiter
	{
		[CompilerGenerated]
		private Func<Token, bool> <check>P;

		[CompilerGenerated]
		private bool <waitForReady>P;

		[field: CompilerGenerated]
		public bool Matched
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public bool Ready
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		public TokenWaiter(Func<Token, bool> check, bool waitForReady = false)
		{
			<check>P = check;
			<waitForReady>P = waitForReady;
			Ready = !<waitForReady>P;
			base..ctor();
		}

		public void Reset()
		{
			Matched = false;
			Ready = !<waitForReady>P;
		}

		public void SetReady()
		{
			Ready = true;
		}

		public bool Check(Token token)
		{
			if (!Matched && Ready && <check>P.Invoke(token))
			{
				Matched = true;
				return true;
			}
			return false;
		}
	}
}
namespace GDWeave.Godot
{
	public enum BuiltinFunction : uint
	{
		MathSin,
		MathCos,
		MathTan,
		MathSinh,
		MathCosh,
		MathTanh,
		MathAsin,
		MathAcos,
		MathAtan,
		MathAtan2,
		MathSqrt,
		MathFmod,
		MathFposmod,
		MathPosmod,
		MathFloor,
		MathCeil,
		MathRound,
		MathAbs,
		MathSign,
		MathPow,
		MathLog,
		MathExp,
		MathIsnan,
		MathIsinf,
		MathIsequalapprox,
		MathIszeroapprox,
		MathEase,
		MathDecimals,
		MathStepDecimals,
		MathStepify,
		MathLerp,
		MathLerpAngle,
		MathInverseLerp,
		MathRangeLerp,
		MathSmoothstep,
		MathMoveToward,
		MathDectime,
		MathRandomize,
		MathRand,
		MathRandf,
		MathRandom,
		MathSeed,
		MathRandseed,
		MathDeg2Rad,
		MathRad2Deg,
		MathLinear2Db,
		MathDb2Linear,
		MathPolar2Cartesian,
		MathCartesian2Polar,
		MathWrap,
		MathWrapf,
		LogicMax,
		LogicMin,
		LogicClamp,
		LogicNearestPo2,
		ObjWeakref,
		FuncFuncref,
		TypeConvert,
		TypeOf,
		TypeExists,
		TextChar,
		TextOrd,
		TextStr,
		TextPrint,
		TextPrintTabbed,
		TextPrintSpaced,
		TextPrinterr,
		TextPrintraw,
		TextPrintDebug,
		PushError,
		PushWarning,
		VarToStr,
		StrToVar,
		VarToBytes,
		BytesToVar,
		GenRange,
		ResourceLoad,
		Inst2Dict,
		Dict2Inst,
		ValidateJson,
		ParseJson,
		ToJson,
		Hash,
		Color8,
		Colorn,
		PrintStack,
		GetStack,
		InstanceFromId,
		Len,
		IsInstanceValid,
		DeepEqual,
		FuncMax
	}
	public class GodotScriptFile
	{
		public const uint Magic = 1129530439u;

		public const uint Version = 13u;

		public const byte UselessXorKey = 182;

		public const uint TokenLineMask = 16777215u;

		public List<string> Identifiers = new List<string>();

		public List<Variant> Constants = new List<Variant>();

		public List<ValueTuple<uint, uint>> Lines = new List<ValueTuple<uint, uint>>();

		public List<Token> Tokens = new List<Token>();

		public GodotScriptFile(BinaryReader br)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			if (br.ReadUInt32() != 1129530439)
			{
				throw new InvalidDataException("Invalid file header");
			}
			if (br.ReadUInt32() != 13)
			{
				throw new InvalidDataException("Invalid file version");
			}
			uint num = br.ReadUInt32();
			uint num2 = br.ReadUInt32();
			uint num3 = br.ReadUInt32();
			uint num4 = br.ReadUInt32();
			for (int i = 0; i < num; i++)
			{
				uint num5 = br.ReadUInt32();
				byte[] array = br.ReadBytes((int)num5);
				for (int j = 0; j < num5; j++)
				{
					array[j] ^= 182;
				}
				string str = Encoding.UTF8.GetString(array);
				MemoryUtils.TrimNullTerminator(ref str);
				Identifiers.Add(str);
			}
			for (int k = 0; k < num2; k++)
			{
				Variant variant = VariantParser.Read(br);
				Constants.Add(variant);
			}
			for (int l = 0; l < num3; l++)
			{
				uint num6 = br.ReadUInt32();
				uint num7 = br.ReadUInt32();
				Lines.Add(new ValueTuple<uint, uint>(num6, num7));
			}
			for (int m = 0; m < num4; m++)
			{
				Tokens.Add(TokenParser.Read(br));
			}
		}

		public void Write(BinaryWriter bw)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: 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_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			bw.Write(1129530439u);
			bw.Write(13u);
			bw.Write(Identifiers.Count);
			bw.Write(Constants.Count);
			bw.Write(Lines.Count);
			bw.Write(Tokens.Count);
			Enumerator<string> enumerator = Identifiers.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					string current = enumerator.Current;
					byte[] bytes = Encoding.UTF8.GetBytes(current + "\0");
					int num = 4 - bytes.Length % 4;
					if (num == 4)
					{
						num = 0;
					}
					for (int i = 0; i < bytes.Length; i++)
					{
						bytes[i] ^= 182;
					}
					bw.Write((uint)(bytes.Length + num));
					bw.Write(bytes);
					if (num > 0)
					{
						bw.Write(new byte[num]);
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator).Dispose();
			}
			Enumerator<Variant> enumerator2 = Constants.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					Variant current2 = enumerator2.Current;
					VariantParser.Write(bw, current2);
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator2).Dispose();
			}
			Enumerator<ValueTuple<uint, uint>> enumerator3 = Lines.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					ValueTuple<uint, uint> current3 = enumerator3.Current;
					uint item = current3.Item1;
					uint item2 = current3.Item2;
					bw.Write(item);
					bw.Write(item2);
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator3).Dispose();
			}
			Enumerator<Token> enumerator4 = Tokens.GetEnumerator();
			try
			{
				while (enumerator4.MoveNext())
				{
					Token current4 = enumerator4.Current;
					TokenParser.Write(bw, current4);
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator4).Dispose();
			}
		}
	}
	public class Token
	{
		public TokenType Type;

		public uint? AssociatedData;

		public Token(TokenType type, uint? associatedData = null)
		{
			Type = type;
			AssociatedData = associatedData;
		}

		public virtual string ToString()
		{
			return $"Token({Type}, {AssociatedData})";
		}
	}
	[RequiredMember]
	public class ConstantToken : Token
	{
		[RequiredMember]
		public Variant Value;

		[SetsRequiredMembers]
		public ConstantToken(Variant value)
			: base(TokenType.Constant)
		{
			Value = value;
		}

		[SetsRequiredMembers]
		public ConstantToken(TokenType type, uint? associatedData, Variant value)
			: base(type, associatedData)
		{
			Value = value;
		}

		public override string ToString()
		{
			return $"ConstantToken({Type}, {AssociatedData}, {Value})";
		}
	}
	[RequiredMember]
	public class IdentifierToken : Token
	{
		[RequiredMember]
		public string Name;

		[SetsRequiredMembers]
		public IdentifierToken(string name)
			: base(TokenType.Identifier)
		{
			Name = name;
		}

		[SetsRequiredMembers]
		public IdentifierToken(TokenType type, uint? associatedData, string name)
			: base(type, associatedData)
		{
			Name = name;
		}

		public override string ToString()
		{
			return $"IdentifierToken({Type}, {AssociatedData}, {Name})";
		}
	}
	public class TokenParser
	{
		public const int TokenByteMask = 128;

		public const int TokenBits = 8;

		public const int TokenMask = 255;

		public static Token Read(BinaryReader br)
		{
			byte b = br.ReadByte();
			if ((b & 0x80u) != 0)
			{
				br.BaseStream.Seek(-1L, (SeekOrigin)1);
				int num = (int)(br.ReadUInt32() & -129);
				TokenType type = (TokenType)(num & 0xFF);
				uint num2 = (uint)num >> 8;
				return new Token(type, num2);
			}
			return new Token((TokenType)b);
		}

		public static void Write(BinaryWriter bw, Token token)
		{
			if (token.AssociatedData.HasValue)
			{
				byte[] bytes = BitConverter.GetBytes((uint)token.Type | (token.AssociatedData.Value << 8) | 0x80u);
				for (int i = 0; i < 4; i++)
				{
					bw.Write(bytes[i]);
				}
			}
			else
			{
				bw.Write((byte)token.Type);
			}
		}
	}
	public enum TokenType
	{
		Empty,
		Identifier,
		Constant,
		Self,
		BuiltInType,
		BuiltInFunc,
		OpIn,
		OpEqual,
		OpNotEqual,
		OpLess,
		OpLessEqual,
		OpGreater,
		OpGreaterEqual,
		OpAnd,