using System;
using System.Buffers.Binary;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using AIGraph;
using Agents;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.BounceFeatures.DeathLink;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.MessageLog.Messages;
using Archipelago.MultiClient.Net.MessageLog.Parts;
using Archipelago.MultiClient.Net.Models;
using Archipelago.MultiClient.Net.Packets;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BoosterImplants;
using CellMenu;
using ChainedPuzzles;
using Clonesoft.Json;
using Clonesoft.Json.Converters;
using Clonesoft.Json.Serialization;
using DropServer.BoosterImplants;
using Enemies;
using GameData;
using Gear;
using Globals;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Threading;
using Il2CppSystem.Threading.Tasks;
using LevelGeneration;
using Localization;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Linq;
using Player;
using ReTFO.Archipelago.Features;
using ReTFO.Archipelago.Features.EventHandlers;
using ReTFO.Archipelago.Features.FloatingItems;
using ReTFO.Archipelago.Features.ObjectiveHandlers;
using ReTFO.Archipelago.Features.Pickups;
using ReTFO.Archipelago.Features.Terminals;
using ReTFO.Archipelago.FeaturesAPI;
using ReTFO.Archipelago.ModdedInstanceData;
using ReTFO.Archipelago.ModdedInstanceData.Model;
using ReTFO.Archipelago.ModdedInstanceData.Processors;
using ReTFO.Archipelago.Patches;
using ReTFO.Archipelago.Utilities;
using SNetwork;
using TMPro;
using TheArchive;
using TheArchive.Core;
using TheArchive.Core.Attributes;
using TheArchive.Core.Attributes.Feature;
using TheArchive.Core.Attributes.Feature.Members;
using TheArchive.Core.Attributes.Feature.Patches;
using TheArchive.Core.Attributes.Feature.Settings;
using TheArchive.Core.FeaturesAPI;
using TheArchive.Core.FeaturesAPI.Components;
using TheArchive.Core.FeaturesAPI.Settings;
using TheArchive.Core.Localization;
using TheArchive.Features.Dev;
using TheArchive.Interfaces;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Archipelago")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+96f81b2ca47a13e5e387023f31a849bd4d47dc50")]
[assembly: AssemblyProduct("Archipelago")]
[assembly: AssemblyTitle("Archipelago")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object? value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object? value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object? value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object? value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object? value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object? value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object? value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object? value)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 0;
	}

	void IList.Insert(int index, object? value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object? value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NativeIntegerAttribute : Attribute
	{
		public readonly bool[] TransformFlags;

		public NativeIntegerAttribute()
		{
			TransformFlags = new bool[1] { true };
		}

		public NativeIntegerAttribute(bool[] P_0)
		{
			TransformFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		private readonly string <Name>k__BackingField;

		public string Name => <Name>k__BackingField;

		public ExtensionMarkerAttribute(string name)
		{
			<Name>k__BackingField = name;
		}
	}
}
namespace ReTFO.Archipelago
{
	[ArchiveModule("RoboRyGuy.BetaArchipelago", "BetaArchipelago", "0.0.4")]
	public class ArchipelagoArchiveModule : IArchiveModule
	{
		private IArchiveLogger? m_logger;

		public ILocalizationService LocalizationService { get; set; }

		public IArchiveLogger Logger
		{
			get
			{
				return m_logger ?? throw new NullReferenceException("Module logger was not initalized!");
			}
			set
			{
				m_logger = value;
			}
		}

		public void Init()
		{
			if (!Plugin.TryGet(out Plugin plugin))
			{
				Logger.Error("Failed to find Plugin while loading Archipelago Archive Module!");
			}
			else
			{
				plugin.ArchiveModule = this;
			}
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false)]
	internal class InjectToIl2Cpp : Attribute
	{
		public Type[] InterfaceTypes;

		public InjectToIl2Cpp()
		{
			InterfaceTypes = Array.Empty<Type>();
		}

		public InjectToIl2Cpp(Type type)
		{
			InterfaceTypes = new Type[1] { type };
		}

		public InjectToIl2Cpp(Type[] types)
		{
			InterfaceTypes = types;
		}
	}
	[BepInPlugin("RoboRyGuy.BetaArchipelago", "BetaArchipelago", "0.0.4")]
	[BepInProcess("GTFO.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		public const string Name = "BetaArchipelago";

		public const string Author = "RoboRyGuy";

		public const string GUID = "RoboRyGuy.BetaArchipelago";

		public const string Version = "0.0.4";

		private static Plugin? _plugin;

		protected Harmony harmony = new Harmony("RoboRyGuy.BetaArchipelago");

		private ArchipelagoArchiveModule? m_archiveModule;

		private MidManager m_midManager = new MidManager();

		public ArchipelagoArchiveModule ArchiveModule
		{
			get
			{
				return m_archiveModule ?? (m_archiveModule = ArchiveMod.Modules.OfType<ArchipelagoArchiveModule>().First());
			}
			internal set
			{
				m_archiveModule = value;
			}
		}

		public IArchiveLogger Logger => ArchiveModule.Logger;

		public StateTracker? StateTracker { get; internal set; }

		public MidManager MidManager
		{
			get
			{
				return m_midManager;
			}
			protected set
			{
				m_midManager = value;
			}
		}

		public event Action<SNet_Replicator>? LateSetup;

		public static Plugin Get()
		{
			return TryGet() ?? throw new NullReferenceException("Tried to retrieve BetaArchipelago, but it was not loaded!");
		}

		public static Plugin? TryGet()
		{
			return _plugin ?? (_plugin = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.FirstOrDefault((KeyValuePair<string, PluginInfo> p) => p.Key == "RoboRyGuy.BetaArchipelago").Value.Instance as Plugin);
		}

		public static bool TryGet([NotNullWhen(true)] out Plugin? plugin)
		{
			plugin = TryGet();
			return plugin != null;
		}

		public override void Load()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			_plugin = this;
			harmony.PatchAll(((object)this).GetType());
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			InjectRecursive(types);
			PatchRecursive(types);
			AddProcessors(MidManager);
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(11, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("RoboRyGuy.BetaArchipelago");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is loaded!");
			}
			log.LogInfo(val);
		}

		public override bool Unload()
		{
			harmony.UnpatchSelf();
			return true;
		}

		private void InjectRecursive(Type[] types)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			foreach (Type type in types)
			{
				InjectToIl2Cpp customAttribute = type.GetCustomAttribute<InjectToIl2Cpp>();
				if (customAttribute != null)
				{
					if (type.IsAssignableTo(typeof(Il2CppObjectBase)))
					{
						RegisterTypeOptions val = new RegisterTypeOptions();
						val.set_Interfaces(Il2CppInterfaceCollection.op_Implicit(customAttribute.InterfaceTypes));
						RegisterTypeOptions val2 = val;
						ClassInjector.RegisterTypeInIl2Cpp(type, val2);
					}
					InjectRecursive(type.GetNestedTypes(AccessTools.all));
				}
			}
		}

		private void PatchRecursive(Type[] types)
		{
			foreach (Type type in types)
			{
				if (((MemberInfo)type).GetCustomAttribute<HarmonyPatch>() != null)
				{
					harmony.PatchAll(type);
					PatchRecursive(type.GetNestedTypes(AccessTools.all));
				}
			}
		}

		public static void AddProcessors(MidManager midManager)
		{
			Expedition.Processor processor = new Expedition.Processor().SubscribedTo(midManager.GetProcessor<Game.Data>());
			midManager.RegisterProcessor(processor);
			Layer.Processor processor2 = new Layer.Processor().SubscribedTo(processor);
			midManager.RegisterProcessor(processor2);
			Zone.Processor processor3 = new Zone.Processor().SubscribedTo(processor2);
			midManager.RegisterProcessor(processor3);
			Terminal.Processor processor4 = new Terminal.Processor().SubscribedTo(processor3);
			midManager.RegisterProcessor(processor4);
			Objective.Processor processor5 = new Objective.Processor().SubscribedTo(processor2);
			midManager.RegisterProcessor(processor5);
			Event.Processor processor6 = new Event.Processor();
			midManager.RegisterProcessor(processor6);
		}

		internal void InvokeLateSetup(SNet_Replicator replicator)
		{
			this.LateSetup?.Invoke(replicator);
		}

		[HarmonyPatch(typeof(SNet_Replication), "RecallBytes")]
		[HarmonyPrefix]
		public static void PreRecallBytes(SNet_Replication __instance, Il2CppStructArray<byte> bytes, uint size)
		{
		}
	}
}
namespace ReTFO.Archipelago.Utilities
{
	public class AsyncItemSpawnWrapper
	{
		public ISyncedItem? Item { get; private set; }

		private event Action<ISyncedItem>? OnItemSpawned;

		public void AddSpawnCallback(Action<ISyncedItem> action)
		{
			OnItemSpawned += action;
			if (Item != null)
			{
				this.OnItemSpawned(Item);
			}
		}

		public void QueueDespawn()
		{
			AddSpawnCallback(Despawn);
			static void Despawn(ISyncedItem item)
			{
				((Il2CppObjectBase)item).Cast<Item>().ReplicationWrapper.Replicator.Despawn();
			}
		}

		public void OnSpawn(ISyncedItem item, PlayerAgent _)
		{
			Item = item;
			this.OnItemSpawned?.Invoke(item);
		}
	}
	public sealed class IdConverter : JsonConverter
	{
		public override bool CanRead => false;

		public override bool CanWrite => true;

		public override bool CanConvert(Type objectType)
		{
			if (objectType.IsAssignableTo(typeof(IId)))
			{
				return true;
			}
			Type[] interfaces = objectType.GetInterfaces();
			foreach (Type type in interfaces)
			{
				if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
				{
					Type type2 = type.GetGenericArguments()[0];
					if (type2.IsAssignableTo(typeof(IId)))
					{
						return true;
					}
				}
			}
			return false;
		}

		public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (value is IId id)
			{
				serializer.Serialize(writer, (object)id.AsId);
				return;
			}
			if (value is IEnumerable source)
			{
				List<long> list = (from IId i in source
					select i.AsId).ToList();
				serializer.Serialize(writer, (object)list);
				return;
			}
			throw new JsonException("IdConverter cannot convert type " + value?.GetType().FullName);
		}

		public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
		{
			throw new NotImplementedException("This converter cannot read.");
		}
	}
	public interface IId
	{
		long AsId { get; init; }
	}
	public interface IIndex
	{
		int AsIndex { get; init; }
	}
	public interface IKeyed<T> where T : IComparable<T>, IEquatable<T>
	{
		T Key { get; }
	}
	[InjectToIl2Cpp]
	public class Il2CppAction : Object
	{
		public Action? WrappedAction;

		public Il2CppAction(Action action)
			: base(ClassInjector.DerivedConstructorPointer<Il2CppAction>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
			WrappedAction = action;
		}

		public Il2CppAction(IntPtr pointer)
			: base(pointer)
		{
		}

		public void Action()
		{
			if (WrappedAction != null)
			{
				WrappedAction();
			}
		}

		public static implicit operator Action(Il2CppAction self)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			IntPtr il2CppMethod = IL2CPP.GetIl2CppMethod(((Il2CppObjectBase)self).ObjectClass, false, "Action", typeof(void).FullName, Array.Empty<string>());
			return new Action((Object)(object)self, il2CppMethod);
		}
	}
	[InjectToIl2Cpp]
	public class Il2CppAction_int : Object
	{
		public Action<int>? WrappedAction;

		public Il2CppAction_int(Action<int> action)
			: base(ClassInjector.DerivedConstructorPointer<Il2CppAction_int>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
			WrappedAction = action;
		}

		public Il2CppAction_int(IntPtr pointer)
			: base(pointer)
		{
		}

		public void Action(int value)
		{
			if (WrappedAction != null)
			{
				WrappedAction(value);
			}
		}

		public static implicit operator Action<int>(Il2CppAction_int self)
		{
			IntPtr il2CppMethod = IL2CPP.GetIl2CppMethod(((Il2CppObjectBase)self).ObjectClass, false, "Action", typeof(void).FullName, new string[1] { typeof(int).FullName });
			return new Action<int>((Object)(object)self, il2CppMethod);
		}
	}
	[InjectToIl2Cpp(typeof(IEnumerable))]
	public class Il2CppEnumerable : Object
	{
		private IEnumerable? wrappedEnumerable;

		public Il2CppEnumerable(IntPtr ptr)
			: base(ptr)
		{
		}

		public Il2CppEnumerable(IEnumerable enumerable)
			: base(ClassInjector.DerivedConstructorPointer<Il2CppEnumerable>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
			wrappedEnumerable = enumerable;
		}

		public IEnumerator GetEnumerator()
		{
			IEnumerator enumerator = wrappedEnumerable?.GetEnumerator() ?? Enumerable.Empty<object>().GetEnumerator();
			IEnumerator val = (IEnumerator)((enumerator is IEnumerator) ? enumerator : null);
			if (val != null)
			{
				return val;
			}
			return new Il2CppEnumerator(enumerator);
		}

		public static implicit operator IEnumerable(Il2CppEnumerable enumerable)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return new IEnumerable(((Il2CppObjectBase)enumerable).Pointer);
		}
	}
	[InjectToIl2Cpp(typeof(IEnumerator))]
	public class Il2CppEnumerator : Object
	{
		private IEnumerator? wrappedEnumerator;

		public Object Current
		{
			get
			{
				object obj = wrappedEnumerator?.Current;
				return (Object)((obj is Object) ? obj : null);
			}
		}

		public Il2CppEnumerator(IntPtr ptr)
			: base(ptr)
		{
		}

		public Il2CppEnumerator(IEnumerator enumerator)
			: base(ClassInjector.DerivedConstructorPointer<Il2CppEnumerator>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
			wrappedEnumerator = enumerator;
		}

		public bool MoveNext()
		{
			return wrappedEnumerator?.MoveNext() ?? false;
		}

		public void Reset()
		{
			wrappedEnumerator?.Reset();
		}

		public static implicit operator IEnumerator(Il2CppEnumerator enumerable)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			return new IEnumerator(((Il2CppObjectBase)enumerable).Pointer);
		}
	}
	[InjectToIl2Cpp]
	public class Il2CppFunc_string : Object
	{
		public Func<string>? WrappedFunc;

		public Il2CppFunc_string(Func<string> action)
			: base(ClassInjector.DerivedConstructorPointer<Il2CppFunc_string>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
			WrappedFunc = action;
		}

		public Il2CppFunc_string(IntPtr pointer)
			: base(pointer)
		{
		}

		public string Func()
		{
			if (WrappedFunc != null)
			{
				return WrappedFunc();
			}
			return null;
		}

		public static implicit operator Func<string>(Il2CppFunc_string self)
		{
			IntPtr il2CppMethod = IL2CPP.GetIl2CppMethod(((Il2CppObjectBase)self).ObjectClass, false, "Func", typeof(string).FullName, Array.Empty<string>());
			return new Func<string>((Object)(object)self, il2CppMethod);
		}
	}
	public static class Il2CppListIter
	{
		[CompilerGenerated]
		private sealed class <Iter>d__0<T> : IEnumerable<T>, IEnumerable, IEnumerator<T>, IEnumerator, IDisposable where T : notnull
		{
			private int <>1__state;

			private T <>2__current;

			private int <>l__initialThreadId;

			private List<T> source;

			public List<T> <>3__source;

			private Enumerator<T> <>7__wrap1;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
				}
				else
				{
					<>1__state = -1;
					if (source == null)
					{
						goto IL_0069;
					}
					<>7__wrap1 = source.GetEnumerator();
				}
				if (<>7__wrap1.MoveNext())
				{
					T current = <>7__wrap1.Current;
					<>2__current = current;
					<>1__state = 1;
					return true;
				}
				<>7__wrap1 = null;
				goto IL_0069;
				IL_0069:
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				<Iter>d__0<T> <Iter>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Iter>d__ = this;
				}
				else
				{
					<Iter>d__ = new <Iter>d__0<T>(0);
				}
				<Iter>d__.source = <>3__source;
				return <Iter>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<T>)this).GetEnumerator();
			}
		}

		[IteratorStateMachine(typeof(<Iter>d__0<>))]
		public static IEnumerable<T> Iter<T>(this List<T>? source)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Iter>d__0<T>(-2)
			{
				<>3__source = source
			};
		}

		public static bool Any<T>(this List<T>? source)
		{
			return source.Iter<T>().Any();
		}

		public static bool Any<T>(this List<T> source, Func<T, bool> predicate)
		{
			return source.Iter<T>().Any(predicate);
		}

		public static T First<T>(this List<T> source)
		{
			return source.Iter<T>().First();
		}

		public static T First<T>(this List<T> source, Func<T, bool> predicate)
		{
			return source.Iter<T>().First(predicate);
		}

		public static T? FirstOrDefault<T>(this List<T> source, Func<T, bool> predicate)
		{
			return source.Iter<T>().FirstOrDefault(predicate);
		}

		public static T? FirstOrDefault<T>(this List<T> source)
		{
			return source.Iter<T>().FirstOrDefault();
		}

		public static IEnumerable<U> Select<T, U>(this List<T> source, Func<T, U> func)
		{
			return source.Iter<T>().Select(func);
		}

		public static IEnumerable<U> SelectMany<T, U>(this List<T> source, Func<T, IEnumerable<U>> func)
		{
			return source.Iter<T>().SelectMany(func);
		}

		public static IEnumerable<T> Skip<T>(this List<T> source, int count)
		{
			return source.Iter<T>().Skip(count);
		}

		public static T[] ToArray<T>(this List<T> source)
		{
			return source.Iter<T>().ToArray();
		}

		public static List<T> ToList<T>(this List<T> source)
		{
			return source.Iter<T>().ToList();
		}

		public static IEnumerable<T> Where<T>(this List<T> source, Func<T, bool> predicate)
		{
			return source.Iter<T>().Where(predicate);
		}
	}
	public static class Il2CppQueueIter
	{
		public static IEnumerable<T> Iter<T>(this Queue<T> queue)
		{
			Queue<T> queue2 = queue;
			return from i in Enumerable.Range(queue2._head, queue2._size)
				select queue2._array[i];
		}

		public static T FromEnd<T>(this Queue<T> queue, int indexFromEnd = 0)
		{
			return queue._array[queue._head + queue._size - 1 - indexFromEnd];
		}
	}
	public sealed class InlineConverter : JsonConverter
	{
		public override bool CanRead => false;

		public override bool CanWrite => true;

		public Type[] TargetTypes { get; set; }

		public Type[] InlinedTypes { get; set; }

		public InlineConverter(Type[] targetTypes, Type[] inlinedTypes)
		{
			TargetTypes = targetTypes;
			InlinedTypes = inlinedTypes;
		}

		public override bool CanConvert(Type objectType)
		{
			Type objectType2 = objectType;
			if (!TargetTypes.Any((Type t) => t.IsAssignableFrom(objectType2)))
			{
				return InlinedTypes.Any((Type t) => t.IsAssignableFrom(objectType2));
			}
			return true;
		}

		public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			object value2 = value;
			bool flag = (int)writer.WriteState == 2;
			if (value2 == null)
			{
				if (!flag)
				{
					writer.WriteNull();
				}
				return;
			}
			bool flag2 = TargetTypes.Any((Type t) => t.IsAssignableFrom(value2.GetType()));
			JsonObjectContract val = (JsonObjectContract)serializer.ContractResolver.ResolveContract(value2.GetType());
			if (!flag)
			{
				writer.WriteStartObject();
			}
			try
			{
				foreach (JsonProperty property in (Collection<JsonProperty>)(object)val.Properties)
				{
					if (!property.Ignored && property.Readable)
					{
						if (!flag2 || !InlinedTypes.Any((Type t) => t.IsAssignableFrom(property.PropertyType)))
						{
							writer.WritePropertyName(property.PropertyName);
						}
						serializer.Serialize(writer, property.ValueProvider.GetValue(value2));
					}
				}
			}
			finally
			{
				if (!flag)
				{
					writer.WriteEndObject();
				}
			}
		}

		public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
		{
			throw new NotSupportedException("This converter cannot read.");
		}
	}
	public interface INullable
	{
		bool IsNull { get; }
	}
	public static class LinqUtils
	{
		[CompilerGenerated]
		private sealed class <TakeLooped>d__0<T> : IEnumerable<T>, IEnumerable, IEnumerator<T>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private T <>2__current;

			private int <>l__initialThreadId;

			private int count;

			public int <>3__count;

			private IEnumerable<T> source;

			public IEnumerable<T> <>3__source;

			private IReadOnlyList<T> <cache>5__2;

			private List<T> <mutableCache>5__3;

			private IEnumerator<T> <>7__wrap3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<cache>5__2 = null;
				<mutableCache>5__3 = null;
				<>7__wrap3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (count < 0)
						{
							throw new ArgumentException("Count cannot be negative");
						}
						if (count == 0)
						{
							return false;
						}
						<cache>5__2 = source as IReadOnlyList<T>;
						if (<cache>5__2 == null)
						{
							<mutableCache>5__3 = new List<T>();
							<>7__wrap3 = source.GetEnumerator();
							<>1__state = -3;
							goto IL_00d4;
						}
						goto IL_0160;
					case 1:
						<>1__state = -3;
						if (--count != 0)
						{
							goto IL_00d4;
						}
						goto IL_00e1;
					case 2:
						{
							<>1__state = -4;
							goto IL_0146;
						}
						IL_00d4:
						if (<>7__wrap3.MoveNext())
						{
							T current = <>7__wrap3.Current;
							<mutableCache>5__3.Add(current);
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
						goto IL_00e1;
						IL_00e1:
						<>m__Finally1();
						<>7__wrap3 = null;
						<cache>5__2 = <mutableCache>5__3;
						<mutableCache>5__3 = null;
						goto IL_0160;
						IL_0160:
						if (count-- > 0)
						{
							<>7__wrap3 = <cache>5__2.GetEnumerator();
							<>1__state = -4;
							goto IL_0146;
						}
						return false;
						IL_0146:
						if (<>7__wrap3.MoveNext())
						{
							T current2 = <>7__wrap3.Current;
							<>2__current = current2;
							<>1__state = 2;
							return true;
						}
						<>m__Finally2();
						<>7__wrap3 = null;
						goto IL_0160;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap3 != null)
				{
					<>7__wrap3.Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -1;
				if (<>7__wrap3 != null)
				{
					<>7__wrap3.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				<TakeLooped>d__0<T> <TakeLooped>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<TakeLooped>d__ = this;
				}
				else
				{
					<TakeLooped>d__ = new <TakeLooped>d__0<T>(0);
				}
				<TakeLooped>d__.source = <>3__source;
				<TakeLooped>d__.count = <>3__count;
				return <TakeLooped>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<T>)this).GetEnumerator();
			}
		}

		[IteratorStateMachine(typeof(<TakeLooped>d__0<>))]
		public static IEnumerable<T> TakeLooped<T>(this IEnumerable<T> source, int count)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TakeLooped>d__0<T>(-2)
			{
				<>3__source = source,
				<>3__count = count
			};
		}
	}
	public sealed class ListConverter<T> : JsonConverter
	{
		private class ThisWriter : TextWriter
		{
			private JsonWriter writer;

			public override Encoding Encoding => System.Text.Encoding.Default;

			public ThisWriter(JsonWriter source)
			{
				writer = source;
			}

			public override void Write(char value)
			{
				writer.WriteRaw(new string(value, 1));
			}

			public override void Write(string? value)
			{
				writer.WriteRaw(value);
			}
		}

		public override bool CanRead => false;

		public override bool CanWrite => true;

		public int MaxPerLine { get; set; }

		public ListConverter(int maxPerLine = 20)
		{
			MaxPerLine = maxPerLine;
		}

		public override bool CanConvert(Type objectType)
		{
			return typeof(IEnumerable<T>).IsAssignableFrom(objectType);
		}

		public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			if (!(value is IEnumerable<T> source))
			{
				throw new ArgumentException("Expected value to be of type " + typeof(List<T>).FullName + ".", "value");
			}
			if ((int)writer.Formatting != 1)
			{
				throw new NotSupportedException("ListConverter was either used on a nested conerted list or during an unformatted serialization. Neither are supported!");
			}
			List<T[]> list = source.Chunk(MaxPerLine).ToList();
			ThisWriter thisWriter = new ThisWriter(writer);
			if (list.Count == 0)
			{
				writer.WriteStartArray();
				writer.WriteEndArray();
				return;
			}
			if (list.Count == 1)
			{
				writer.WriteStartArray();
				writer.WriteRaw(" ");
				writer.Formatting = (Formatting)0;
				serializer.Serialize((TextWriter)thisWriter, (object)list.First().First());
				foreach (T item in list.First().Skip(1))
				{
					writer.WriteRaw(", ");
					serializer.Serialize((TextWriter)thisWriter, (object)item);
				}
				writer.WriteEndArray();
				writer.Formatting = (Formatting)1;
				return;
			}
			writer.WriteStartArray();
			foreach (T[] item2 in list)
			{
				serializer.Serialize(writer, (object)item2.First());
				writer.Formatting = (Formatting)0;
				foreach (T item3 in item2.Skip(1))
				{
					writer.WriteRaw(", ");
					serializer.Serialize((TextWriter)thisWriter, (object)item3);
				}
				writer.Formatting = (Formatting)1;
			}
			writer.WriteEndArray();
		}

		public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
		{
			throw new NotImplementedException("This converter cannot read.");
		}
	}
	public class ReadOnlyListDict<I, T> : IReadOnlyDictionary<I, T>, IEnumerable<KeyValuePair<I, T>>, IEnumerable, IReadOnlyCollection<KeyValuePair<I, T>> where I : IIndex, new()
	{
		private readonly IReadOnlyList<T> m_list;

		public T this[I key] => m_list[key.AsIndex];

		public IEnumerable<I> Keys => from i in Enumerable.Range(0, m_list.Count)
			select new I
			{
				AsIndex = i
			};

		public IEnumerable<T> Values => m_list;

		public int Count => m_list.Count;

		public bool IsReadOnly => true;

		public ReadOnlyListDict(IReadOnlyList<T> source)
		{
			m_list = source;
		}

		public bool ContainsKey(I key)
		{
			if (key.AsIndex >= 0)
			{
				return key.AsIndex < m_list.Count;
			}
			return false;
		}

		public IEnumerator<KeyValuePair<I, T>> GetEnumerator()
		{
			return m_list.Select((T v, int i) => new KeyValuePair<I, T>(new I
			{
				AsIndex = i
			}, v)).GetEnumerator();
		}

		public bool TryGetValue(I key, [MaybeNullWhen(false)] out T value)
		{
			if (!ContainsKey(key))
			{
				value = default(T);
				return false;
			}
			value = m_list[key.AsIndex];
			return true;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public static class SerializationHelpers
	{
		public struct Spannable<T>
		{
			public T[] Values { get; init; }

			public int Start { get; init; }

			public int Length { get; init; }

			public Spannable(T[] values, int start, int length)
			{
				Values = values;
				Start = start;
				Length = length;
			}

			public Span<T> AsSpan()
			{
				return new Span<T>(Values, Start, Length);
			}
		}

		public static int CalcLengthSize(int value)
		{
			if (value != 0)
			{
				return Calc7BitEncodedSize(value);
			}
			return 1;
		}

		public static void WriteLength(Il2CppStructArray<byte> bytes, ref int index, int value)
		{
			Write7BitEncodedLong(bytes, ref index, value);
		}

		public static int ReadLength(Il2CppStructArray<byte> bytes, ref int index)
		{
			return checked((int)Read7BitEncodedLong(bytes, ref index));
		}

		public static int Calc7BitEncodedSize(long value)
		{
			return Calc7BitEncodedSize((ulong)value);
		}

		public static int Calc7BitEncodedSize(ulong value)
		{
			if ((value & 0xFF00000000000000uL) != 0L)
			{
				return 9;
			}
			if ((value & 0xFE000000000000L) != 0L)
			{
				return 8;
			}
			if ((value & 0x1FC0000000000L) != 0L)
			{
				return 7;
			}
			if ((value & 0x3F800000000L) != 0L)
			{
				return 6;
			}
			if ((value & 0x7F0000000L) != 0L)
			{
				return 5;
			}
			if ((value & 0xFE00000) != 0L)
			{
				return 4;
			}
			if ((value & 0x1FC000) != 0L)
			{
				return 3;
			}
			if ((value & 0x3F80) != 0L)
			{
				return 2;
			}
			return 1;
		}

		public static int Calc7BitEncodedArraySize(ICollection<long> values)
		{
			return Calc7BitEncodedArraySize(values.Cast<ulong>(), values.Count);
		}

		public static int Calc7BitEncodedArraySize(ICollection<ulong> values)
		{
			return Calc7BitEncodedArraySize(values, values.Count);
		}

		public static int Calc7BitEncodedArraySize(IEnumerable<long> values, int count)
		{
			return Calc7BitEncodedArraySize(values.Cast<ulong>(), count);
		}

		public static int Calc7BitEncodedArraySize(IEnumerable<ulong> values, int count)
		{
			return Calc7BitEncodedSize(count) + values.Sum((ulong i) => Calc7BitEncodedSize(i));
		}

		public static int Calc7BitEncodedMultiArraySize(ICollection<ICollection<long>> values)
		{
			return Calc7BitEncodedMultiArraySize(values.Cast<ICollection<ulong>>(), values.Count, values.Sum((ICollection<long> arr) => arr.Count));
		}

		public static int Calc7BitEncodedMultiArraySize(ICollection<ICollection<ulong>> values)
		{
			return Calc7BitEncodedMultiArraySize(values, values.Count, values.Sum((ICollection<ulong> arr) => arr.Count));
		}

		public static int Calc7BitEncodedMultiArraySize(IEnumerable<IEnumerable<long>> values, int arrCount, int valueCount)
		{
			return Calc7BitEncodedMultiArraySize(values.Cast<IEnumerable<ulong>>(), arrCount, valueCount);
		}

		public static int Calc7BitEncodedMultiArraySize(IEnumerable<IEnumerable<ulong>> values, int arrCount, int valueCount)
		{
			arrCount = ((arrCount != 0) ? (arrCount - 1) : 0);
			return CalcLengthSize(valueCount + arrCount) + arrCount + values.Sum((IEnumerable<ulong> arr) => arr.Sum((ulong i) => Calc7BitEncodedSize(i)));
		}

		public static void Write7BitEncodedLong(Il2CppStructArray<byte> bytes, ref int index, long value)
		{
			Write7BitEncodedLong(bytes, ref index, (ulong)value);
		}

		public static void Write7BitEncodedLong(Il2CppStructArray<byte> bytes, ref int index, ulong value)
		{
			for (int i = 0; i < 9; i++)
			{
				((Il2CppArrayBase<byte>)(object)bytes)[index++] = (byte)((value & 0x7F) | 0x80);
				value >>= 7;
				if (value == 0L)
				{
					break;
				}
			}
			if (value == 0L)
			{
				int num = index - 1;
				int num2 = index - 1;
				byte b2 = (((Il2CppArrayBase<byte>)(object)bytes)[num2] = (byte)(((Il2CppArrayBase<byte>)(object)bytes)[num2] & 0x7Fu));
				((Il2CppArrayBase<byte>)(object)bytes)[num] = b2;
			}
		}

		public static long Read7BitEncodedLong(Il2CppStructArray<byte> bytes, ref int index)
		{
			return (long)Read7BitEncodedULong(bytes, ref index);
		}

		public static ulong Read7BitEncodedULong(Il2CppStructArray<byte> bytes, ref int index)
		{
			ulong num = 0uL;
			for (int i = 0; i < 56; i += 7)
			{
				byte b = ((Il2CppArrayBase<byte>)(object)bytes)[index++];
				num |= (ulong)((long)(b & 0x7F) << i);
				if ((0x80 & b) == 0)
				{
					return num;
				}
			}
			return num | ((ulong)((Il2CppArrayBase<byte>)(object)bytes)[index++] << 56);
		}

		public static void Write7BitEncodedArray(Il2CppStructArray<byte> bytes, ref int index, ICollection<long> values)
		{
			Write7BitEncodedArray(bytes, ref index, values, values.Count);
		}

		public static void Write7BitEncodedArray(Il2CppStructArray<byte> bytes, ref int index, ICollection<ulong> values)
		{
			Write7BitEncodedArray(bytes, ref index, values, values.Count);
		}

		public static void Write7BitEncodedArray(Il2CppStructArray<byte> bytes, ref int index, IEnumerable<long> values, int count)
		{
			Write7BitEncodedArray(bytes, ref index, values.Cast<ulong>(), count);
		}

		public unsafe static void Write7BitEncodedArray(Il2CppStructArray<byte> bytes, ref int index, IEnumerable<ulong> values, int count)
		{
			byte* ptr = (byte*)IntPtr.Add(((Il2CppObjectBase)bytes).Pointer, 4 * IntPtr.Size).ToPointer();
			WriteLength(bytes, ref index, count);
			foreach (ulong value in values)
			{
				Write7BitEncodedLong(bytes, ref index, value);
			}
		}

		public static long[] Read7BitEncodedArray(Il2CppStructArray<byte> bytes, ref int index)
		{
			int num = ReadLength(bytes, ref index);
			long[] array = new long[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = Read7BitEncodedLong(bytes, ref index);
			}
			return array;
		}

		public static ulong[] Read7BitEncodedUArray(Il2CppStructArray<byte> bytes, ref int index)
		{
			int num = ReadLength(bytes, ref index);
			ulong[] array = new ulong[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = Read7BitEncodedULong(bytes, ref index);
			}
			return array;
		}

		public static void Write7BitEncodedMultiArray(Il2CppStructArray<byte> bytes, ref int index, ICollection<IEnumerable<long>> values, int valuesCount)
		{
			Write7BitEncodedMultiArray(bytes, ref index, values.Cast<IEnumerable<ulong>>(), values.Count, valuesCount);
		}

		public static void Write7BitEncodedMultiArray(Il2CppStructArray<byte> bytes, ref int index, ICollection<IEnumerable<ulong>> values, int valuesCount)
		{
			Write7BitEncodedMultiArray(bytes, ref index, values, values.Count, valuesCount);
		}

		public static void Write7BitEncodedMultiArray(Il2CppStructArray<byte> bytes, ref int index, IEnumerable<IEnumerable<long>> values, int arrCount, int valuesCount)
		{
			Write7BitEncodedMultiArray(bytes, ref index, values.Cast<IEnumerable<ulong>>(), arrCount, valuesCount);
		}

		public static void Write7BitEncodedMultiArray(Il2CppStructArray<byte> bytes, ref int index, IEnumerable<IEnumerable<ulong>> values, int arrCount, int valuesCount)
		{
			Write7BitEncodedArray(bytes, ref index, values.SelectMany((IEnumerable<ulong> v) => v.Prepend(0uL)).Skip(1), valuesCount + arrCount - 1);
		}

		public static Spannable<long>[] Read7BitEncodedMultiArray(Il2CppStructArray<byte> bytes, ref int index)
		{
			long[] array = Read7BitEncodedArray(bytes, ref index);
			Spannable<long>[] array2 = new Spannable<long>[1 + array.Count((long i) => i == 0)];
			int num = 0;
			int num2 = 0;
			for (int j = 0; j < array.Length; j++)
			{
				if (array[j] == 0L)
				{
					array2[num++] = new Spannable<long>(array, num2, j - num2);
					num2 = j + 1;
				}
			}
			array2[num] = new Spannable<long>(array, num2, array.Length - num2);
			return array2;
		}

		public static Spannable<ulong>[] Read7BitEncodedMultiUArray(Il2CppStructArray<byte> bytes, ref int index)
		{
			ulong[] array = Read7BitEncodedUArray(bytes, ref index);
			Spannable<ulong>[] array2 = new Spannable<ulong>[1 + array.Count((ulong i) => i == 0)];
			int num = 0;
			int num2 = 0;
			for (int j = 0; j < array.Length; j++)
			{
				if (array[j] == 0L)
				{
					array2[num++] = new Spannable<ulong>(array, num2, j - num2);
					num2 = j + 1;
				}
			}
			return array2;
		}

		public static int CalcStringArraySize(ICollection<string> strings)
		{
			return CalcStringArraySize(strings, strings.Count);
		}

		public static int CalcStringArraySize(IEnumerable<string> strings, int arrSize)
		{
			return CalcLengthSize(arrSize) + strings.Sum((Func<string, int>)CalcStringSize);
		}

		public static int CalcStringSize(string? value)
		{
			return (value?.Length ?? 0) * 2 + 2;
		}

		public unsafe static void WriteStringArray(Il2CppStructArray<byte> bytes, ref int index, IEnumerable<string> strings)
		{
			WriteLength(bytes, ref index, strings.Count());
			byte* ptr = (byte*)IntPtr.Add(((Il2CppObjectBase)bytes).Pointer, IntPtr.Size * 4).ToPointer();
			foreach (string @string in strings)
			{
				@string.AsSpan().CopyTo(new Span<char>(ptr + index, (((Il2CppArrayBase<byte>)(object)bytes).Length - index) / 2));
				index += 2 * @string.Length;
				*(short*)(ptr + index) = 0;
				index += 2;
			}
		}

		public unsafe static void WriteString(Il2CppStructArray<byte> bytes, ref int index, string? value)
		{
			byte* ptr = (byte*)IntPtr.Add(((Il2CppObjectBase)bytes).Pointer, IntPtr.Size * 4).ToPointer();
			if (value == null)
			{
				value = string.Empty;
			}
			value.AsSpan().CopyTo(new Span<char>(ptr + index, (((Il2CppArrayBase<byte>)(object)bytes).Length - index) / 2));
			index += 2 * value.Length;
			*(short*)(ptr + index) = 0;
			index += 2;
		}

		public unsafe static string[] ReadStringArray(Il2CppStructArray<byte> bytes, ref int index)
		{
			byte* ptr = (byte*)IntPtr.Add(((Il2CppObjectBase)bytes).Pointer, IntPtr.Size * 4).ToPointer();
			int num = ReadLength(bytes, ref index);
			string[] array = new string[num];
			for (num = 0; num < array.Length; num++)
			{
				int num2 = index;
				while (*(ushort*)(ptr + index) != 0)
				{
					index += 2;
				}
				array[num] = new Span<char>(ptr + num2, (index - num2) / 2).ToString();
				index += 2;
			}
			return array;
		}

		public unsafe static string? ReadString(Il2CppStructArray<byte> bytes, ref int index)
		{
			byte* ptr = (byte*)IntPtr.Add(((Il2CppObjectBase)bytes).Pointer, IntPtr.Size * 4).ToPointer();
			int num = index;
			while (*(ushort*)(ptr + index) != 0)
			{
				index += 2;
			}
			string result = ((index <= num) ? null : new Span<char>(ptr + num, (index - num) / 2).ToString());
			index += 2;
			return result;
		}
	}
	public static class SetHelpers
	{
		[CompilerGenerated]
		private sealed class <<TryIntersect>g__intersectHelper|0_0>d<T> : IEnumerable<T>, IEnumerable, IEnumerator<T>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private T <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<T> other;

			public IEnumerable<T> <>3__other;

			private IReadOnlySet<T> self;

			public IReadOnlySet<T> <>3__self;

			private IEnumerator<T> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <<TryIntersect>g__intersectHelper|0_0>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = other.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						T current = <>7__wrap1.Current;
						if (self.Contains(current))
						{
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

			[DebuggerHidden]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				<<TryIntersect>g__intersectHelper|0_0>d<T> <<TryIntersect>g__intersectHelper|0_0>d;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<<TryIntersect>g__intersectHelper|0_0>d = this;
				}
				else
				{
					<<TryIntersect>g__intersectHelper|0_0>d = new <<TryIntersect>g__intersectHelper|0_0>d<T>(0);
				}
				<<TryIntersect>g__intersectHelper|0_0>d.self = <>3__self;
				<<TryIntersect>g__intersectHelper|0_0>d.other = <>3__other;
				return <<TryIntersect>g__intersectHelper|0_0>d;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<T>)this).GetEnumerator();
			}
		}

		public static bool TryIntersect<T>(this IReadOnlySet<T> self, IEnumerable<T> other, out IEnumerable<T> intersection)
		{
			intersection = intersectHelper(self, other);
			return intersection.Any();
			[IteratorStateMachine(typeof(<<TryIntersect>g__intersectHelper|0_0>d<>))]
			static IEnumerable<T> intersectHelper(IReadOnlySet<T> self, IEnumerable<T> other)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<TryIntersect>g__intersectHelper|0_0>d<T>(-2)
				{
					<>3__self = self,
					<>3__other = other
				};
			}
		}
	}
	public sealed class SimplifiedListConverter<T> : JsonConverter
	{
		public override bool CanRead => false;

		public override bool CanWrite => true;

		public int MaxPerLine { get; set; }

		public SimplifiedListConverter(int maxPerLine = 20)
		{
			MaxPerLine = maxPerLine;
		}

		public override bool CanConvert(Type objectType)
		{
			return typeof(IEnumerable<T>).IsAssignableFrom(objectType);
		}

		public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			if (!(value is IEnumerable<T> source))
			{
				throw new ArgumentException("Expected value to be of type " + typeof(List<T>).FullName + ".", "value");
			}
			List<T[]> list = source.Chunk(MaxPerLine).ToList();
			if (list.Count == 0)
			{
				writer.WriteStartArray();
				writer.WriteEndArray();
				return;
			}
			if (list.Count == 1)
			{
				writer.WriteStartArray();
				Formatting formatting = writer.Formatting;
				writer.Formatting = (Formatting)0;
				if (typeof(T) == typeof(string))
				{
					writer.WriteRaw(" " + string.Join(", ", from i in list.First()
						select $"\"{i}\"") + " ");
				}
				else
				{
					writer.WriteRaw(" " + string.Join(", ", from i in list.First()
						select i?.ToString()) + " ");
				}
				writer.WriteEndArray();
				writer.Formatting = formatting;
				return;
			}
			List<List<string>> list2 = ((!(typeof(T) == typeof(string))) ? list.Select((T[] set) => set.Select(delegate(T s)
			{
				object obj = s?.ToString();
				if (obj == null)
				{
					obj = "null";
				}
				return (string)obj;
			}).ToList()).ToList() : list.Select((T[] set) => set.Select((T s) => $"\"{s}\"").ToList()).ToList());
			int max = list2.Max((List<string> set) => set.Max((string s) => s.Length));
			writer.WriteStartArray();
			foreach (List<string> item in list2)
			{
				writer.WriteRawValue(string.Join(", ", item.Select((string s) => s.PadLeft(max))));
			}
			writer.WriteEndArray();
		}

		public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
		{
			throw new NotImplementedException("This converter cannot read.");
		}
	}
}
namespace ReTFO.Archipelago.Patches
{
	[HarmonyPatch(typeof(CM_SettingsInputField), "OnBtnPressAnywhere")]
	public static class AutoEnterFeatureSettings
	{
		public static void Prefix(CM_SettingsInputField __instance, ref bool __state)
		{
			__state = __instance.m_readingActive;
		}

		public static void Postfix(CM_SettingsInputField __instance, bool __state)
		{
			if (!__instance.m_readingActive && __state)
			{
				__instance.SetNewValue(__instance.m_currentValue);
			}
		}
	}
	[HarmonyPatch]
	internal static class CatchNetworkSettingsSubmenuPatch
	{
		[CompilerGenerated]
		private sealed class <TargetMethods>d__4 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private MethodBase <>2__current;

			private int <>l__initialThreadId;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = AccessTools.Constructor(typeof(SubMenu), new Type[2]
					{
						typeof(string),
						typeof(string)
					}, false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <TargetMethods>d__4(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<MethodBase>)this).GetEnumerator();
			}
		}

		public static SubMenu? NetworkSettingsSubMenu { get; set; }

		[IteratorStateMachine(typeof(<TargetMethods>d__4))]
		public static IEnumerable<MethodBase> TargetMethods()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TargetMethods>d__4(-2);
		}

		public static void Postfix(SubMenu __instance, string identifier)
		{
			StateTracker stateTracker = StateTracker.Get();
			if (((Feature)stateTracker).Identifier == identifier)
			{
				NetworkSettingsSubMenu = __instance;
			}
		}
	}
	[HarmonyPatch(typeof(GlobalPopupMessageManager), "ShowPopup")]
	public static class GlobalPopupPatch
	{
		public static void Prefix(GlobalPopupMessageManager __instance, ref PopupMessage message)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)message.PopupType == 1)
			{
				message.Header = ((Object)MainMenuGuiLayer.Current.PageRundownNew.m_currentRundownData.StorytellingData.Title).ToString();
			}
		}
	}
	[HarmonyPatch(typeof(ItemReplicationManager), "OnItemSpawn")]
	public static class InvokeItemSpawnCallbackPatch
	{
		public static void Postfix(pItemSpawnData spawnData, ItemReplicator replicator)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			int num = ItemReplicationManager.m_callBacks.FindEntry(spawnData.callbackID);
			if (num != -1 && SNet.IsMaster)
			{
				((Il2CppArrayBase<Entry<ushort, delItemCallback>>)(object)ItemReplicationManager.m_callBacks.entries)[num].value.Invoke(((Il2CppObjectBase)replicator.Item).Cast<ISyncedItem>(), (PlayerAgent)null);
				ItemReplicationManager.RemoveCallback(spawnData.callbackID);
			}
		}
	}
	[HarmonyPatch]
	internal static class ModifyRundownMenuPatch
	{
		[HarmonyPatch(typeof(CM_PageRundown_New), "Intro_RevealRundown")]
		[HarmonyAfter(new string[] { "com.dak.MTFO" })]
		public static class AddResetButtonPatch
		{
			public static void Postfix(CM_PageRundown_New __instance)
			{
				((RectTransformComp)__instance.m_matchmakeAllButton).SetVisible(true);
				__instance.m_matchmakeAllButton.SetText("<#F0F>EXIT ARCHIPELAGO</color>");
				__instance.m_matchmakeAllButton.OnBtnPressCallback = new Il2CppAction_int(delegate
				{
					StateTracker.Get().Reset();
				});
			}
		}

		[HarmonyPatch]
		public static class RevealJoinLobbyPatch
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(CM_PageRundown_New), "OnCortexDone", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(CM_PageRundown_New), "SetPageActive", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						return false;
					}
				}

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

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

				[DebuggerHidden]
				IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__0(0);
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<MethodBase>)this).GetEnumerator();
				}
			}

			[IteratorStateMachine(typeof(<TargetMethods>d__0))]
			public static IEnumerable<MethodBase> TargetMethods()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <TargetMethods>d__0(-2);
			}

			public static void Postfix(CM_PageRundown_New __instance)
			{
				__instance.m_selectionIsRevealed = true;
			}
		}

		public static CM_Item AddButton(CM_PageRundown_New __instance, float offset)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.down * offset;
			CM_Item buttonConnect = __instance.m_buttonConnect;
			GameObject val2 = Object.Instantiate<GameObject>(((Component)buttonConnect).gameObject);
			val2.transform.parent = ((Component)buttonConnect).transform.parent;
			CM_Item component = val2.GetComponent<CM_Item>();
			((RectTransformComp)component).RectTrans.anchorMin = ((RectTransformComp)buttonConnect).RectTrans.anchorMin;
			((RectTransformComp)component).RectTrans.anchorMax = ((RectTransformComp)buttonConnect).RectTrans.anchorMax;
			((Transform)((RectTransformComp)component).RectTrans).position = ((Transform)((RectTransformComp)buttonConnect).RectTrans).position + val;
			((RectTransformComp)component).Setup();
			component.SetupCMItem();
			return component;
		}

		[HarmonyPatch(typeof(CM_PageRundown_New), "Setup")]
		[HarmonyPrefix]
		public static void PreMenuSetup(CM_PageRundown_New __instance)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			CM_Item buttonConnect = __instance.m_buttonConnect;
			buttonConnect.SetText("Connect to <#F0F><i>ARCHIPELAGO</i></color>");
			buttonConnect.OnBtnPressCallback += new Il2CppAction_int(delegate
			{
				StateTracker.Get().Connect();
			});
			float offset = ((RectTransformComp)buttonConnect).GetSize().y + 25f;
			CM_Item val = AddButton(__instance, offset);
			val.SetText("Server Settings");
			val.OnBtnPressCallback += new Il2CppAction_int(delegate
			{
				MainMenuGuiLayer.Current.ChangePage((eCM_MenuPage)10, false);
				SubMenu? networkSettingsSubMenu = CatchNetworkSettingsSubmenuPatch.NetworkSettingsSubMenu;
				if (networkSettingsSubMenu != null)
				{
					networkSettingsSubMenu.Show();
				}
			});
			((Transform)((RectTransformComp)val).RectTrans).SetParent((Transform)(object)((RectTransformComp)buttonConnect).RectTrans, true);
		}

		[HarmonyPatch(typeof(CM_PageRundown_New), "Setup")]
		[HarmonyPostfix]
		public static void PostMenuSetup(CM_PageRundown_New __instance)
		{
			CM_Item buttonConnect = __instance.m_buttonConnect;
			foreach (Delegate item in (Il2CppArrayBase<Delegate>)(object)((Delegate)buttonConnect.OnBtnPressCallback).GetInvocationList())
			{
				Object target = item.Target;
				if (((target != null) ? ((Il2CppObjectBase)target).Pointer : IntPtr.Zero) == ((Il2CppObjectBase)__instance).Pointer)
				{
					buttonConnect.OnBtnPressCallback -= ((Il2CppObjectBase)item).Cast<Action<int>>();
				}
			}
			StateTracker.Get().SetupReplication();
		}
	}
	[HarmonyPatch]
	internal static class PostLoadGamedataPatch
	{
		[CompilerGenerated]
		private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private MethodBase <>2__current;

			private int <>l__initialThreadId;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = AccessTools.Method(typeof(GameDataInit), "Initialize", (Type[])null, (Type[])null);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = AccessTools.Method(typeof(GameDataInit), "ReInitialize", (Type[])null, (Type[])null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <TargetMethods>d__0(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<MethodBase>)this).GetEnumerator();
			}
		}

		[IteratorStateMachine(typeof(<TargetMethods>d__0))]
		[HarmonyTargetMethods]
		public static IEnumerable<MethodBase> TargetMethods()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TargetMethods>d__0(-2);
		}

		[HarmonyPostfix]
		public static void Postfix()
		{
			if (!Plugin.TryGet(out Plugin plugin))
			{
				throw new NotImplementedException("PostLoadGamedataPatch could not access plugin!");
			}
			plugin.MidManager.InvalidateModdedInstanceData();
			GameSetupDataBlock val = GameDataBlockBase<GameSetupDataBlock>.GetAllBlocks()[0];
			uint num = val.RundownIdsToLoad[0];
			val.RundownIdsToLoad = new List<uint>(1);
			val.RundownIdsToLoad.Add(num);
		}
	}
	[HarmonyPatch]
	[InjectToIl2Cpp]
	public static class PrivateFeatureSettingsPatch
	{
		[AttributeUsage(AttributeTargets.Property)]
		public class FSOptionallyPrivate : Attribute
		{
		}

		public interface IOptionallyPrivate
		{
			bool IsCurrentlyPrivate { get; }
		}

		[InjectToIl2Cpp(typeof(iStringInputReceiver))]
		private class WrappedCustomStringReceiver : Object
		{
			[HideFromIl2Cpp]
			public iStringInputReceiver WrappedReceiver { get; set; }

			[HideFromIl2Cpp]
			public Func<bool>? IsCurrentlyPrivate { get; set; }

			public WrappedCustomStringReceiver(IntPtr ptr)
				: base(ptr)
			{
			}

			public WrappedCustomStringReceiver(iStringInputReceiver wrappedReceiver, Func<bool>? isCurrentlyPrivate)
				: base(ClassInjector.DerivedConstructorPointer<WrappedCustomStringReceiver>())
			{
				ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
				WrappedReceiver = wrappedReceiver;
				IsCurrentlyPrivate = isCurrentlyPrivate;
			}

			public string GetStringValue(eCellSettingID setting)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return WrappedReceiver.GetStringValue(setting);
			}

			public string SetStringValue(eCellSettingID setting, string value)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return WrappedReceiver.SetStringValue(setting, value);
			}
		}

		[HarmonyPatch]
		public static class ModSettings__SettingsCreationHelper__CreateStringSetting__Patch
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

				private Type <nestedType>5__2;

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

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

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

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						Type typeFromHandle = typeof(ModSettings);
						<nestedType>5__2 = typeFromHandle.GetNestedType("SettingsCreationHelper", AccessTools.all);
						<>2__current = AccessTools.Method(<nestedType>5__2, "CreateStringSetting", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					}
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(<nestedType>5__2, "CreateNumberSetting", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						return false;
					}
				}

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

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

				[DebuggerHidden]
				IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__0(0);
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<MethodBase>)this).GetEnumerator();
				}
			}

			[IteratorStateMachine(typeof(<TargetMethods>d__0))]
			[HarmonyTargetMethods]
			public static IEnumerable<MethodBase> TargetMethods()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <TargetMethods>d__0(-2);
			}

			[HarmonyPostfix]
			public static void Postfix(FeatureSetting setting)
			{
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Expected O, but got Unknown
				FSOptionallyPrivate customAttribute = setting.Prop.GetCustomAttribute<FSOptionallyPrivate>();
				if (customAttribute == null)
				{
					return;
				}
				NumberSetting val = (NumberSetting)(object)((setting is NumberSetting) ? setting : null);
				if (val == null || !val.HasSlider)
				{
					object value = AccessTools.Property(typeof(FeatureSetting), "WrappedInstance").GetValue(setting);
					IOptionallyPrivate unwrappedInstance = value as IOptionallyPrivate;
					if (unwrappedInstance == null)
					{
						throw new NullReferenceException();
					}
					object cM_SettingsItem = setting.CM_SettingsItem;
					CM_SettingsItem val2 = ((Il2CppObjectBase)((cM_SettingsItem is Object) ? cM_SettingsItem : null)).Cast<CM_SettingsItem>();
					CM_SettingsInputField component = ((Component)val2.m_inputAlign.GetChild(val2.m_inputAlign.childCount - 1)).GetComponent<CM_SettingsInputField>();
					WrappedCustomStringReceiver wrappedCustomStringReceiver = new WrappedCustomStringReceiver(component.m_stringReceiver, () => unwrappedInstance.IsCurrentlyPrivate);
					component.m_stringReceiver = new iStringInputReceiver(((Il2CppObjectBase)wrappedCustomStringReceiver).Pointer);
				}
			}
		}

		[HarmonyPatch]
		public static class CM_SettingsInputField__Patch
		{
			[HarmonyPatch(typeof(CM_SettingsInputField), "Update")]
			[HarmonyPostfix]
			public static void PostUpdate(CM_SettingsInputField __instance)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.m_readingActive)
				{
					return;
				}
				WrappedCustomStringReceiver wrappedCustomStringReceiver = ((Il2CppObjectBase)new Object(((Il2CppObjectBase)__instance.m_stringReceiver).Pointer)).TryCast<WrappedCustomStringReceiver>();
				if (wrappedCustomStringReceiver != null)
				{
					Func<bool>? isCurrentlyPrivate = wrappedCustomStringReceiver.IsCurrentlyPrivate;
					if (isCurrentlyPrivate == null || isCurrentlyPrivate())
					{
						((TMP_Text)__instance.m_text).SetText(new string('*', ((TMP_Text)__instance.m_text).text.Length), true);
					}
					else
					{
						((TMP_Text)__instance.m_text).SetText(__instance.m_currentValue, true);
					}
				}
			}
		}
	}
}
namespace ReTFO.Archipelago.ModdedInstanceData
{
	public class MidManager
	{
		public abstract class Processor
		{
			public abstract class CallbackBase : Attribute
			{
				public abstract Type DataType { get; }

				public abstract Type DelegateType { get; }
			}

			public abstract void UntypedRegisterCallback(Delegate callback);

			public abstract void UntypedUnregisterCallback(Delegate callback);
		}

		public abstract class Processor<TData> : Processor where TData : class
		{
			[AttributeUsage(AttributeTargets.Method)]
			public class Callback : CallbackBase
			{
				public override Type DataType => typeof(TData);

				public override Type DelegateType => typeof(Delegate);
			}

			public delegate void Delegate(TData data);

			public abstract void RegisterCallback(Delegate callback);

			public override void UntypedRegisterCallback(System.Delegate callback)
			{
				if (callback is Delegate callback2)
				{
					RegisterCallback(callback2);
				}
				else
				{
					FeatureLogger.Error("Failed to register callback; callback is of wrong delegate type");
				}
			}

			public abstract void UnregisterCallback(Delegate callback);

			public override void UntypedUnregisterCallback(System.Delegate callback)
			{
				if (callback is Delegate callback2)
				{
					UnregisterCallback(callback2);
				}
				else
				{
					FeatureLogger.Error("Failed to unregister callback; callback is of wrong delegate type");
				}
			}

			public abstract void Process(TData data);

			protected virtual void RegisterStaticCallbacks()
			{
				BindingFlags bf = BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public;
				IEnumerable<MethodInfo> enumerable = from m in AppDomain.CurrentDomain.GetAssemblies().SelectMany(delegate(Assembly a)
					{
						try
						{
							return a.GetTypes();
						}
						catch (ReflectionTypeLoadException ex)
						{
							return ex.Types.OfType<Type>();
						}
					}).SelectMany((Type t) => t.GetMethods(bf))
					where m.CustomAttributes.Any((CustomAttributeData a) => a.AttributeType.IsAssignableTo(typeof(Callback)))
					select m;
				foreach (MethodInfo item in enumerable)
				{
					if (!(System.Delegate.CreateDelegate(typeof(Delegate), item) is Delegate callback))
					{
						FeatureLogger.Warning($"Failed to register callback {item.DeclaringType?.FullName}.{item.Name} to event; failed to convert to delegate type");
					}
					else
					{
						RegisterCallback(callback);
					}
				}
			}
		}

		[DataContract]
		private struct JsonTag
		{
			private List<JsonTag>? m_children;

			[DataMember]
			public RandomizationTag ID { get; init; }

			[DataMember]
			public string Name { get; init; }

			[DataMember]
			public string Description { get; init; }

			[DataMember(EmitDefaultValue = false)]
			public List<JsonTag>? Children
			{
				get
				{
					return m_children;
				}
				init
				{
					m_children = ((value == null || value.Count == 0) ? null : value);
				}
			}
		}

		public bool IsProcessed { get; protected set; }

		public bool IsProcessing { get; protected set; }

		protected Dictionary<Type, Processor> m_processorLookup { get; set; } = new Dictionary<Type, Processor>();


		protected Game.Data? m_gameData { get; set; }

		protected Game.Processor m_gameProcessor { get; set; } = new Game.Processor();


		protected Dictionary<string, string?> m_namedHashes { get; set; } = new Dictionary<string, string> { { "nriV4wruyGDWJAlthDcQVOnZRc/XrdAjR2fCHXE/E0k=", null } };


		private static Guid DownloadsGUID => new Guid("374DE290-123F-4565-9164-39C4925E467B");

		public MidManager()
		{
			RegisterProcessor(m_gameProcessor);
		}

		public void RegisterProcessor<TData>(Processor<TData> processor) where TData : class
		{
			if (!m_processorLookup.TryAdd(typeof(TData), processor))
			{
				Processor processor2 = m_processorLookup[typeof(TData)];
				FeatureLogger.Warning($"Cannot add new processor of type: {processor.GetType().Name}; an existing processor of type {processor2.GetType().Name} is already registered for that data type!");
			}
		}

		public IReadOnlyDictionary<Type, Processor> GetAllProcessors()
		{
			return m_processorLookup;
		}

		public Processor<TData> GetProcessor<TData>() where TData : class
		{
			if (m_processorLookup.TryGetValue(typeof(TData), out Processor value))
			{
				if (value is Processor<TData> result)
				{
					return result;
				}
				throw new InvalidCastException("Cannot converted processor of type " + value.GetType().Name + " to " + typeof(Processor<TData>).FullName);
			}
			throw new KeyNotFoundException("There is no processor for the requested data type: " + typeof(TData).FullName);
		}

		public Processor GetProcessor(Type tData)
		{
			if (m_processorLookup.TryGetValue(tData, out Processor value))
			{
				Type type = typeof(Processor<>).MakeGenericType(tData);
				if (type.IsAssignableFrom(value.GetType()))
				{
					return value;
				}
				throw new InvalidCastException("Cannot converted processor of type " + value.GetType().FullName + " to " + type.FullName);
			}
			throw new KeyNotFoundException("There is no processor for the requested data type: " + tData.FullName);
		}

		public bool NameHash(string hash, string name)
		{
			return m_namedHashes.TryAdd(hash, name);
		}

		public void InvalidateModdedInstanceData()
		{
			if (IsProcessing)
			{
				throw new NotSupportedException("Attempted to invalidate modded instance data while it's processing!");
			}
			IsProcessed = false;
			m_gameData = null;
		}

		public Game.Data GetUnprocessedGameData()
		{
			if (m_gameData != null)
			{
				return m_gameData;
			}
			return m_gameData = new Game.Data(this);
		}

		public Game.Data GetProcessedGameData()
		{
			ProcessData();
			return GetUnprocessedGameData();
		}

		public void ProcessData()
		{
			if (IsProcessed)
			{
				return;
			}
			if (IsProcessing)
			{
				throw new NotSupportedException("Process data request received while already processing!");
			}
			FeatureLogger.Notice("Beginning MID generation");
			IsProcessing = true;
			Game.Data unprocessedGameData = GetUnprocessedGameData();
			Event.Processor processor = Event.get_EventProcessor(unprocessedGameData);
			m_gameProcessor.Process(unprocessedGameData);
			unprocessedGameData.CleanUp();
			FeatureLogger.Notice("Checking for winability");
			if (DoGraphTraversal(unprocessedGameData, doProcessing: true))
			{
				FeatureLogger.Success("Game is beatable!");
			}
			else
			{
				FeatureLogger.Fail("Game is not beatable!");
			}
			using SHA256 sHA = SHA256.Create();
			byte[] array = new byte[1];
			IEnumerable<string> enumerable = Enumerable.Empty<string>().Concat(from e in unprocessedGameData.GetAllExpeditions()
				select e.Key).Concat(from r in unprocessedGameData.GetAllRegions()
				select r.Value.Name)
				.Concat<string>(from p in unprocessedGameData.GetAllPaths()
					select p.Value.Name ?? "null")
				.Concat(from t in unprocessedGameData.GetAllTags()
					select t.Value.Name);
			foreach (string item in enumerable)
			{
				byte[] bytes = Encoding.UTF8.GetBytes(item);
				sHA.TransformBlock(bytes, 0, bytes.Length, null, 0);
				sHA.TransformBlock(array, 0, array.Length, null, 0);
			}
			sHA.TransformFinalBlock(array, 0, 0);
			string text = Convert.ToBase64String(sHA.Hash);
			if (m_namedHashes.TryGetValue(text, out string value))
			{
				unprocessedGameData.Name = value;
			}
			else
			{
				unprocessedGameData.Name = text.Substring(0, 10);
			}
			unprocessedGameData.IsComplete = true;
			IsProcessing = false;
			IsProcessed = true;
			FeatureLogger.Notice("MID generation completed!");
			FeatureLogger.Notice("World Hash: " + text);
			if (unprocessedGameData.Name == null)
			{
				FeatureLogger.Notice("World is Vanilla");
			}
			else
			{
				FeatureLogger.Notice("World Name: " + unprocessedGameData.Name);
			}
			GameDataBlockBase<RundownDataBlock>.FileDirty = true;
			GameDataBlockBase<LevelLayoutDataBlock>.FileDirty = true;
			GameDataBlockBase<WardenObjectiveDataBlock>.FileDirty = true;
			GameDataBlockBase<DimensionDataBlock>.FileDirty = true;
			GameDataBlockBase<TextDataBlock>.FileDirty = true;
			unprocessedGameData.CleanUp();
		}

		[DllImport("shell32", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = false)]
		private static extern string SHGetKnownFolderPath([MarshalAs(UnmanagedType.LPStruct)] Guid rfid, uint dwFlags, nint hToken = 0);

		public void ExportMidData(string? directory = null)
		{
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Expected O, but got Unknown
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Expected O, but got Unknown
			Game.Data processedGameData = GetProcessedGameData();
			if (directory == null)
			{
				directory = SHGetKnownFolderPath(DownloadsGUID, 0u);
			}
			string path = System.IO.Path.Combine(directory, (processedGameData.Name == null) ? "GTFO.ini" : ("GTFO-" + processedGameData.Name + ".ini"));
			DoGraphTraversal(processedGameData, doProcessing: true, null, null, logDebugInfo: false);
			List<MidExpeditionData> list = new List<MidExpeditionData>();
			HashSet<RegionID> hashSet = new HashSet<RegionID>();
			Queue<PathID> queue = new Queue<PathID>();
			foreach (KeyValuePair<string, Expedition.Data> allExpedition in processedGameData.GetAllExpeditions())
			{
				hashSet.Clear();
				queue.Clear();
				hashSet.Add(Zone.get_StartingRegion(allExpedition.Value));
				foreach (PathID connectedPath in processedGameData.LookupRegion(hashSet.First()).ConnectedPaths)
				{
					queue.Enqueue(connectedPath);
				}
				while (queue.Count > 0)
				{
					ReadOnlyPath readOnlyPath = processedGameData.LookupPath(queue.Dequeue());
					if (hashSet.Contains(readOnlyPath.EndingRegion))
					{
						continue;
					}
					ReadOnlyRegion readOnlyRegion = processedGameData.LookupRegion(readOnlyPath.EndingRegion);
					if (!readOnlyRegion.Reachable)
					{
						continue;
					}
					hashSet.Add(readOnlyPath.EndingRegion);
					foreach (PathID connectedPath2 in readOnlyRegion.ConnectedPaths)
					{
						queue.Enqueue(connectedPath2);
					}
				}
				list.Add(new MidExpeditionData
				{
					Name = allExpedition.Key,
					ReachableRegions = hashSet.ToList()
				});
			}
			var anon = new
			{
				Expeditions = list,
				Tags = (from t in processedGameData.GetAllTags()
					select new KeyedRandomizationTag(t.Key, t.Value)).ToList(),
				Regions = (from r in processedGameData.GetAllRegions()
					select new KeyedRegion(r.Key, r.Value)).ToList(),
				Paths = (from p in processedGameData.GetAllPaths()
					select new KeyedPath(p.Key, p.Value)).ToList(),
				Locations = (from l in processedGameData.GetAllLocations()
					select new KeyedLocation(l.Key, l.Value)).ToList(),
				Items = (from i in processedGameData.GetAllItems()
					select new KeyedItem(i.Key, i.Value)).ToList(),
				FloatingItems = processedGameData.GetAllFloatingItemIds()
			};
			JsonSerializerSettings val = new JsonSerializerSettings
			{
				Formatting = (Formatting)1
			};
			val.Converters.Add((JsonConverter)new StringEnumConverter());
			val.Converters.Add((JsonConverter)(object)new SimplifiedListConverter<long>());
			val.Converters.Add((JsonConverter)(object)new SimplifiedListConverter<string>(15));
			val.Converters.Add((JsonConverter)(object)new IdConverter());
			Type[] targetTypes = new Type[7]
			{
				typeof(KeyedRandomizationTag),
				typeof(KeyedRegion),
				typeof(ReadOnlyRegion),
				typeof(KeyedPath),
				typeof(ReadOnlyPath),
				typeof(KeyedLocation),
				typeof(KeyedItem)
			};
			Type[] inlinedTypes = new Type[7]
			{
				typeof(RandomizationTagDefinition),
				typeof(ReadOnlyRegion),
				typeof(Region),
				typeof(ReadOnlyPath),
				typeof(ReTFO.Archipelago.ModdedInstanceData.Model.Path),
				typeof(Location),
				typeof(Item)
			};
			val.Converters.Add((JsonConverter)(object)new InlineConverter(targetTypes, inlinedTypes));
			string contents = JsonConvert.SerializeObject((object)anon, val);
			File.WriteAllText(path, contents);
		}

		public void ExportTagsToCSV(string? filename = null)
		{
			if (filename == null)
			{
				filename = System.IO.Path.Combine(SHGetKnownFolderPath(DownloadsGUID, 0u), "gtfoTags.csv");
			}
			IEnumerable<string> contents = Enumerable.Repeat("\"ID\",\"NAME\",\"PARENT\",\"DESCRIPTION\"", 1).Concat(from pair in GetProcessedGameData().GetAllTags()
				select $"\"{pair.Key.AsId.ToString()}\"\"{pair.Value.Name}\",\"{pair.Value.Parent}\",\"{pair.Value.Description}\"");
			File.WriteAllLines(filename, contents);
		}

		public void ExportTagsToJSON(string? filename = null)
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			if (filename == null)
			{
				filename = System.IO.Path.Combine(SHGetKnownFolderPath(DownloadsGUID, 0u), "gtfoTags.json");
			}
			Game.Data data = GetProcessedGameData();
			Dictionary<RandomizationTag, List<RandomizationTag>?> tagsByParent = new Dictionary<RandomizationTag, List<RandomizationTag>>();
			foreach (KeyValuePair<RandomizationTag, RandomizationTagDefinition> allTag in data.GetAllTags())
			{
				if (tagsByParent.TryGetValue(allTag.Value.Parent, out List<RandomizationTag> value))
				{
					value.Add(allTag.Key);
					continue;
				}
				tagsByParent.Add(allTag.Value.Parent, new List<RandomizationTag> { allTag.Key });
			}
			var anon = new
			{
				Tags = MakeJsonRecursive(new RandomizationTag())
			};
			JsonSerializerSettings val = new JsonSerializerSettings
			{
				Formatting = (Formatting)1
			};
			val.Converters.Add((JsonConverter)(object)new IdConverter());
			string contents = JsonConvert.SerializeObject((object)anon, val);
			File.WriteAllText(filename, contents);
			List<JsonTag> MakeJsonRecursive(RandomizationTag parentTag)
			{
				IEnumerable<RandomizationTag> valueOrDefault = tagsByParent.GetValueOrDefault(parentTag, null);
				return (valueOrDefault ?? Enumerable.Empty<RandomizationTag>()).Select((RandomizationTag t) => new KeyedRandomizationTag(t, data.LookupTagDef(t))).Select(delegate(KeyedRandomizationTag t)
				{
					JsonTag result = default(JsonTag);
					result.ID = t.ID;
					result.Name = t.Definition.Name;
					result.Description = t.Definition.Description;
					result.Children = MakeJsonRecursive(t.ID);
					return result;
				}).ToList();
			}
		}

		public static bool DoGraphTraversal(Game.Data gameData, bool doProcessing = false, ICollection<RandomizationTag>? unlockTags = null, ICollection<RandomizationTag>? goalTags = null, bool logDebugInfo = true)
		{
			Game.Data gameData2 = gameData;
			ICollection<RandomizationTag> goalTags2 = goalTags;
			if (unlockTags == null)
			{
				unlockTags = new List<RandomizationTag>(1) { RootRandomizationTags.get_Tag_UnlockItems(gameData2) };
			}
			if (goalTags2 == null)
			{
				goalTags2 = new List<RandomizationTag>(1) { RootRandomizationTags.get_Tag_GoalItems(gameData2) };
			}
			List<Item> collectedItems = new List<Item>();
			Dictionary<RandomizationTag, int> itemCounts = new Dictionary<RandomizationTag, int>();
			Dictionary<RandomizationTag, int> categoryCounts = new Dictionary<RandomizationTag, int>();
			List<Tuple<SortedList<RandomizationTag, int>?, SortedList<RandomizationTag, int>?>> usedItemsPerRegion = (gameData2.IsComplete ? new List<Tuple<SortedList<RandomizationTag, int>, SortedList<RandomizationTag, int>>>(0) : Enumerable.Repeat(Tuple.Create<SortedList<RandomizationTag, int>, SortedList<RandomizationTag, int>>(null, null), gameData2.GetAllRegions().Count).ToList());
			List<bool> isReachable = (doProcessing ? null : Enumerable.Repeat(element: false, gameData2.GetAllRegions().Count).ToList());
			List<PathID> list = new List<PathID>();
			if (doProcessing)
			{
				foreach (KeyValuePair<RegionID, Region> allRegion in gameData2.GetAllRegions())
				{
					gameData2.SetRegionReachable(allRegion.Key, isReachable: false);
				}
			}
			RegionID menuRegion = gameData2.MenuRegion;
			ReadOnlyRegion readOnlyRegion = gameData2.LookupRegion(menuRegion);
			setReachable(menuRegion);
			foreach (ItemID allFloatingItemId in gameData2.GetAllFloatingItemIds())
			{
				Item item2 = gameData2.LookupItem(allFloatingItemId);
				RandomizationTagDefinition randomizationTagDefinition = gameData2.LookupTagDef(item2.NameTag);
				RandomizationTagDefinition randomizationTagDefinition2 = (item2.Tag2.IsNull ? default(RandomizationTagDefinition) : gameData2.LookupTagDef(item2.Tag2));
				randomizationTagDefinition.Name.Contains("Expedition Unlock");
				if (gameData2.AnyTagMatches(unlockTags, gameData2.LookupItem(allFloatingItemId)))
				{
					collectItem(allFloatingItemId);
				}
			}
			foreach (Location item5 in readOnlyRegion.ConnectedLocationIds.Select(gameData2.LookupLocation))
			{
				if (item5.OwningRegionIds.Length == 1 && !item5.ItemID.IsNull)
				{
					collectItem(item5.ItemID);
				}
			}
			list.AddRange(readOnlyRegion.ConnectedPaths);
			int num = 1;
			while (num > 0)
			{
				num = 0;
				for (int i = 0; i < list.Count; i++)
				{
					ReadOnlyPath readOnlyPath = gameData2.LookupPath(list[i]);
					if (getReachable(readOnlyPath.EndingRegion))
					{
						list.RemoveAt(i--);
						continue;
					}
					int num2 = ((readOnlyPath.ReqItem.Type == ReTFO.Archipelago.ModdedInstanceData.Model.Path.RequiredItem.eType.Item) ? (itemCount(readOnlyPath.ReqItem.Target) - usedItemCount(readOnlyPath.StartingRegion, readOnlyPath.ReqItem.Target)) : ((readOnlyPath.ReqItem.Type == ReTFO.Archipelago.ModdedInstanceData.Model.Path.RequiredItem.eType.Category) ? (catsCount(readOnlyPath.ReqItem.Target) - usedCatsCount(readOnlyPath.StartingRegion, readOnlyPath.ReqItem.Target)) : 0));
					int num3 = ((readOnlyPath.AlternateItem.Type == ReTFO.Archipelago.ModdedInstanceData.Model.Path.RequiredItem.eType.Item) ? itemCount(readOnlyPath.AlternateItem.Target) : ((readOnlyPath.AlternateItem.Type == ReTFO.Archipelago.ModdedInstanceData.Model.Path.RequiredItem.eType.Category) ? catsCount(readOnlyPath.AlternateItem.Target) : 0));
					if (readOnlyPath.ReqItem.Type != 0 && num2 < readOnlyPath.ReqCount && num3 < 1)
					{
						continue;
					}
					setReachable(readOnlyPath.EndingRegion);
					num++;
					list.AddRange(gameData2.LookupRegion(readOnlyPath.EndingRegion).ConnectedPaths);
					if (!gameData2.IsComplete)
					{
						if (readOnlyPath.ReqItem.Type != 0)
						{
							ReTFO.Archipelago.ModdedInstanceData.Model.Path.RequiredItem requiredItem;
							int num4;
							if (num2 >= readOnlyPath.ReqCount)
							{
								requiredItem = readOnlyPath.ReqItem;
								num4 = (int)readOnlyPath.ReqCount;
							}
							else
							{
								requiredItem = readOnlyPath.AlternateItem;
								num4 = 1;
							}
							SortedList<RandomizationTag, int> sortedList = new SortedList<RandomizationTag, int>();
							SortedList<RandomizationTag, int> sortedList2;
							if (requiredItem.Type == ReTFO.Archipelago.ModdedInstanceData.Model.Path.RequiredItem.eType.Item)
							{
								sortedList2 = usedItemsPerRegion[readOnlyPath.StartingRegion.AsIndex].Item1;
								usedItemsPerRegion[readOnlyPath.EndingRegion.AsIndex] = Tuple.Create(sortedList, usedItemsPerRegion[readOnlyPath.StartingRegion.AsIndex].Item2);
							}
							else
							{
								sortedList2 = usedItemsPerRegion[readOnlyPath.StartingRegion.AsIndex].Item2;
								usedItemsPerRegion[readOnlyPath.EndingRegion.AsIndex] = Tuple.Create(usedItemsPerRegion[readOnlyPath.StartingRegion.AsIndex].Item1, sortedList);
							}
							IEnumerable<KeyValuePair<RandomizationTag, int>> enumerable = sortedList2;
							foreach (KeyValuePair<RandomizationTag, int> item6 in enumerable ?? Enumerable.Empty<KeyValuePair<RandomizationTag, int>>())
							{
								sortedList.Add(item6.Key, item6.Value);
							}
							sortedList[requiredItem.Target] = sortedList.GetValueOrDefault(requiredItem.Target, 0) + num4;
						}
						else
						{
							usedItemsPerRegion[readOnlyPath.EndingRegion.AsIndex] = usedItemsPerRegion[readOnlyPath.StartingRegion.AsIndex];
						}
						if (doProcessing && readOnlyPath.ReqItem.Type != 0)
						{
							uint num5 = (uint)((readOnlyPath.ReqItem.Type != ReTFO.Archipelago.ModdedInstanceData.Model.Path.RequiredItem.eType.Item) ? usedCatsCount(readOnlyPath.StartingRegion, readOnlyPath.ReqItem.Target) : usedItemCount(readOnlyPath.StartingRegion, readOnlyPath.ReqItem.Target));
							gameData2.SetPathReqCount(list[i], num5 + readOnlyPath.ReqCount);
						}
					}
					foreach (Location item7 in gameData2.LookupRegion(readOnlyPath.EndingRegion).ConnectedLocationIds.Select(gameData2.LookupLocation))
					{
						if (!item7.OwningRegionIds.Any((RegionID id) => !getReachable(id)))
						{
							collectItem(item7.ItemID);
						}
					}
					list.RemoveAt(i--);
				}
			}
			List<Item> list2 = (from item in (from pair in gameData2.GetAllLocations()
					select pair.Value.ItemID into id
					where !id.IsNull
					select id).Select(gameData2.LookupItem)
				where gameData2.AnyTagMatches(goalTags2, item)
				select item).ToList();
			foreach (Item item8 in collectedItems)
			{
				list2.Remove(item8);
			}
			if (list2.Count == 0)
			{
				return true;
			}
			if (!logDebugInfo)
			{
				return false;
			}
			FeatureLogger.Error("Graph traversal failed for game!");
			ConsoleManager.SetConsoleColor(ConsoleColor.Yellow);
			ConsoleManager.ConsoleStream.WriteLine("\n    Missing Item" + ((list2.Count > 1) ? "s" : "") + " Required for Completion:");
			ConsoleManager.SetConsoleColor(ConsoleColor.White);
			foreach (Item item9 in list2)
			{
				ConsoleManager.ConsoleStream.WriteLine("  - " + gameData2.LookupTagDef(item9.NameTag).Name);
			}
			ConsoleManager.SetConsoleColor(ConsoleColor.Yellow);
			ConsoleManager.ConsoleStream.WriteLine("\n    Regions:");
			bool flag = false;
			foreach (KeyValuePair<RegionID, Region> allRegion2 in gameData2.GetAllRegions())
			{
				bool flag2 = getReachable(allRegion2.Key);
				if (flag2)
				{
					ConsoleManager.SetConsoleColor(ConsoleColor.Green);
				}
				else
				{
					ConsoleManager.SetConsoleColor(ConsoleColor.Red);
				}
				ConsoleManager.ConsoleStream.WriteLine($"  {(flag2 ? "[ Reachable ]" : "[Unreachable]")} [{allRegion2.Key.AsId.ToString("000")}] {allRegion2.Value.Name}");
				flag = true;
			}
			if (!flag)
			{
				ConsoleManager.ConsoleStream.WriteLine("\n  NO REGIONS FOUND");
			}
			ConsoleManager.SetConsoleColor(ConsoleColor.Yellow);
			ConsoleManager.ConsoleStream.WriteLine("\n    Blocked paths:");
			PathID[] array = new PathID[list.Count];
			list.CopyTo(array);
			Array.Sort(array);
			flag = false;
			PathID[] array2 = array;
			foreach (PathID id2 in array2)
			{
				ReadOnlyPath readOnlyPath2 = gameData2.LookupPath(id2);
				ConsoleManager.ConsoleStream.WriteLine();
				ConsoleManager.ConsoleStream.WriteLine("  Name:  " + (readOnlyPath2.Name ?? "None"));
				ConsoleManager.SetConsoleColor(ConsoleColor.Green);
				ConsoleManager.ConsoleStream.WriteLine("  Start: [" + readOnlyPath2.StartingRegion.AsId.ToString("000") + "] " + gameData2.LookupRegion(readOnlyPath2.StartingRegion).Name);
				ConsoleManager.SetConsoleColor(ConsoleColor.Red);
				ConsoleManager.ConsoleStream.WriteLine("  End:   [" + readOnlyPath2.EndingRegion.AsId.ToString("000") + "] " + gameData2.LookupRegion(readOnlyPath2.EndingRegion).Name);
				ConsoleManager.SetConsoleColor(ConsoleColor.Yellow);
				if (readOnlyPath2.ReqItem.Type == ReTFO.Archipelago.ModdedInstanceData.Model.Path.RequiredItem.eType.None)
				{
					ConsoleManager.ConsoleStream.WriteLine("  No required item!");
				}
				else if (readOnlyPath2.ReqItem.Type == ReTFO.Archipelago.ModdedInstanceData.Model.Path.RequiredItem.eType.Item)
				{
					ConsoleManager.ConsoleStream.WriteLine("  Item:  " + (usedItemCount(readOnlyPath2.StartingRegion, readOnlyPath2.ReqItem.Target) + readOnlyPath2.ReqCount).ToString("000") + "x " + gameData2.LookupTagDef(readOnlyPath2.ReqItem.Target).Name);
				}
				else
				{
					ConsoleManager.ConsoleStream.WriteLine("  Cats:  " + (usedCatsCount(readOnlyPath2.StartingRegion, readOnlyPath2.ReqItem.Target) + readOnlyPath2.ReqCount).ToString("000") + "x " + gameData2.LookupTagDef(readOnlyPath2.ReqItem.Target).Name);
				}
				if (readOnlyPath2.AlternateItem.Type != 0)
				{
					ConsoleManager.ConsoleStream.WriteLine("  Alt:   001x " + gameData2.LookupTagDef(readOnlyPath2.AlternateItem.Target).Name);
				}
				flag = true;
			}
			if (!flag)
			{
				ConsoleManager.ConsoleStream.WriteLine("\n  NO BLOCKED PATHS FOUND");
			}
			ConsoleManager.SetConsoleColor(ConsoleColor.Yellow);
			ConsoleManager.ConsoleStream.WriteLine("\n    Notable unfound locations:");
			HashSet<RandomizationTag> hashSet = list.Select(gameData2.LookupPath).SelectMany((ReadOnlyPath p) => Enumerable.Empty<RandomizationTag>().Append(p.ReqItem.Target).Append(p.AlternateItem.Target)).ToHashSet();
			flag = false;
			foreach (Location item10 in from pair in gameData2.GetAllLocations()
				select pair.Value)
			{
				if (item10.ItemID.IsNull || item10.OwningRegionIds.All(getReachable))
				{
					continue;
				}
				Item item3 = gameData2.LookupItem(item10.ItemID);
				if (!gameData2.TagMatches(hashSet, item3.PathReqs.Target))
				{
					continue;
				}
				ConsoleManager.ConsoleStream.WriteLine();
				ConsoleManager.ConsoleStream.WriteLine("  Name: " + gameData2.LookupTagDef(item10.NameTag).Name);
				ConsoleManager.ConsoleStream.WriteLine("  Item: " + gameData2.LookupTagDef(item3.NameTag).Name);
				if (!item3.Tag2.IsNull)
				{
					ConsoleManager.ConsoleStream.WriteLine("   Cat: " + gameData2.LookupTagDef(item3.Tag2).Name);
				}
				if (!item3.Tag3.IsNull)
				{
					ConsoleManager.ConsoleStream.WriteLine("   Cat: " + gameData2.LookupTagDef(item3.Tag3).Name);
				}
				ConsoleManager.ConsoleStream.WriteLine("  Regions:");
				if (item10.OwningRegionIds.Length == 0)
				{
					ConsoleManager.SetConsoleColor(ConsoleColor.Red);
					ConsoleManager.ConsoleStream.WriteLine("  LOCATION HAS NO REGIONS AND CANNOT BE DISCOVERED");
				}
				else
				{
					RegionID[] owningRegionIds = item10.OwningRegionIds;
					for (int k = 0; k < owningRegionIds.Length; k++)
					{
						RegionID id3 = owningRegionIds[k];
						bool flag3 = getReachable(id3);
						if (flag3)
						{
							ConsoleManager.SetConsoleColor(ConsoleColor.Green);
						}
						else
						{
							ConsoleManager.SetConsoleColor(ConsoleColor.Red);
						}
						ConsoleManager.ConsoleStream.WriteLine($"   {(flag3 ? "[ Reachable ]" : "[Unreachable]")} [{id3.AsId.ToString("000")}] {gameData2.LookupRegion(id3).Name}");
					}
				}
				ConsoleManager.SetConsoleColor(ConsoleColor.Yellow);
				flag = true;
			}
			if (hashSet.Count == 0)
			{
				ConsoleManager.ConsoleStream.WriteLine("\n  NO NEEDED ITEMS FOUND");
			}
			else if (!flag)
			{
				ConsoleManager.Cons