using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using GLTFast;
using GLTFast.Loading;
using GLTFast.Logging;
using GLTFast.Materials;
using GLTFast.Newtonsoft;
using GLTFast.Newtonsoft.Schema;
using GLTFast.Schema;
using HarmonyLib;
using Hebron.Runtime;
using Microsoft.CodeAnalysis;
using StbImageSharp;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("ModMogul")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("An API with hooks to make modding easier")]
[assembly: AssemblyFileVersion("0.3.1.0")]
[assembly: AssemblyInformationalVersion("0.3.1+38b6f8b0a5a8927ef8fc7ad487276693aa48c9b6")]
[assembly: AssemblyProduct("ModMogul")]
[assembly: AssemblyTitle("ModMogul")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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;
		}
	}
}
namespace ModMogul
{
	public static class Itemizer
	{
		[Serializable]
		public struct ItemSpec
		{
			public int BlockID;

			public string InternalName;

			public string DisplayName;

			public string Description;

			public int Price;

			public string ShopCategory;

			public int MaxStackSize;

			public bool IsLockedByDefault;

			public string QFunction;

			public string IconPath;

			public ItemSpec(int blockID, string internalName, string displayName, string description, int price, string shopCategory, int maxStackSize = 999, bool isLockedByDefault = false, string qFunction = "Mirror")
			{
				BlockID = blockID;
				InternalName = internalName;
				DisplayName = displayName;
				Description = description;
				Price = price;
				ShopCategory = shopCategory;
				MaxStackSize = maxStackSize;
				IsLockedByDefault = isLockedByDefault;
				QFunction = qFunction;
				IconPath = null;
			}
		}

		private sealed class ItemRuntime
		{
			public ItemSpec Spec;

			public BuildingObject Prefab;

			public BuildingInventoryDefinition Def;

			public ShopItemDefinition ShopItemDef;
		}

		[HarmonyPatch(typeof(EconomyManager), "Start")]
		private static class Patch_EconomyManager_Start_Postfix
		{
			private static void Postfix(EconomyManager __instance)
			{
				Debug.Log((object)"[ModMogul.Itemizer] Injecting Custom Items into EconomyManager");
				TryInjectAllIntoEconomy(__instance);
			}
		}

		private static readonly object _lock = new object();

		private static readonly Dictionary<int, ItemRuntime> _itemsByBlockId = new Dictionary<int, ItemRuntime>();

		private static readonly HashSet<int> _injectedEconomyIds = new HashSet<int>();

		private static EconomyManager _lastEconomy;

		private static GameObject prefabHolder;

		public static BuildingObject RegisterItem(ItemSpec spec)
		{
			ValidateSpec(spec);
			ItemRuntime value;
			lock (_lock)
			{
				if (!_itemsByBlockId.TryGetValue(spec.BlockID, out value))
				{
					value = new ItemRuntime();
					_itemsByBlockId.Add(spec.BlockID, value);
				}
				value.Spec = spec;
				value.Prefab = CreateOrGetPrefabTemplate(spec.BlockID, spec.InternalName, value.Prefab);
			}
			EconomyManager val = _lastEconomy ?? Singleton<EconomyManager>.Instance;
			if ((Object)(object)val != (Object)null)
			{
				TryInjectAllIntoEconomy(val);
			}
			RegisterWithSaveLoadManager(((Component)value.Prefab).gameObject);
			return value.Prefab;
		}

		public static BuildingObject RegisterItem(ItemSpec spec, string iconPath)
		{
			ValidateSpec(spec);
			spec.IconPath = iconPath;
			ItemRuntime value;
			lock (_lock)
			{
				if (!_itemsByBlockId.TryGetValue(spec.BlockID, out value))
				{
					value = new ItemRuntime();
					_itemsByBlockId.Add(spec.BlockID, value);
				}
				value.Spec = spec;
				value.Prefab = CreateOrGetPrefabTemplate(spec.BlockID, spec.InternalName, value.Prefab);
			}
			EconomyManager val = _lastEconomy ?? Singleton<EconomyManager>.Instance;
			if ((Object)(object)val != (Object)null)
			{
				TryInjectAllIntoEconomy(val);
			}
			RegisterWithSaveLoadManager(((Component)value.Prefab).gameObject);
			return value.Prefab;
		}

		private static void RegisterWithSaveLoadManager(GameObject savableObjectPrefab)
		{
			Object.FindFirstObjectByType<SavingLoadingManager>().AllSavableObjectPrefabs.Add(savableObjectPrefab);
		}

		private static void ValidateSpec(ItemSpec spec)
		{
			if (spec.BlockID <= 0)
			{
				throw new ArgumentException("BlockID must be > 0");
			}
			if (string.IsNullOrWhiteSpace(spec.InternalName))
			{
				throw new ArgumentException("InternalName required");
			}
			if (string.IsNullOrWhiteSpace(spec.DisplayName))
			{
				throw new ArgumentException("DisplayName required");
			}
			if (string.IsNullOrWhiteSpace(spec.ShopCategory))
			{
				throw new ArgumentException("ShopCategory required");
			}
		}

		internal static BuildingObject CreateOrGetPrefabTemplate(int blockID, string internalName, BuildingObject existing)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)existing != (Object)null)
			{
				return existing;
			}
			GameObject val = new GameObject(internalName + "_BuildingPrefab");
			GameObject val2 = new GameObject("BuildingPlacementColliderObject");
			val2.transform.SetParent(val.transform, false);
			GameObject val3 = new GameObject("BuildingCrateSpawnPoint");
			val3.transform.SetParent(val.transform, false);
			GameObject val4 = GameObject.CreatePrimitive((PrimitiveType)3);
			MeshFilter val5 = val.GetComponent<MeshFilter>() ?? val.AddComponent<MeshFilter>();
			val5.sharedMesh = val4.GetComponent<MeshFilter>().sharedMesh;
			MeshRenderer val6 = val.GetComponent<MeshRenderer>() ?? val.AddComponent<MeshRenderer>();
			((Renderer)val6).sharedMaterial = ((Renderer)val4.GetComponent<MeshRenderer>()).sharedMaterial;
			Object.Destroy((Object)(object)val4);
			if ((Object)(object)prefabHolder == (Object)null)
			{
				prefabHolder = new GameObject("Itemizer_PrefabHolder");
				prefabHolder.transform.position = -Vector3.up * 1000f;
				Object.DontDestroyOnLoad((Object)(object)prefabHolder);
				((Object)prefabHolder).hideFlags = (HideFlags)61;
				prefabHolder.SetActive(false);
			}
			val.transform.parent = prefabHolder.transform;
			BuildingObject val7 = val.AddComponent<BuildingObject>();
			val7.SavableObjectID = (SavableObjectID)blockID;
			val7.BuildingPlacementColliderObject = val2;
			val7.BuildingCrateSpawnPoint = val3.transform;
			RegisterSavableLookupIfPossible(blockID, val7);
			return val7;
		}

		internal static void TryInjectAllIntoEconomy(EconomyManager econ)
		{
			if ((Object)(object)econ == (Object)null)
			{
				return;
			}
			_lastEconomy = econ;
			int instanceID = ((Object)econ).GetInstanceID();
			lock (_lock)
			{
				if (!_injectedEconomyIds.Add(instanceID))
				{
					return;
				}
			}
			List<ShopCategory> list = (List<ShopCategory>)(AccessTools.Field(typeof(EconomyManager), "_allShopCategories")?.GetValue(econ));
			if (list == null)
			{
				return;
			}
			List<ItemRuntime> list2;
			lock (_lock)
			{
				list2 = _itemsByBlockId.Values.ToList();
			}
			foreach (ItemRuntime item in list2)
			{
				try
				{
					EnsureInjectedIntoEconomy(econ, list, item);
				}
				catch (Exception arg)
				{
					Debug.LogError((object)$"[ModMogul.Itemizer] Inject into EconomyManager failed for {item?.Spec.InternalName} ({item?.Spec.BlockID}): {arg}");
				}
			}
		}

		private static void EnsureInjectedIntoEconomy(EconomyManager econ, List<ShopCategory> allCats, ItemRuntime rt)
		{
			ItemSpec spec = rt.Spec;
			rt.Prefab = CreateOrGetPrefabTemplate(spec.BlockID, spec.InternalName, rt.Prefab);
			if ((Object)(object)rt.Def == (Object)null)
			{
				rt.Def = ScriptableObject.CreateInstance<BuildingInventoryDefinition>();
				((Object)rt.Def).name = spec.InternalName + "_Definition";
				Object.DontDestroyOnLoad((Object)(object)rt.Def);
				((Object)rt.Def).hideFlags = (HideFlags)61;
				rt.Def.Name = spec.DisplayName;
				rt.Def.Description = spec.Description;
				rt.Def.MaxInventoryStackSize = spec.MaxStackSize;
				rt.Def.QButtonFunction = spec.QFunction;
				rt.Def.BuildingPrefabs = new List<BuildingObject> { rt.Prefab };
				rt.Def.InventoryIcon = Utility.ImportSprite(spec.IconPath);
				rt.Def.ProgrammerInventoryIcon = Utility.ImportSprite(spec.IconPath);
				rt.Def.PackedPrefab = GetABuildingCrate(allCats);
				rt.Def.UseReverseRotationDirection = false;
				rt.Prefab.Definition = rt.Def;
				if ((Object)(object)rt.Def.GetMainPrefab() == (Object)null)
				{
					Debug.LogError((object)("[ModMogul.Itemizer] " + spec.InternalName + " def has no main prefab after init."));
				}
			}
			if ((Object)(object)rt.ShopItemDef == (Object)null)
			{
				rt.ShopItemDef = ScriptableObject.CreateInstance<ShopItemDefinition>();
				((Object)rt.ShopItemDef).name = spec.InternalName + "_ShopItem";
				Object.DontDestroyOnLoad((Object)(object)rt.ShopItemDef);
				((Object)rt.ShopItemDef).hideFlags = (HideFlags)61;
				rt.ShopItemDef.UseNameAndDescriptionOfBuildingDefinition = true;
				rt.ShopItemDef.BuildingInventoryDefinition = rt.Def;
				rt.ShopItemDef.Price = spec.Price;
				rt.ShopItemDef.IsLockedByDefault = spec.IsLockedByDefault;
				rt.ShopItemDef.IsDummyItem = false;
				rt.ShopItemDef.PrefabToSpawn = null;
			}
			else
			{
				rt.ShopItemDef.BuildingInventoryDefinition = rt.Def;
				rt.ShopItemDef.Price = spec.Price;
				rt.ShopItemDef.IsLockedByDefault = spec.IsLockedByDefault;
			}
			RegisterSavableLookupIfPossible(spec.BlockID, rt.Prefab);
			SetupCategory(econ, allCats, rt.ShopItemDef, spec.ShopCategory);
		}

		private static void SetupCategory(EconomyManager __instance, List<ShopCategory> allCats, ShopItemDefinition def, string shopCategory)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0078: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			if (allCats != null)
			{
				ShopCategory val = ((IEnumerable<ShopCategory>)allCats).FirstOrDefault((Func<ShopCategory, bool>)((ShopCategory c) => c != null && c.CategoryName == shopCategory && !c.IsAnyHolidayCategory()));
				if (val == null)
				{
					val = new ShopCategory
					{
						CategoryName = shopCategory,
						ShopItemDefinitions = new List<ShopItemDefinition>(),
						ShopItems = new List<ShopItem>(),
						DontShowIfAllItemsAreLocked = false,
						HolidayType = (HolidayType)0
					};
					allCats.Add(val);
				}
				ShopCategory val2 = val;
				if (val2.ShopItemDefinitions == null)
				{
					val2.ShopItemDefinitions = new List<ShopItemDefinition>();
				}
				val2 = val;
				if (val2.ShopItems == null)
				{
					val2.ShopItems = new List<ShopItem>();
				}
				if (!val.ShopItemDefinitions.Contains(def))
				{
					val.ShopItemDefinitions.Add(def);
				}
				ShopItem val3 = ((IEnumerable<ShopItem>)val.ShopItems).FirstOrDefault((Func<ShopItem, bool>)((ShopItem si) => si != null && (Object)(object)si.Definition == (Object)(object)def));
				if (val3 == null)
				{
					val3 = new ShopItem(def);
					val.ShopItems.Add(val3);
				}
				val3.IsLocked = false;
				__instance.UnlockShopItem(def);
				if (!__instance.AllShopItems.Any((ShopItem si) => si != null && (Object)(object)si.Definition == (Object)(object)def))
				{
					__instance.AllShopItems.Add(val3);
				}
				if (AccessTools.Field(typeof(EconomyManager), "_allShopItemDefinitions")?.GetValue(__instance) is HashSet<ShopItemDefinition> hashSet)
				{
					hashSet.Add(def);
				}
			}
		}

		public static void RegisterSavableLookupIfPossible(int blockID, BuildingObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return;
			}
			SavingLoadingManager instance = Singleton<SavingLoadingManager>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				Dictionary<SavableObjectID, GameObject> dictionary = (Dictionary<SavableObjectID, GameObject>)(AccessTools.Field(typeof(SavingLoadingManager), "_lookup")?.GetValue(instance));
				if (dictionary != null)
				{
					dictionary[(SavableObjectID)blockID] = ((Component)prefab).gameObject;
				}
			}
		}

		private static BuildingCrate GetABuildingCrate(List<ShopCategory> allCats)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Invalid comparison between Unknown and I4
			if (allCats == null)
			{
				return null;
			}
			foreach (ShopCategory allCat in allCats)
			{
				List<ShopItemDefinition> list = allCat?.ShopItemDefinitions;
				if (list == null)
				{
					continue;
				}
				foreach (ShopItemDefinition item in list)
				{
					BuildingInventoryDefinition val = item?.BuildingInventoryDefinition;
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					BuildingObject mainPrefab = val.GetMainPrefab();
					if (!((Object)(object)mainPrefab == (Object)null))
					{
						BuildingObject componentInChildren = ((Component)mainPrefab).GetComponentInChildren<BuildingObject>(true);
						if (!((Object)(object)componentInChildren == (Object)null) && (int)componentInChildren.GetSavableObjectID() == 108)
						{
							return val.PackedPrefab;
						}
					}
				}
			}
			return null;
		}
	}
	public static class ModelMaker
	{
		[Serializable]
		public enum MaterialType
		{
			Opaque,
			Fade,
			Cutout
		}

		internal static async Task<GltfImport> LoadModelAsync(string modelPath, Transform parent, CancellationToken ct = default(CancellationToken))
		{
			if ((Object)(object)parent == (Object)null)
			{
				Debug.LogError((object)"LoadModelAsync: parent is null");
				return null;
			}
			try
			{
				string fullPath = Path.GetFullPath(modelPath);
				if (!File.Exists(fullPath))
				{
					Debug.LogError((object)("LoadModelAsync: file not found: " + fullPath));
					return null;
				}
				Uri uri = new Uri(fullPath);
				CollectingLogger logger = new CollectingLogger();
				GltfImport gltfImport = new GltfImport((IDownloadProvider)null, (IDeferAgent)null, (IMaterialGenerator)null, (ICodeLogger)(object)logger);
				Debug.Log((object)$"glTFast Load: {uri}");
				if (!(await ((GltfImportBase)gltfImport).Load(uri, (ImportSettings)null, ct)))
				{
					Debug.LogError((object)("glTFast failed to load: " + fullPath));
					logger.LogAll();
					return null;
				}
				if (!(await ((GltfImportBase)gltfImport).InstantiateMainSceneAsync(parent, ct)))
				{
					Debug.LogError((object)("glTFast failed to instantiate: " + fullPath));
					logger.LogAll();
					return null;
				}
				return gltfImport;
			}
			catch (OperationCanceledException)
			{
				Debug.LogWarning((object)"LoadModelAsync canceled");
				return null;
			}
			catch (Exception e)
			{
				Debug.LogException(e);
				return null;
			}
		}

		public static async Task<GameObject> LoadModelToGameObjectAsync(string modelPath, Transform parent, MaterialType materialType, string childName = null, CancellationToken ct = default(CancellationToken))
		{
			GameObject rootGo = new GameObject(childName ?? Path.GetFileNameWithoutExtension(modelPath));
			rootGo.transform.SetParent(parent, false);
			GltfImport glbImport = await LoadModelAsync(modelPath, rootGo.transform, ct);
			if (glbImport == null)
			{
				Object.Destroy((Object)(object)rootGo);
				return null;
			}
			for (int i = 0; i < rootGo.GetComponentsInChildren<MeshRenderer>().Length; i++)
			{
				MeshRenderer j = rootGo.GetComponentsInChildren<MeshRenderer>()[i];
				_ = ((Renderer)j).materials;
			}
			BindAllToStandard(glbImport, rootGo, materialType);
			return rootGo;
		}

		public static void BindAllToStandard(GltfImport import, GameObject instantiatedRoot, MaterialType materialType)
		{
			if (import == null || (Object)(object)instantiatedRoot == (Object)null)
			{
				return;
			}
			Root sourceRoot = ((GltfImportBase<Root>)(object)import).GetSourceRoot();
			if (sourceRoot == null)
			{
				Debug.LogError((object)"BindAllToStandard: GetSourceRoot() returned null");
				return;
			}
			Material val = CreateCleanStandard();
			if ((Object)(object)val == (Object)null || (Object)(object)val.shader == (Object)null)
			{
				Debug.LogError((object)"BindAllToStandard: could not create/find Standard material");
				return;
			}
			Dictionary<int, Material> dictionary = BuildStandardMaterials(import, sourceRoot, val, materialType);
			Dictionary<string, int> dictionary2 = new Dictionary<string, int>(StringComparer.Ordinal);
			if (((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).nodes != null)
			{
				for (int i = 0; i < ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).nodes.Length; i++)
				{
					Node val2 = ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).nodes[i];
					if (!string.IsNullOrEmpty(((NamedObject)val2).name) && !dictionary2.ContainsKey(((NamedObject)val2).name))
					{
						dictionary2[((NamedObject)val2).name] = i;
					}
				}
			}
			MeshRenderer[] componentsInChildren = instantiatedRoot.GetComponentsInChildren<MeshRenderer>(true);
			foreach (MeshRenderer val3 in componentsInChildren)
			{
				Material[] array = ((Renderer)val3).materials;
				if (!dictionary2.TryGetValue(((Object)val3).name, out var value))
				{
					string key = TrimCloneSuffix(((Object)val3).name);
					if (!dictionary2.TryGetValue(key, out value))
					{
						continue;
					}
				}
				Node val4 = ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).nodes[value];
				int mesh = ((NodeBase)val4).mesh;
				if (((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).meshes == null || mesh < 0 || mesh >= ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).meshes.Length)
				{
					continue;
				}
				Mesh val5 = ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).meshes[mesh];
				MeshPrimitive[] primitives = ((MeshBase<MeshExtras, MeshPrimitive>)(object)val5).primitives;
				if (primitives == null || primitives.Length == 0)
				{
					continue;
				}
				if (array == null || array.Length != primitives.Length)
				{
					Array.Resize(ref array, primitives.Length);
				}
				bool flag = false;
				for (int k = 0; k < primitives.Length; k++)
				{
					int material = ((MeshPrimitiveBase)primitives[k]).material;
					Material value2;
					Material val6 = (dictionary.TryGetValue(material, out value2) ? value2 : dictionary[-1]);
					if ((Object)(object)array[k] != (Object)(object)val6)
					{
						array[k] = val6;
						flag = true;
					}
				}
				if (flag)
				{
					((Renderer)val3).materials = array;
					((Renderer)val3).SetPropertyBlock((MaterialPropertyBlock)null);
				}
			}
			SkinnedMeshRenderer[] componentsInChildren2 = instantiatedRoot.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val7 in componentsInChildren2)
			{
				Material[] array2 = ((Renderer)val7).materials;
				if (!dictionary2.TryGetValue(((Object)val7).name, out var value3))
				{
					string key2 = TrimCloneSuffix(((Object)val7).name);
					if (!dictionary2.TryGetValue(key2, out value3))
					{
						continue;
					}
				}
				Node val8 = ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).nodes[value3];
				int mesh2 = ((NodeBase)val8).mesh;
				if (((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).meshes == null || mesh2 < 0 || mesh2 >= ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).meshes.Length)
				{
					continue;
				}
				Mesh val9 = ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)sourceRoot).meshes[mesh2];
				MeshPrimitive[] primitives2 = ((MeshBase<MeshExtras, MeshPrimitive>)(object)val9).primitives;
				if (primitives2 == null || primitives2.Length == 0)
				{
					continue;
				}
				if (array2 == null || array2.Length != primitives2.Length)
				{
					Array.Resize(ref array2, primitives2.Length);
				}
				bool flag2 = false;
				for (int m = 0; m < primitives2.Length; m++)
				{
					int material2 = ((MeshPrimitiveBase)primitives2[m]).material;
					Material value4;
					Material val10 = (dictionary.TryGetValue(material2, out value4) ? value4 : dictionary[-1]);
					if ((Object)(object)array2[m] != (Object)(object)val10)
					{
						array2[m] = val10;
						flag2 = true;
					}
				}
				if (flag2)
				{
					((Renderer)val7).materials = array2;
					((Renderer)val7).SetPropertyBlock((MaterialPropertyBlock)null);
				}
			}
		}

		private static Dictionary<int, Material> BuildStandardMaterials(GltfImport import, Root gltf, Material template, MaterialType materialType)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<int, Material> dictionary = new Dictionary<int, Material>();
			Material value = new Material(template)
			{
				name = "glTF_Default_Standard"
			};
			dictionary[-1] = value;
			if (((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)gltf).materials == null || ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)gltf).materials.Length == 0)
			{
				return dictionary;
			}
			for (int i = 0; i < ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)gltf).materials.Length; i++)
			{
				Material val = ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)gltf).materials[i];
				PbrMetallicRoughness pbrMetallicRoughness = ((MaterialBase<MaterialExtensions, NormalTextureInfo, OcclusionTextureInfo, PbrMetallicRoughness, TextureInfo, TextureInfoExtensions>)(object)val).pbrMetallicRoughness;
				Material val2 = new Material(template)
				{
					name = (string.IsNullOrEmpty(((NamedObject)val).name) ? $"glTF_Mat_{i}_Standard" : (((NamedObject)val).name + "_Standard"))
				};
				Texture val3 = null;
				int num = -1;
				if (((PbrMetallicRoughnessBase<TextureInfo>)(object)pbrMetallicRoughness)?.baseColorTexture != null)
				{
					num = ((TextureInfoBase)((PbrMetallicRoughnessBase<TextureInfo>)(object)pbrMetallicRoughness).baseColorTexture).index;
				}
				if (num >= 0)
				{
					val3 = (Texture)(object)((GltfImportBase)import).GetTexture(num);
				}
				if ((Object)(object)val3 == (Object)null && ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)gltf).textures != null && ((RootBase<Accessor, Animation, Asset, Buffer, BufferView, Camera, RootExtensions, Image, Material, Mesh, Node, Sampler, Scene, Skin, Texture>)(object)gltf).textures.Length == 1)
				{
					val3 = (Texture)(object)((GltfImportBase)import).GetTexture(0);
				}
				if ((Object)(object)val3 != (Object)null && val2.HasProperty("_MainTex"))
				{
					val2.SetTexture("_MainTex", val3);
				}
				if (((MaterialBase)val).doubleSided)
				{
					val2.SetInt("_Cull", 0);
				}
				switch (materialType)
				{
				case MaterialType.Fade:
					ApplyBlendMaterial(val2, val3);
					break;
				case MaterialType.Cutout:
					SetStandardCutout(val2, 0.5f);
					break;
				default:
					SetStandardOpaque(val2);
					break;
				}
				if (pbrMetallicRoughness != null && val2.HasProperty("_Color") && ((PbrMetallicRoughnessBase)pbrMetallicRoughness).baseColorFactor != null && ((PbrMetallicRoughnessBase)pbrMetallicRoughness).baseColorFactor.Length >= 4)
				{
					val2.SetColor("_Color", new Color(((PbrMetallicRoughnessBase)pbrMetallicRoughness).baseColorFactor[0], ((PbrMetallicRoughnessBase)pbrMetallicRoughness).baseColorFactor[1], ((PbrMetallicRoughnessBase)pbrMetallicRoughness).baseColorFactor[2], ((PbrMetallicRoughnessBase)pbrMetallicRoughness).baseColorFactor[3]));
				}
				dictionary[i] = val2;
			}
			return dictionary;
		}

		private static Material CreateCleanStandard()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Standard");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Unlit/Texture");
			}
			Material val2 = new Material(val);
			if (val2.HasProperty("_MainTex"))
			{
				val2.SetTexture("_MainTex", (Texture)null);
			}
			if (val2.HasProperty("_BumpMap"))
			{
				val2.SetTexture("_BumpMap", (Texture)null);
			}
			if (val2.HasProperty("_EmissionMap"))
			{
				val2.SetTexture("_EmissionMap", (Texture)null);
			}
			if (val2.HasProperty("_MetallicGlossMap"))
			{
				val2.SetTexture("_MetallicGlossMap", (Texture)null);
			}
			if (val2.HasProperty("_OcclusionMap"))
			{
				val2.SetTexture("_OcclusionMap", (Texture)null);
			}
			if (val2.HasProperty("_DetailAlbedoMap"))
			{
				val2.SetTexture("_DetailAlbedoMap", (Texture)null);
			}
			if (val2.HasProperty("_DetailNormalMap"))
			{
				val2.SetTexture("_DetailNormalMap", (Texture)null);
			}
			val2.DisableKeyword("_EMISSION");
			val2.DisableKeyword("_NORMALMAP");
			val2.DisableKeyword("_METALLICGLOSSMAP");
			val2.DisableKeyword("_PARALLAXMAP");
			val2.DisableKeyword("_DETAIL_MULX2");
			val2.DisableKeyword("_DETAIL_SCALED");
			if (val2.HasProperty("_Color"))
			{
				val2.SetColor("_Color", Color.white);
			}
			if (val2.HasProperty("_Metallic"))
			{
				val2.SetFloat("_Metallic", 0f);
			}
			if (val2.HasProperty("_Glossiness"))
			{
				val2.SetFloat("_Glossiness", 0.5f);
			}
			if (val2.HasProperty("_BumpScale"))
			{
				val2.SetFloat("_BumpScale", 1f);
			}
			if (val2.HasProperty("_EmissionColor"))
			{
				val2.SetColor("_EmissionColor", Color.black);
			}
			return val2;
		}

		private static string TrimCloneSuffix(string name)
		{
			if (name != null && name.EndsWith("(Clone)", StringComparison.Ordinal))
			{
				return name.Substring(0, name.Length - "(Clone)".Length).TrimEnd(Array.Empty<char>());
			}
			return name;
		}

		private static void SetStandardOpaque(Material m)
		{
			m.SetOverrideTag("RenderType", "Opaque");
			m.SetFloat("_Mode", 0f);
			m.SetInt("_SrcBlend", 1);
			m.SetInt("_DstBlend", 0);
			m.SetInt("_ZWrite", 1);
			m.DisableKeyword("_ALPHATEST_ON");
			m.DisableKeyword("_ALPHABLEND_ON");
			m.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			m.renderQueue = -1;
		}

		private static void SetStandardCutout(Material m, float cutoff)
		{
			m.SetOverrideTag("RenderType", "TransparentCutout");
			m.SetFloat("_Mode", 1f);
			if (m.HasProperty("_Cutoff"))
			{
				m.SetFloat("_Cutoff", cutoff);
			}
			m.SetInt("_SrcBlend", 1);
			m.SetInt("_DstBlend", 0);
			m.SetInt("_ZWrite", 1);
			m.EnableKeyword("_ALPHATEST_ON");
			m.DisableKeyword("_ALPHABLEND_ON");
			m.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			m.renderQueue = 2450;
		}

		private static void SetStandardFade(Material m)
		{
			m.shader = ModMogulPlugin.fadeShader;
		}

		private static Shader FindFirst(params string[] names)
		{
			foreach (string text in names)
			{
				Shader val = Shader.Find(text);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static void ApplyBlendMaterial(Material m, Texture mainTex)
		{
			//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_00f3: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Standard");
			if ((Object)(object)val != (Object)null)
			{
				m.shader = val;
				if (m.HasProperty("_MainTex"))
				{
					m.SetTexture("_MainTex", mainTex);
				}
				SetStandardFade(m);
				if (m.IsKeywordEnabled("_ALPHABLEND_ON"))
				{
					return;
				}
			}
			Shader val2 = FindFirst("Unlit/Transparent", "Legacy Shaders/Transparent/Diffuse", "Legacy Shaders/Transparent/VertexLit", "Particles/Standard Unlit", "Sprites/Default");
			if ((Object)(object)val2 != (Object)null)
			{
				m.shader = val2;
				if (m.HasProperty("_MainTex"))
				{
					m.SetTexture("_MainTex", mainTex);
				}
				if (m.HasProperty("_Color"))
				{
					Color color = m.GetColor("_Color");
					color.a = 1f;
					m.SetColor("_Color", color);
				}
				m.renderQueue = 3000;
			}
			else
			{
				SetStandardCutout(m, 0.5f);
				if (m.HasProperty("_MainTex"))
				{
					m.SetTexture("_MainTex", mainTex);
				}
			}
		}
	}
	public static class ModListUI
	{
		public static void Populate(TMP_Text text)
		{
			if ((Object)(object)text == (Object)null)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder(4096);
			List<PluginInfo> list = Chainloader.PluginInfos.Select((KeyValuePair<string, PluginInfo> kvp) => kvp.Value).OrderBy<PluginInfo, string>((PluginInfo pi) => pi.Metadata.Name, StringComparer.OrdinalIgnoreCase).ThenBy<PluginInfo, string>((PluginInfo pi) => pi.Metadata.GUID, StringComparer.OrdinalIgnoreCase)
				.ToList();
			stringBuilder.AppendLine($"<b>Mods loaded:</b> {list.Count}");
			foreach (PluginInfo item in list)
			{
				BepInPlugin metadata = item.Metadata;
				stringBuilder.Append("• ");
				stringBuilder.Append(metadata.Name);
				stringBuilder.Append("<color=#AAAAAA>v</color>");
				stringBuilder.Append(metadata.Version);
				stringBuilder.AppendLine();
			}
			List<string> dependencyErrors = Chainloader.DependencyErrors;
			if (dependencyErrors != null && dependencyErrors.Count > 0)
			{
				stringBuilder.AppendLine();
				stringBuilder.AppendLine($"<b><color=#FF6666>Failed to load:</color></b> {dependencyErrors.Count}");
				foreach (string item2 in dependencyErrors.OrderBy<string, string>((string k) => k, StringComparer.OrdinalIgnoreCase))
				{
					stringBuilder.Append("• <b>");
					stringBuilder.Append(item2);
					stringBuilder.AppendLine("</b>");
				}
			}
			text.text = stringBuilder.ToString();
		}

		public static ScrollRect SpawnScrollRect(Transform parent, out Transform contentTransform)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ScrollView", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(ScrollRect),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			val.GetComponent<ScrollRect>().elasticity = 0f;
			val.GetComponent<ScrollRect>().horizontal = false;
			val.GetComponent<ScrollRect>().inertia = false;
			val.GetComponent<ScrollRect>().movementType = (MovementType)2;
			((Graphic)val.GetComponent<Image>()).color = new Color(0.2f, 0.2f, 0.2f, 0.9f);
			GameObject val2 = new GameObject("Viewport", new Type[2]
			{
				typeof(RectTransform),
				typeof(RectMask2D)
			});
			val2.transform.SetParent(val.transform, false);
			val2.GetComponent<RectTransform>().anchorMin = Vector2.one * 0.1f;
			val2.GetComponent<RectTransform>().anchorMax = Vector2.one * 0.9f;
			val2.GetComponent<RectTransform>().offsetMin = Vector2.zero;
			val2.GetComponent<RectTransform>().offsetMax = Vector2.zero;
			GameObject val3 = new GameObject("Content", new Type[3]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			val3.transform.SetParent(val2.transform, false);
			contentTransform = val3.transform;
			val3.GetComponent<RectTransform>().anchorMin = new Vector2(0f, 1f);
			val3.GetComponent<RectTransform>().anchorMax = Vector2.one;
			val3.GetComponent<RectTransform>().pivot = new Vector2(0.5f, 1f);
			val3.GetComponent<RectTransform>().anchoredPosition = Vector2.zero;
			val3.GetComponent<RectTransform>().offsetMin = Vector2.zero;
			val3.GetComponent<RectTransform>().offsetMax = Vector2.zero;
			ScrollRect component = val.GetComponent<ScrollRect>();
			component.viewport = val2.GetComponent<RectTransform>();
			component.content = val3.GetComponent<RectTransform>();
			component.horizontal = false;
			component.vertical = true;
			ContentSizeFitter component2 = val3.GetComponent<ContentSizeFitter>();
			component2.verticalFit = (FitMode)2;
			return component;
		}
	}
	[BepInPlugin("modmogul.core", "Mod Mogul", "0.4.0")]
	public class ModMogulPlugin : BaseUnityPlugin
	{
		private static SettingsSetter _settingsSetter;

		public static Shader fadeShader;

		public static SettingsSetter SettingSetter => _settingsSetter;

		private void Start()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("modmogul.core").PatchAll();
			string text = Path.Combine(Paths.PluginPath, "ModMogul", "modmogul.assets");
			AssetBundle val = AssetBundle.LoadFromFile(text);
			fadeShader = val.LoadAsset<Shader>("Fade");
			((MonoBehaviour)this).StartCoroutine(WaitForMenu());
			_settingsSetter = ((Component)this).gameObject.AddComponent<SettingsSetter>();
		}

		private IEnumerator WaitForMenu()
		{
			Transform menuUI = null;
			while ((Object)(object)menuUI == (Object)null)
			{
				Image[] array = Object.FindObjectsByType<Image>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				foreach (Image c in array)
				{
					if (((Object)((Component)c).gameObject).name == "MainMenu")
					{
						menuUI = ((Component)c).transform;
					}
				}
				yield return null;
			}
			Transform content;
			RectTransform modListRectTransform = ((Component)ModListUI.SpawnScrollRect(menuUI, out content)).GetComponent<RectTransform>();
			modListRectTransform.anchorMax = new Vector2(0.95f, 0.8f);
			modListRectTransform.anchorMin = new Vector2(0.75f, 0.3f);
			modListRectTransform.offsetMin = Vector2.zero;
			modListRectTransform.offsetMax = Vector2.zero;
			GameObject modListGo = new GameObject("ModList", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			TMP_Text modsText = modListGo.GetComponent<TMP_Text>();
			modsText.horizontalAlignment = (HorizontalAlignmentOptions)1;
			modsText.fontSize = 14f;
			modsText.transform.SetParent(content, false);
			((Graphic)modsText).color = new Color(0.7765f, 0.6196f, 0.2588f);
			((Component)modsText).GetComponent<RectTransform>().anchorMin = Vector2.zero;
			((Component)modsText).GetComponent<RectTransform>().anchorMax = Vector2.one;
			((Component)modsText).GetComponent<RectTransform>().offsetMin = Vector2.zero;
			((Component)modsText).GetComponent<RectTransform>().offsetMax = Vector2.zero;
			ModListUI.Populate(modsText);
			string path = Path.Combine(Paths.PluginPath, "ModMogul", "ModMogul_Logo.png");
			Sprite modMogulLogo = Utility.ImportSprite(path);
			Image[] array2 = Object.FindObjectsByType<Image>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (Image i in array2)
			{
				if (((Object)((Component)i).gameObject).name == "Logo")
				{
					i.sprite = modMogulLogo;
					break;
				}
			}
			yield return null;
			((Component)Object.FindFirstObjectByType<SavingLoadingManager>()).SendMessage("Awake");
			((MonoBehaviour)this).StartCoroutine(WaitForReturnToMenu());
		}

		private IEnumerator WaitForReturnToMenu()
		{
			while (true)
			{
				SceneManager.GetActiveScene();
				if (false)
				{
					yield return null;
					continue;
				}
				break;
			}
			Scene activeScene;
			while (true)
			{
				activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name.ToLower() != "gameplay")
				{
					yield return null;
					continue;
				}
				break;
			}
			while (true)
			{
				activeScene = SceneManager.GetActiveScene();
				if (!(((Scene)(ref activeScene)).name.ToLower() == "gameplay"))
				{
					break;
				}
				yield return null;
			}
			((MonoBehaviour)this).StartCoroutine(WaitForMenu());
		}
	}
	internal class ModMogulSettingsManager : MonoBehaviour
	{
		private void OnEnable()
		{
			ModMogulPlugin.SettingSetter.UpdateUI();
		}
	}
	public class SettingsSetter : MonoBehaviour
	{
		protected class ModSettings
		{
			public string modName;

			public Transform modLabel;

			public List<BaseSettingOption> settings;
		}

		private GameObject generalSettingsView;

		private GameObject settingsTab;

		private GameObject settingsView;

		private Transform settingsContent = null;

		private List<ModSettings> modSettings;

		private void Awake()
		{
			((MonoBehaviour)this).StartCoroutine(WaitForMenu());
		}

		private IEnumerator WaitForMenu()
		{
			while ((Object)(object)settingsContent == (Object)null)
			{
				ScrollRect[] array = Object.FindObjectsByType<ScrollRect>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				foreach (ScrollRect s in array)
				{
					if (((Object)((Component)s).gameObject).name == "GeneralScrollView")
					{
						generalSettingsView = ((Component)s).gameObject;
						settingsView = Object.Instantiate<GameObject>(((Component)s).gameObject, ((Component)s).transform.parent);
						((Object)settingsView).name = "ModSettingsView";
						Transform[] componentsInChildren = settingsView.GetComponentsInChildren<Transform>();
						foreach (Transform t3 in componentsInChildren)
						{
							if (!(((Object)t3).name == "Content"))
							{
								continue;
							}
							settingsContent = ((Component)t3).transform;
							Transform[] componentsInChildren2 = ((Component)t3).GetComponentsInChildren<Transform>();
							foreach (Transform tr in componentsInChildren2)
							{
								if (!((Object)(object)tr == (Object)(object)t3))
								{
									Object.Destroy((Object)(object)((Component)tr).gameObject);
								}
							}
							break;
						}
					}
					if (!((Object)(object)settingsContent != (Object)null))
					{
						continue;
					}
					UIButtonSounds[] array2 = Object.FindObjectsByType<UIButtonSounds>((FindObjectsInactive)1, (FindObjectsSortMode)0);
					foreach (UIButtonSounds b in array2)
					{
						if (!(((Object)b).name == "AccessibilityTabButton"))
						{
							continue;
						}
						foreach (Transform item in ((Component)b).transform.parent)
						{
							Transform t2 = item;
							((UnityEvent)((Component)t2).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
							{
								settingsView.SetActive(false);
							});
						}
						settingsTab = Object.Instantiate<GameObject>(((Component)b).gameObject, ((Component)b).transform.parent);
						settingsTab.GetComponentInChildren<TMP_Text>().text = "Mods";
						((UnityEventBase)settingsTab.GetComponent<Button>().onClick).RemoveAllListeners();
						foreach (Transform item2 in settingsView.transform.parent)
						{
							Transform t = item2;
							if (((Object)t).name.ToLower().Contains("view"))
							{
								((UnityEvent)settingsTab.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
								{
									((Component)t).gameObject.SetActive(false);
								});
							}
						}
						((UnityEvent)settingsTab.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
						{
							settingsView.SetActive(true);
						});
					}
					break;
				}
				yield return null;
			}
			settingsView.SetActive(false);
		}

		public void UpdateUI()
		{
			int num = 0;
			foreach (ModSettings modSetting in modSettings)
			{
				modSetting.modLabel.SetSiblingIndex(num++);
				foreach (BaseSettingOption setting in modSetting.settings)
				{
					((Component)setting).transform.SetSiblingIndex(num++);
				}
			}
		}

		private ModSettings SetupModSettings(string modName)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			if (this.modSettings == null)
			{
				this.modSettings = new List<ModSettings>();
			}
			ModSettings modSettings = null;
			foreach (ModSettings modSetting in this.modSettings)
			{
				if (modSetting.modName == modName)
				{
					modSettings = modSetting;
					break;
				}
			}
			if (modSettings == null)
			{
				GameObject val = null;
				RectTransform[] componentsInChildren = generalSettingsView.GetComponentsInChildren<RectTransform>(true);
				foreach (RectTransform val2 in componentsInChildren)
				{
					if (Object.op_Implicit((Object)(object)((Component)val2).GetComponent<SettingToggle>()))
					{
						val = ((Component)val2).gameObject;
						break;
					}
				}
				GameObject val3 = new GameObject(modName, new Type[1] { typeof(RectTransform) });
				val3.transform.SetParent(settingsContent, false);
				RectTransform component = val3.GetComponent<RectTransform>();
				component.anchorMin = Vector2.op_Implicit(Vector3.zero);
				component.anchorMax = Vector2.op_Implicit(Vector3.zero);
				component.offsetMin = Vector2.op_Implicit(Vector3.zero);
				component.offsetMax = Vector2.op_Implicit(Vector3.zero);
				component.sizeDelta = new Vector2(0f, 50f);
				Object.Instantiate<GameObject>(((Component)val.GetComponentInChildren<TMP_Text>()).gameObject, val3.transform);
				TMP_Text componentInChildren = val3.GetComponentInChildren<TMP_Text>();
				component = ((Component)componentInChildren).GetComponent<RectTransform>();
				component.anchorMin = Vector2.op_Implicit(Vector3.zero);
				component.anchorMax = Vector2.op_Implicit(Vector3.one);
				component.offsetMin = Vector2.op_Implicit(Vector3.zero);
				component.offsetMax = Vector2.op_Implicit(Vector3.zero);
				componentInChildren.transform.localScale = Vector3.one;
				componentInChildren.text = modName;
				componentInChildren.alignment = (TextAlignmentOptions)514;
				modSettings = new ModSettings
				{
					modName = modName,
					modLabel = val3.transform,
					settings = new List<BaseSettingOption>()
				};
				this.modSettings.Add(modSettings);
			}
			return modSettings;
		}

		public void RegisterToggleSetting(string settingName, string settingKey, bool defaultValue = false)
		{
			string name = Assembly.GetCallingAssembly().GetName().Name;
			((MonoBehaviour)this).StartCoroutine(WaitForSettings(name, settingName, settingKey, defaultValue));
		}

		private IEnumerator WaitForSettings(string modName, string settingName, string settingKey, bool defaultValue)
		{
			while ((Object)(object)settingsContent == (Object)null)
			{
				yield return null;
			}
			ModSettings settings = SetupModSettings(modName);
			GameObject template = null;
			RectTransform[] componentsInChildren = generalSettingsView.GetComponentsInChildren<RectTransform>(true);
			foreach (RectTransform r in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)((Component)r).GetComponent<SettingToggle>()))
				{
					template = ((Component)r).gameObject;
					break;
				}
			}
			GameObject toggleSettingPrefab = Object.Instantiate<GameObject>(template, settingsContent);
			((Object)toggleSettingPrefab).name = settingName;
			ModSettingsToggle toggle = toggleSettingPrefab.AddComponent<ModSettingsToggle>();
			Transform[] componentsInChildren2 = toggleSettingPrefab.GetComponentsInChildren<Transform>();
			foreach (Transform t in componentsInChildren2)
			{
				if (Object.op_Implicit((Object)(object)((Component)t).GetComponent<Toggle>()))
				{
					toggle.toggle = ((Component)t).GetComponent<Toggle>();
				}
				if (((Object)t).name == "OnOff")
				{
					toggle._onOffLabel = ((Component)t).GetComponent<TMP_Text>();
				}
				if (((Object)t).name == "Title")
				{
					((Component)t).GetComponent<TMP_Text>().text = settingName;
				}
			}
			toggle.defaultValue = defaultValue;
			toggle.settingKey = settingKey;
			Object.Destroy((Object)(object)toggleSettingPrefab.GetComponent<SettingToggle>());
			settings.settings.Add((BaseSettingOption)(object)toggle);
		}
	}
	public class ModSettingsToggle : BaseSettingOption
	{
		public Toggle toggle;

		public TMP_Text _onOffLabel;

		public string settingKey = "UnnamedBoolSetting";

		public bool defaultValue = true;

		public string onText = "On";

		public string offText = "Off";

		public Action<bool> onValueChanged;

		private bool _suppressEvents;

		private void Awake()
		{
			bool flag = PlayerPrefs.GetInt(settingKey, defaultValue ? 1 : 0) == 1;
			toggle.isOn = flag;
			UpdateLabel(flag);
		}

		protected override void OnEnable()
		{
			((BaseSettingOption)this).OnEnable();
			((UnityEvent<bool>)(object)toggle.onValueChanged).AddListener((UnityAction<bool>)OnToggleChanged);
		}

		private void OnDisable()
		{
			((UnityEvent<bool>)(object)toggle.onValueChanged).RemoveListener((UnityAction<bool>)OnToggleChanged);
		}

		private void OnToggleChanged(bool value)
		{
			if (!_suppressEvents)
			{
				SaveAndApply(value);
			}
		}

		private void SaveAndApply(bool value)
		{
			PlayerPrefs.SetInt(settingKey, value ? 1 : 0);
			UpdateLabel(value);
			onValueChanged?.Invoke(value);
		}

		private void UpdateLabel(bool value)
		{
			if ((Object)(object)_onOffLabel != (Object)null)
			{
				_onOffLabel.text = (value ? onText : offText);
			}
		}

		public void RefreshFromSaved()
		{
			bool flag = PlayerPrefs.GetInt(settingKey, defaultValue ? 1 : 0) == 1;
			_suppressEvents = true;
			toggle.isOn = flag;
			_suppressEvents = false;
			UpdateLabel(flag);
		}
	}
	internal class Utility
	{
		public static Sprite ImportSprite(string path, bool flipVertically = true)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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 (string.IsNullOrEmpty(path))
			{
				return GenerateFallbackSprite();
			}
			if (!File.Exists(path))
			{
				Debug.LogError((object)("File not found: " + path));
				return GenerateFallbackSprite();
			}
			byte[] data = File.ReadAllBytes(path);
			ImageResult imageResult = ImageResult.FromMemory(data, ColorComponents.RedGreenBlueAlpha);
			Texture2D val = new Texture2D(imageResult.Width, imageResult.Height, (TextureFormat)4, false, false);
			((Texture)val).filterMode = (FilterMode)0;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color32[] array = (Color32[])(object)new Color32[imageResult.Width * imageResult.Height];
			byte[] data2 = imageResult.Data;
			int num = 0;
			int num2 = 0;
			while (num < array.Length)
			{
				array[num] = new Color32(data2[num2], data2[num2 + 1], data2[num2 + 2], data2[num2 + 3]);
				num++;
				num2 += 4;
			}
			if (flipVertically)
			{
				FlipVertically(array, imageResult.Width, imageResult.Height);
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
		}

		private static Sprite GenerateFallbackSprite()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(4, 4, (TextureFormat)4, false, false);
			((Texture)val).filterMode = (FilterMode)0;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color[] array = (Color[])(object)new Color[16];
			for (int i = 0; i < 4; i++)
			{
				for (int j = 0; j < 4; j++)
				{
					array[i * 4 + j] = (((j % 2 == 0) ^ (i % 2 == 0)) ? Color.purple : Color.black);
				}
			}
			val.SetPixels(array);
			val.Apply(false, false);
			return Sprite.Create(val, new Rect(0f, 0f, 4f, 4f), new Vector2(0.5f, 0.5f), 100f);
		}

		private static void FlipVertically(Color32[] pixels, int width, int height)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < height / 2; i++)
			{
				int num = i * width;
				int num2 = (height - 1 - i) * width;
				for (int j = 0; j < width; j++)
				{
					Color32 val = pixels[num + j];
					pixels[num + j] = pixels[num2 + j];
					pixels[num2 + j] = val;
				}
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "ModMogul";

		public const string PLUGIN_NAME = "ModMogul";

		public const string PLUGIN_VERSION = "0.3.1";
	}
}
namespace Hebron.Runtime
{
	internal static class CRuntime
	{
		private static readonly string numbers = "0123456789";

		public unsafe static void* malloc(ulong size)
		{
			return malloc((long)size);
		}

		public unsafe static void* malloc(long size)
		{
			IntPtr intPtr = Marshal.AllocHGlobal((int)size);
			MemoryStats.Allocated();
			return intPtr.ToPointer();
		}

		public unsafe static void free(void* a)
		{
			if (a != null)
			{
				IntPtr hglobal = new IntPtr(a);
				Marshal.FreeHGlobal(hglobal);
				MemoryStats.Freed();
			}
		}

		public unsafe static void memcpy(void* a, void* b, long size)
		{
			Buffer.MemoryCopy(b, a, size, size);
		}

		public unsafe static void memcpy(void* a, void* b, ulong size)
		{
			memcpy(a, b, (long)size);
		}

		public unsafe static void memmove(void* a, void* b, long size)
		{
			void* ptr = null;
			try
			{
				ptr = malloc(size);
				memcpy(ptr, b, size);
				memcpy(a, ptr, size);
			}
			finally
			{
				if (ptr != null)
				{
					free(ptr);
				}
			}
		}

		public unsafe static int memcmp(void* a, void* b, long size)
		{
			int num = 0;
			byte* ptr = (byte*)a;
			byte* ptr2 = (byte*)b;
			for (long num2 = 0L; num2 < size; num2++)
			{
				if (*ptr != *ptr2)
				{
					num++;
				}
				ptr++;
				ptr2++;
			}
			return num;
		}

		public unsafe static void memset(void* ptr, int value, long size)
		{
			byte* ptr2 = (byte*)ptr;
			byte b = (byte)value;
			for (long num = 0L; num < size; num++)
			{
				*(ptr2++) = b;
			}
		}

		public unsafe static void memset(void* ptr, int value, ulong size)
		{
			memset(ptr, value, (long)size);
		}

		public static uint _lrotl(uint x, int y)
		{
			return (x << y) | (x >> 32 - y);
		}

		public unsafe static void* realloc(void* a, long newSize)
		{
			if (a == null)
			{
				return malloc(newSize);
			}
			IntPtr pv = new IntPtr(a);
			return Marshal.ReAllocHGlobal(pv, new IntPtr(newSize)).ToPointer();
		}

		public unsafe static void* realloc(void* a, ulong newSize)
		{
			return realloc(a, (long)newSize);
		}

		public static int abs(int v)
		{
			return Math.Abs(v);
		}

		public static double pow(double a, double b)
		{
			return Math.Pow(a, b);
		}

		public static double ldexp(double number, int exponent)
		{
			return number * Math.Pow(2.0, exponent);
		}

		public unsafe static int strcmp(sbyte* src, string token)
		{
			int num = 0;
			for (int i = 0; i < token.Length; i++)
			{
				if (src[i] != token[i])
				{
					num++;
				}
			}
			return num;
		}

		public unsafe static int strncmp(sbyte* src, string token, ulong size)
		{
			int num = 0;
			for (int i = 0; i < Math.Min(token.Length, (int)size); i++)
			{
				if (src[i] != token[i])
				{
					num++;
				}
			}
			return num;
		}

		public unsafe static long strtol(sbyte* start, sbyte** end, int radix)
		{
			int num = 0;
			sbyte* ptr = start;
			while (numbers.IndexOf((char)(*ptr)) != -1)
			{
				ptr++;
				num++;
			}
			long num2 = 0L;
			ptr = start;
			while (num > 0)
			{
				long num3 = numbers.IndexOf((char)(*ptr));
				long num4 = (long)Math.Pow(10.0, num - 1);
				num2 += num3 * num4;
				ptr++;
				num--;
			}
			if (end != null)
			{
				*end = ptr;
			}
			return num2;
		}
	}
	internal static class MemoryStats
	{
		private static int _allocations;

		public static int Allocations => _allocations;

		internal static void Allocated()
		{
			Interlocked.Increment(ref _allocations);
		}

		internal static void Freed()
		{
			Interlocked.Decrement(ref _allocations);
		}
	}
	internal class Utility
	{
		public static T[][] CreateArray<T>(int d1, int d2)
		{
			T[][] array = new T[d1][];
			for (int i = 0; i < d1; i++)
			{
				array[i] = new T[d2];
			}
			return array;
		}
	}
}
namespace StbImageSharp
{
	public class AnimatedFrameResult : ImageResult
	{
		public int DelayInMs { get; set; }
	}
	internal class AnimatedGifEnumerator : IEnumerator<AnimatedFrameResult>, IDisposable, IEnumerator
	{
		private readonly StbImage.stbi__context _context;

		private StbImage.stbi__gif _gif;

		private readonly ColorComponents _colorComponents;

		public ColorComponents ColorComponents => _colorComponents;

		public AnimatedFrameResult Current { get; private set; }

		object IEnumerator.Current => Current;

		public AnimatedGifEnumerator(Stream input, ColorComponents colorComponents)
		{
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			_context = new StbImage.stbi__context(input);
			if (StbImage.stbi__gif_test(_context) == 0)
			{
				throw new Exception("Input stream is not GIF file.");
			}
			_gif = new StbImage.stbi__gif();
			_colorComponents = colorComponents;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		public unsafe bool MoveNext()
		{
			int num = default(int);
			byte b = default(byte);
			byte* ptr = StbImage.stbi__gif_load_next(_context, _gif, &num, (int)ColorComponents, &b);
			if (ptr == null)
			{
				return false;
			}
			if (Current == null)
			{
				Current = new AnimatedFrameResult
				{
					Width = _gif.w,
					Height = _gif.h,
					SourceComp = (ColorComponents)num,
					Comp = ((ColorComponents == ColorComponents.Default) ? ((ColorComponents)num) : ColorComponents)
				};
				Current.Data = new byte[Current.Width * Current.Height * (int)Current.Comp];
			}
			Current.DelayInMs = _gif.delay;
			Marshal.Copy(new IntPtr(ptr), Current.Data, 0, Current.Data.Length);
			return true;
		}

		public void Reset()
		{
			throw new NotImplementedException();
		}

		~AnimatedGifEnumerator()
		{
			Dispose(disposing: false);
		}

		protected unsafe virtual void Dispose(bool disposing)
		{
			if (_gif != null)
			{
				if (_gif._out_ != null)
				{
					CRuntime.free(_gif._out_);
					_gif._out_ = null;
				}
				if (_gif.history != null)
				{
					CRuntime.free(_gif.history);
					_gif.history = null;
				}
				if (_gif.background != null)
				{
					CRuntime.free(_gif.background);
					_gif.background = null;
				}
				_gif = null;
			}
		}
	}
	internal class AnimatedGifEnumerable : IEnumerable<AnimatedFrameResult>, IEnumerable
	{
		private readonly Stream _input;

		private readonly ColorComponents _colorComponents;

		public ColorComponents ColorComponents => _colorComponents;

		public AnimatedGifEnumerable(Stream input, ColorComponents colorComponents)
		{
			_input = input;
			_colorComponents = colorComponents;
		}

		public IEnumerator<AnimatedFrameResult> GetEnumerator()
		{
			return new AnimatedGifEnumerator(_input, ColorComponents);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public enum ColorComponents
	{
		Default,
		Grey,
		GreyAlpha,
		RedGreenBlue,
		RedGreenBlueAlpha
	}
	public struct ImageInfo
	{
		public int Width;

		public int Height;

		public ColorComponents ColorComponents;

		public int BitsPerChannel;

		public unsafe static ImageInfo? FromStream(Stream stream)
		{
			StbImage.stbi__context s = new StbImage.stbi__context(stream);
			bool flag = StbImage.stbi__is_16_main(s) == 1;
			StbImage.stbi__rewind(s);
			int width = default(int);
			int height = default(int);
			int colorComponents = default(int);
			int num = StbImage.stbi__info_main(s, &width, &height, &colorComponents);
			StbImage.stbi__rewind(s);
			if (num == 0)
			{
				return null;
			}
			ImageInfo value = default(ImageInfo);
			value.Width = width;
			value.Height = height;
			value.ColorComponents = (ColorComponents)colorComponents;
			value.BitsPerChannel = (flag ? 16 : 8);
			return value;
		}
	}
	public class ImageResult
	{
		public int Width { get; set; }

		public int Height { get; set; }

		public ColorComponents SourceComp { get; set; }

		public ColorComponents Comp { get; set; }

		public byte[] Data { get; set; }

		internal unsafe static ImageResult FromResult(byte* result, int width, int height, ColorComponents comp, ColorComponents req_comp)
		{
			if (result == null)
			{
				throw new InvalidOperationException(StbImage.stbi__g_failure_reason);
			}
			ImageResult imageResult = new ImageResult
			{
				Width = width,
				Height = height,
				SourceComp = comp,
				Comp = ((req_comp == ColorComponents.Default) ? comp : req_comp)
			};
			imageResult.Data = new byte[width * height * (int)imageResult.Comp];
			Marshal.Copy(new IntPtr(result), imageResult.Data, 0, imageResult.Data.Length);
			return imageResult;
		}

		public unsafe static ImageResult FromStream(Stream stream, ColorComponents requiredComponents = ColorComponents.Default)
		{
			byte* ptr = null;
			try
			{
				StbImage.stbi__context s = new StbImage.stbi__context(stream);
				int width = default(int);
				int height = default(int);
				int comp = default(int);
				ptr = StbImage.stbi__load_and_postprocess_8bit(s, &width, &height, &comp, (int)requiredComponents);
				return FromResult(ptr, width, height, (ColorComponents)comp, requiredComponents);
			}
			finally
			{
				if (ptr != null)
				{
					CRuntime.free(ptr);
				}
			}
		}

		public static ImageResult FromMemory(byte[] data, ColorComponents requiredComponents = ColorComponents.Default)
		{
			using MemoryStream stream = new MemoryStream(data);
			return FromStream(stream, requiredComponents);
		}

		public static IEnumerable<AnimatedFrameResult> AnimatedGifFramesFromStream(Stream stream, ColorComponents requiredComponents = ColorComponents.Default)
		{
			return new AnimatedGifEnumerable(stream, requiredComponents);
		}
	}
	public class ImageResultFloat
	{
		public int Width { get; set; }

		public int Height { get; set; }

		public ColorComponents SourceComp { get; set; }

		public ColorComponents Comp { get; set; }

		public float[] Data { get; set; }

		internal unsafe static ImageResultFloat FromResult(float* result, int width, int height, ColorComponents comp, ColorComponents req_comp)
		{
			if (result == null)
			{
				throw new InvalidOperationException(StbImage.stbi__g_failure_reason);
			}
			ImageResultFloat imageResultFloat = new ImageResultFloat
			{
				Width = width,
				Height = height,
				SourceComp = comp,
				Comp = ((req_comp == ColorComponents.Default) ? comp : req_comp)
			};
			imageResultFloat.Data = new float[width * height * (int)imageResultFloat.Comp];
			Marshal.Copy(new IntPtr(result), imageResultFloat.Data, 0, imageResultFloat.Data.Length);
			return imageResultFloat;
		}

		public unsafe static ImageResultFloat FromStream(Stream stream, ColorComponents requiredComponents = ColorComponents.Default)
		{
			float* ptr = null;
			try
			{
				StbImage.stbi__context s = new StbImage.stbi__context(stream);
				int width = default(int);
				int height = default(int);
				int comp = default(int);
				ptr = StbImage.stbi__loadf_main(s, &width, &height, &comp, (int)requiredComponents);
				return FromResult(ptr, width, height, (ColorComponents)comp, requiredComponents);
			}
			finally
			{
				if (ptr != null)
				{
					CRuntime.free(ptr);
				}
			}
		}

		public static ImageResultFloat FromMemory(byte[] data, ColorComponents requiredComponents = ColorComponents.Default)
		{
			using MemoryStream stream = new MemoryStream(data);
			return FromStream(stream, requiredComponents);
		}
	}
	public static class StbImage
	{
		public class stbi__context
		{
			private readonly Stream _stream;

			public byte[] _tempBuffer;

			public int img_n = 0;

			public int img_out_n = 0;

			public uint img_x = 0u;

			public uint img_y = 0u;

			public Stream Stream => _stream;

			public stbi__context(Stream stream)
			{
				if (stream == null)
				{
					throw new ArgumentNullException("stream");
				}
				_stream = stream;
			}
		}

		public struct stbi__bmp_data
		{
			public int bpp;

			public int offset;

			public int hsz;

			public uint mr;

			public uint mg;

			public uint mb;

			public uint ma;

			public uint all_a;

			public int extra_read;
		}

		public struct stbi__result_info
		{
			public int bits_per_channel;

			public int num_channels;

			public int channel_order;
		}

		public class stbi__gif
		{
			public unsafe byte* _out_;

			public unsafe byte* background;

			public int bgindex;

			public stbi__gif_lzw[] codes = new stbi__gif_lzw[8192];

			public byte[][] color_table;

			public int cur_x;

			public int cur_y;

			public int delay;

			public int eflags;

			public int flags;

			public int h;

			public unsafe byte* history;

			public int lflags;

			public int line_size;

			public byte[][] lpal = Utility.CreateArray<byte>(256, 4);

			public int max_x;

			public int max_y;

			public byte[][] pal = Utility.CreateArray<byte>(256, 4);

			public int parse;

			public int ratio;

			public int start_x;

			public int start_y;

			public int step;

			public int transparent;

			public int w;
		}

		public struct stbi__gif_lzw
		{
			public short prefix;

			public byte first;

			public byte suffix;
		}

		public unsafe delegate void delegate0(byte* arg0, int arg1, short* arg2);

		public unsafe delegate void delegate1(byte* arg0, byte* arg1, byte* arg2, byte* arg3, int arg4, int arg5);

		public unsafe delegate byte* delegate2(byte* arg0, byte* arg1, byte* arg2, int arg3, int arg4);

		public struct stbi__huffman
		{
			public unsafe fixed byte fast[512];

			public unsafe fixed ushort code[256];

			public unsafe fixed byte values[256];

			public unsafe fixed byte size[257];

			public unsafe fixed uint maxcode[18];

			public unsafe fixed int delta[17];
		}

		public class stbi__jpeg
		{
			public struct unnamed1
			{
				public int id;

				public int h;

				public int v;

				public int tq;

				public int hd;

				public int ha;

				public int dc_pred;

				public int x;

				public int y;

				public int w2;

				public int h2;

				public unsafe byte* data;

				public unsafe void* raw_data;

				public unsafe void* raw_coeff;

				public unsafe byte* linebuf;

				public unsafe short* coeff;

				public int coeff_w;

				public int coeff_h;
			}

			public int app14_color_transform;

			public int code_bits;

			public uint code_buffer;

			public ushort[][] dequant = Utility.CreateArray<ushort>(4, 64);

			public int eob_run;

			public short[][] fast_ac = Utility.CreateArray<short>(4, 512);

			public stbi__huffman[] huff_ac = new stbi__huffman[4];

			public stbi__huffman[] huff_dc = new stbi__huffman[4];

			public delegate0 idct_block_kernel;

			public unnamed1[] img_comp = new unnamed1[4];

			public int img_h_max;

			public int img_mcu_h;

			public int img_mcu_w;

			public int img_mcu_x;

			public int img_mcu_y;

			public int img_v_max;

			public int jfif;

			public byte marker;

			public int nomore;

			public int[] order = new int[4];

			public int progressive;

			public delegate2 resample_row_hv_2_kernel;

			public int restart_interval;

			public int rgb;

			public stbi__context s;

			public int scan_n;

			public int spec_end;

			public int spec_start;

			public int succ_high;

			public int succ_low;

			public int todo;

			public delegate1 YCbCr_to_RGB_kernel;
		}

		public class stbi__resample
		{
			public int hs;

			public unsafe byte* line0;

			public unsafe byte* line1;

			public delegate2 resample;

			public int vs;

			public int w_lores;

			public int ypos;

			public int ystep;
		}

		public class stbi__png
		{
			public unsafe byte* _out_;

			public int depth;

			public unsafe byte* expanded;

			public unsafe byte* idata;

			public stbi__context s;
		}

		public struct stbi__pngchunk
		{
			public uint length;

			public uint type;
		}

		public struct stbi__zbuf
		{
			public unsafe byte* zbuffer;

			public unsafe byte* zbuffer_end;

			public int num_bits;

			public int hit_zeof_once;

			public uint code_buffer;

			public unsafe sbyte* zout;

			public unsafe sbyte* zout_start;

			public unsafe sbyte* zout_end;

			public int z_expandable;

			public stbi__zhuffman z_length;

			public stbi__zhuffman z_distance;
		}

		public struct stbi__zhuffman
		{
			public unsafe fixed ushort fast[512];

			public unsafe fixed ushort firstcode[16];

			public unsafe fixed int maxcode[17];

			public unsafe fixed ushort firstsymbol[16];

			public unsafe fixed byte size[288];

			public unsafe fixed ushort value[288];
		}

		public static string stbi__g_failure_reason;

		public static readonly char[] stbi__parse_png_file_invalid_chunk = new char[25];

		public const int STBI_default = 0;

		public const int STBI_grey = 1;

		public const int STBI_grey_alpha = 2;

		public const int STBI_rgb = 3;

		public const int STBI_rgb_alpha = 4;

		public const int STBI_ORDER_RGB = 0;

		public const int STBI_ORDER_BGR = 1;

		public const int STBI__SCAN_load = 0;

		public const int STBI__SCAN_type = 1;

		public const int STBI__SCAN_header = 2;

		public static int stbi__vertically_flip_on_load_global;

		public static int stbi__vertically_flip_on_load_local;

		public static int stbi__vertically_flip_on_load_set;

		public static float stbi__l2h_gamma = 2.2f;

		public static float stbi__l2h_scale = 1f;

		public static float stbi__h2l_gamma_i = 0.45454544f;

		public static float stbi__h2l_scale_i = 1f;

		public static int stbi__unpremultiply_on_load_global;

		public static int stbi__de_iphone_flag_global;

		public static int stbi__unpremultiply_on_load_local;

		public static int stbi__unpremultiply_on_load_set;

		public static int stbi__de_iphone_flag_local;

		public static int stbi__de_iphone_flag_set;

		public static byte[] stbi__process_marker_tag = new byte[6] { 65, 100, 111, 98, 101, 0 };

		public static byte[] stbi__process_frame_header_rgb = new byte[3] { 82, 71, 66 };

		public static byte[] stbi__compute_huffman_codes_length_dezigzag = new byte[19]
		{
			16, 17, 18, 0, 8, 7, 9, 6, 10, 5,
			11, 4, 12, 3, 13, 2, 14, 1, 15
		};

		public static int[] stbi__shiftsigned_mul_table = new int[9] { 0, 255, 85, 73, 17, 33, 65, 129, 1 };

		public static int[] stbi__shiftsigned_shift_table = new int[9] { 0, 0, 0, 1, 0, 2, 4, 6, 0 };

		public static uint[] stbi__bmask = new uint[17]
		{
			0u, 1u, 3u, 7u, 15u, 31u, 63u, 127u, 255u, 511u,
			1023u, 2047u, 4095u, 8191u, 16383u, 32767u, 65535u
		};

		public static int[] stbi__jbias = new int[16]
		{
			0, -1, -3, -7, -15, -31, -63, -127, -255, -511,
			-1023, -2047, -4095, -8191, -16383, -32767
		};

		public static byte[] stbi__jpeg_dezigzag = new byte[79]
		{
			0, 1, 8, 16, 9, 2, 3, 10, 17, 24,
			32, 25, 18, 11, 4, 5, 12, 19, 26, 33,
			40, 48, 41, 34, 27, 20, 13, 6, 7, 14,
			21, 28, 35, 42, 49, 56, 57, 50, 43, 36,
			29, 22, 15, 23, 30, 37, 44, 51, 58, 59,
			52, 45, 38, 31, 39, 46, 53, 60, 61, 54,
			47, 55, 62, 63, 63, 63, 63, 63, 63, 63,
			63, 63, 63, 63, 63, 63, 63, 63, 63
		};

		public const int STBI__F_none = 0;

		public const int STBI__F_sub = 1;

		public const int STBI__F_up = 2;

		public const int STBI__F_avg = 3;

		public const int STBI__F_paeth = 4;

		public const int STBI__F_avg_first = 5;

		public static byte[] first_row_filter = new byte[5] { 0, 1, 0, 5, 1 };

		public static byte[] stbi__check_png_header_png_sig = new byte[8] { 137, 80, 78, 71, 13, 10, 26, 10 };

		public static byte[] stbi__depth_scale_table = new byte[9] { 0, 255, 85, 0, 17, 0, 0, 0, 1 };

		public static byte[] stbi__zdefault_distance = new byte[32]
		{
			5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5
		};

		public static byte[] stbi__zdefault_length = new byte[288]
		{
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
			9, 9, 9, 9, 9, 9, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			8, 8, 8, 8, 8, 8, 8, 8
		};

		public static int[] stbi__zdist_base = new int[32]
		{
			1, 2, 3, 4, 5, 7, 9, 13, 17, 25,
			33, 49, 65, 97, 129, 193, 257, 385, 513, 769,
			1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577,
			0, 0
		};

		public static int[] stbi__zdist_extra = new int[32]
		{
			0, 0, 0, 0, 1, 1, 2, 2, 3, 3,
			4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
			9, 9, 10, 10, 11, 11, 12, 12, 13, 13,
			0, 0
		};

		public static int[] stbi__zlength_base = new int[31]
		{
			3, 4, 5, 6, 7, 8, 9, 10, 11, 13,
			15, 17, 19, 23, 27, 31, 35, 43, 51, 59,
			67, 83, 99, 115, 131, 163, 195, 227, 258, 0,
			0
		};

		public static int[] stbi__zlength_extra = new int[31]
		{
			0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
			1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
			4, 4, 4, 4, 5, 5, 5, 5, 0, 0,
			0
		};

		public static int NativeAllocations => MemoryStats.Allocations;

		private static int stbi__err(string str)
		{
			stbi__g_failure_reason = str;
			return 0;
		}

		public static byte stbi__get8(stbi__context s)
		{
			int num = s.Stream.ReadByte();
			if (num == -1)
			{
				return 0;
			}
			return (byte)num;
		}

		public static void stbi__skip(stbi__context s, int skip)
		{
			s.Stream.Seek(skip, SeekOrigin.Current);
		}

		public static void stbi__rewind(stbi__context s)
		{
			s.Stream.Seek(0L, SeekOrigin.Begin);
		}

		public static int stbi__at_eof(stbi__context s)
		{
			return (s.Stream.Position == s.Stream.Length) ? 1 : 0;
		}

		public unsafe static int stbi__getn(stbi__context s, byte* buf, int size)
		{
			if (s._tempBuffer == null || s._tempBuffer.Length < size)
			{
				s._tempBuffer = new byte[size * 2];
			}
			int num = s.Stream.Read(s._tempBuffer, 0, size);
			Marshal.Copy(s._tempBuffer, 0, new IntPtr(buf), num);
			return num;
		}

		public static int stbi__bmp_test(stbi__context s)
		{
			int result = stbi__bmp_test_raw(s);
			stbi__rewind(s);
			return result;
		}

		public unsafe static void* stbi__bmp_load(stbi__context s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri)
		{
			uint num = 0u;
			uint num2 = 0u;
			uint num3 = 0u;
			uint num4 = 0u;
			uint num5 = 0u;
			byte[][] array = Utility.CreateArray<byte>(256, 4);
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			int num10 = 0;
			int num11 = 0;
			int num12 = 0;
			stbi__bmp_data stbi__bmp_data = default(stbi__bmp_data);
			stbi__bmp_data.all_a = 255u;
			if (stbi__bmp_parse_header(s, &stbi__bmp_data) == null)
			{
				return null;
			}
			num10 = (((int)s.img_y > 0) ? 1 : 0);
			s.img_y = (uint)CRuntime.abs((int)s.img_y);
			if (s.img_y > 16777216)
			{
				return (void*)(int)((stbi__err("too large") != 0) ? 0u : 0u);
			}
			if (s.img_x > 16777216)
			{
				return (void*)(int)((stbi__err("too large") != 0) ? 0u : 0u);
			}
			num = stbi__bmp_data.mr;
			num2 = stbi__bmp_data.mg;
			num3 = stbi__bmp_data.mb;
			num4 = stbi__bmp_data.ma;
			num5 = stbi__bmp_data.all_a;
			if (stbi__bmp_data.hsz == 12)
			{
				if (stbi__bmp_data.bpp < 24)
				{
					num6 = (stbi__bmp_data.offset - stbi__bmp_data.extra_read - 24) / 3;
				}
			}
			else if (stbi__bmp_data.bpp < 16)
			{
				num6 = stbi__bmp_data.offset - stbi__bmp_data.extra_read - stbi__bmp_data.hsz >> 2;
			}
			if (num6 == 0)
			{
				int num13 = (int)s.Stream.Position;
				int num14 = 1024;
				int num15 = 1024;
				if (num13 <= 0 || num13 > num14)
				{
					return (void*)(int)((stbi__err("bad header") != 0) ? 0u : 0u);
				}
				if (stbi__bmp_data.offset < num13 || stbi__bmp_data.offset - num13 > num15)
				{
					return (void*)(int)((stbi__err("bad offset") != 0) ? 0u : 0u);
				}
				stbi__skip(s, stbi__bmp_data.offset - num13);
			}
			if (stbi__bmp_data.bpp == 24 && num4 == 4278190080u)
			{
				s.img_n = 3;
			}
			else
			{
				s.img_n = ((num4 != 0) ? 4 : 3);
			}
			num12 = ((req_comp == 0 || req_comp < 3) ? s.img_n : req_comp);
			if (stbi__mad3sizes_valid(num12, (int)s.img_x, (int)s.img_y, 0) == 0)
			{
				return (void*)(int)((stbi__err("too large") != 0) ? 0u : 0u);
			}
			byte* ptr = (byte*)stbi__malloc_mad3(num12, (int)s.img_x, (int)s.img_y, 0);
			if (ptr == null)
			{
				return (void*)(int)((stbi__err("outofmem") != 0) ? 0u : 0u);
			}
			if (stbi__bmp_data.bpp < 16)
			{
				int num16 = 0;
				if (num6 == 0 || num6 > 256)
				{
					CRuntime.free(ptr);
					return (void*)(int)((stbi__err("invalid") != 0) ? 0u : 0u);
				}
				for (num7 = 0; num7 < num6; num7++)
				{
					array[num7][2] = stbi__get8(s);
					array[num7][1] = stbi__get8(s);
					array[num7][0] = stbi__get8(s);
					if (stbi__bmp_data.hsz != 12)
					{
						stbi__get8(s);
					}
					array[num7][3] = byte.MaxValue;
				}
				stbi__skip(s, stbi__bmp_data.offset - stbi__bmp_data.extra_read - stbi__bmp_data.hsz - num6 * ((stbi__bmp_data.hsz == 12) ? 3 : 4));
				if (stbi__bmp_data.bpp == 1)
				{
					num9 = (int)(s.img_x + 7 >> 3);
				}
				else if (stbi__bmp_data.bpp == 4)
				{
					num9 = (int)(s.img_x + 1 >> 1);
				}
				else
				{
					if (stbi__bmp_data.bpp != 8)
					{
						CRuntime.free(ptr);
						return (void*)(int)((stbi__err("bad bpp") != 0) ? 0u : 0u);
					}
					num9 = (int)s.img_x;
				}
				num11 = -num9 & 3;
				if (stbi__bmp_data.bpp == 1)
				{
					for (num8 = 0; num8 < (int)s.img_y; num8++)
					{
						int num17 = 7;
						int num18 = stbi__get8(s);
						for (num7 = 0; num7 < (int)s.img_x; num7++)
						{
							int num19 = (num18 >> num17) & 1;
							ptr[num16++] = array[num19][0];
							ptr[num16++] = array[num19][1];
							ptr[num16++] = array[num19][2];
							if (num12 == 4)
							{
								ptr[num16++] = byte.MaxValue;
							}
							if (num7 + 1 == (int)s.img_x)
							{
								break;
							}
							if (--num17 < 0)
							{
								num17 = 7;
								num18 = stbi__get8(s);
							}
						}
						stbi__skip(s, num11);
					}
				}
				else
				{
					for (num8 = 0; num8 < (int)s.img_y; num8++)
					{
						for (num7 = 0; num7 < (int)s.img_x; num7 += 2)
						{
							int num20 = stbi__get8(s);
							int num21 = 0;
							if (stbi__bmp_data.bpp == 4)
							{
								num21 = num20 & 0xF;
								num20 >>= 4;
							}
							ptr[num16++] = array[num20][0];
							ptr[num16++] = array[num20][1];
							ptr[num16++] = array[num20][2];
							if (num12 == 4)
							{
								ptr[num16++] = byte.MaxValue;
							}
							if (num7 + 1 == (int)s.img_x)
							{
								break;
							}
							num20 = ((stbi__bmp_data.bpp == 8) ? stbi__get8(s) : num21);
							ptr[num16++] = array[num20][0];
							ptr[num16++] = array[num20][1];
							ptr[num16++] = array[num20][2];
							if (num12 == 4)
							{
								ptr[num16++] = byte.MaxValue;
							}
						}
						stbi__skip(s, num11);
					}
				}
			}
			else
			{
				int shift = 0;
				int shift2 = 0;
				int shift3 = 0;
				int shift4 = 0;
				int num22 = 0;
				int num23 = 0;
				int num24 = 0;
				int num25 = 0;
				int num26 = 0;
				int num27 = 0;
				stbi__skip(s, stbi__bmp_data.offset - stbi__bmp_data.extra_read - stbi__bmp_data.hsz);
				num9 = (int)((stbi__bmp_data.bpp == 24) ? (3 * s.img_x) : ((stbi__bmp_data.bpp == 16) ? (2 * s.img_x) : 0));
				num11 = -num9 & 3;
				if (stbi__bmp_data.bpp == 24)
				{
					num27 = 1;
				}
				else if (stbi__bmp_data.bpp == 32 && num3 == 255 && num2 == 65280 && num == 16711680 && num4 == 4278190080u)
				{
					num27 = 2;
				}
				if (num27 == 0)
				{
					if (num == 0 || num2 == 0 || num3 == 0)
					{
						CRuntime.free(ptr);
						return (void*)(int)((stbi__err("bad masks") != 0) ? 0u : 0u);
					}
					shift = stbi__high_bit(num) - 7;
					num22 = stbi__bitcount(num);
					shift2 = stbi__high_bit(num2) - 7;
					num23 = stbi__bitcount(num2);
					shift3 = stbi__high_bit(num3) - 7;
					num24 = stbi__bitcount(num3);
					shift4 = stbi__high_bit(num4) - 7;
					num25 = stbi__bitcount(num4);
					if (num22 > 8 || num23 > 8 || num24 > 8 || num25 > 8)
					{
						CRuntime.free(ptr);
						return (void*)(int)((stbi__err("bad masks") != 0) ? 0u : 0u);
					}
				}
				for (num8 = 0; num8 < (int)s.img_y; num8++)
				{
					if (num27 != 0)
					{
						for (num7 = 0; num7 < (int)s.img_x; num7++)
						{
							byte b = 0;
							ptr[num26 + 2] = stbi__get8(s);
							ptr[num26 + 1] = stbi__get8(s);
							ptr[num26] = stbi__get8(s);
							num26 += 3;
							b = ((num27 == 2) ? stbi__get8(s) : byte.MaxValue);
							num5 |= b;
							if (num12 == 4)
							{
								ptr[num26++] = b;
							}
						}
					}
					else
					{
						int bpp = stbi__bmp_data.bpp;
						for (num7 = 0; num7 < (int)s.img_x; num7++)
						{
							uint num28 = ((bpp == 16) ? ((uint)stbi__get16le(s)) : stbi__get32le(s));
							uint num29 = 0u;
							ptr[num26++] = (byte)((uint)stbi__shiftsigned(num28 & num, shift, num22) & 0xFFu);
							ptr[num26++] = (byte)((uint)stbi__shiftsigned(num28 & num2, shift2, num23) & 0xFFu);
							ptr[num26++] = (byte)((uint)stbi__shiftsigned(num28 & num3, shift3, num24) & 0xFFu);
							num29 = ((num4 != 0) ? ((uint)stbi__shiftsigned(num28 & num4, shift4, num25)) : 255u);
							num5 |= num29;
							if (num12 == 4)
							{
								ptr[num26++] = (byte)(num29 & 0xFFu);
							}
						}
					}
					stbi__skip(s, num11);
				}
			}
			if (num12 == 4 && num5 == 0)
			{
				for (num7 = (int)(4 * s.img_x * s.img_y - 1); num7 >= 0; num7 -= 4)
				{
					ptr[num7] = byte.MaxValue;
				}
			}
			if (num10 != 0)
			{
				byte b2 = 0;
				for (num8 = 0; num8 < (int)s.img_y >> 1; num8++)
				{
					byte* ptr2 = ptr + num8 * s.img_x * num12;
					byte* ptr3 = ptr + (s.img_y - 1 - num8) * s.img_x * num12;
					for (num7 = 0; num7 < (int)s.img_x * num12; num7++)
					{
						b2 = ptr2[num7];
						ptr2[num7] = ptr3[num7];
						ptr3[num7] = b2;
					}
				}
			}
			if (req_comp != 0 && req_comp != num12)
			{
				ptr = stbi__convert_format(ptr, num12, req_comp, s.img_x, s.img_y);
				if (ptr == null)
				{
					return ptr;
				}
			}
			*x = (int)s.img_x;
			*y = (int)s.img_y;
			if (comp != null)
			{
				*comp = s.img_n;
			}
			return ptr;
		}

		public unsafe static int stbi__bmp_info(stbi__context s, int* x, int* y, int* comp)
		{
			stbi__bmp_data stbi__bmp_data = default(stbi__bmp_data);
			stbi__bmp_data.all_a = 255u;
			void* ptr = stbi__bmp_parse_header(s, &stbi__bmp_data);
			if (ptr == null)
			{
				stbi__rewind(s);
				return 0;
			}
			if (x != null)
			{
				*x = (int)s.img_x;
			}
			if (y != null)
			{
				*y = (int)s.img_y;
			}
			if (comp != null)
			{
				if (stbi__bmp_data.bpp == 24 && stbi__bmp_data.ma == 4278190080u)
				{
					*comp = 3;
				}
				else
				{
					*comp = ((stbi__bmp_data.ma != 0) ? 4 : 3);
				}
			}
			return 1;
		}

		public static int stbi__bmp_test_raw(stbi__context s)
		{
			int num = 0;
			int num2 = 0;
			if (stbi__get8(s) != 66)
			{
				return 0;
			}
			if (stbi__get8(s) != 77)
			{
				return 0;
			}
			stbi__get32le(s);
			stbi__get16le(s);
			stbi__get16le(s);
			stbi__get32le(s);
			num2 = (int)stbi__get32le(s);
			return (num2 == 12 || num2 == 40 || num2 == 56 || num2 == 108 || num2 == 124) ? 1 : 0;
		}

		public unsafe static int stbi__bmp_set_mask_defaults(stbi__bmp_data* info, int compress)
		{
			switch (compress)
			{
			case 3:
				return 1;
			case 0:
				if (info->bpp == 16)
				{
					info->mr = 31744u;
					info->mg = 992u;
					info->mb = 31u;
				}
				else if (info->bpp == 32)
				{
					info->mr = 16711680u;
					info->mg = 65280u;
					info->mb = 255u;
					info->ma = 4278190080u;
					info->all_a = 0u;
				}
				else
				{
					info->mr = (info->mg = (info->mb = (info->ma = 0u)));
				}
				return 1;
			default:
				return 0;
			}
		}

		public unsafe static void* stbi__bmp_parse_header(stbi__context s, stbi__bmp_data* info)
		{
			int num = 0;
			if (stbi__get8(s) != 66 || stbi__get8(s) != 77)
			{
				return (void*)(int)((stbi__err("not BMP") != 0) ? 0u : 0u);
			}
			stbi__get32le(s);
			stbi__get16le(s);
			stbi__get16le(s);
			info->offset = (int)stbi__get32le(s);
			num = (info->hsz = (int)stbi__get32le(s));
			info->mr = (info->mg = (info->mb = (info->ma = 0u)));
			info->extra_read = 14;
			if (info->offset < 0)
			{
				return (void*)(int)((stbi__err("bad BMP") != 0) ? 0u : 0u);
			}
			if (num != 12 && num != 40 && num != 56 && num != 108 && num != 124)
			{
				return (void*)(int)((stbi__err("unknown BMP") != 0) ? 0u : 0u);
			}
			if (num == 12)
			{
				s.img_x = (uint)stbi__get16le(s);
				s.img_y = (uint)stbi__get16le(s);
			}
			else
			{
				s.img_x = stbi__get32le(s);
				s.img_y = stbi__get32le(s);
			}
			if (stbi__get16le(s) != 1)
			{
				return (void*)(int)((stbi__err("bad BMP") != 0) ? 0u : 0u);
			}
			info->bpp = stbi__get16le(s);
			if (num != 12)
			{
				int num2 = (int)stbi__get32le(s);
				if (num2 == 1 || num2 == 2)
				{
					return (void*)(int)((stbi__err("BMP RLE") != 0) ? 0u : 0u);
				}
				if (num2 >= 4)
				{
					return (void*)(int)((stbi__err("BMP JPEG/PNG") != 0) ? 0u : 0u);
				}
				if (num2 == 3 && info->bpp != 16 && info->bpp != 32)
				{
					return (void*)(int)((stbi__err("bad BMP") != 0) ? 0u : 0u);
				}
				stbi__get32le(s);
				stbi__get32le(s);
				stbi__get32le(s);
				stbi__get32le(s);
				stbi__get32le(s);
				if (num == 40 || num == 56)
				{
					if (num == 56)
					{
						stbi__get32le(s);
						stbi__get32le(s);
						stbi__get32le(s);
						stbi__get32le(s);
					}
					if (info->bpp == 16 || info->bpp == 32)
					{
						switch (num2)
						{
						case 0:
							stbi__bmp_set_mask_defaults(info, num2);
							break;
						case 3:
							info->mr = stbi__get32le(s);
							info->mg = stbi__get32le(s);
							info->mb = stbi__get32le(s);
							info->extra_read += 12;
							if (info->mr == info->mg && info->mg == info->mb)
							{
								return (void*)(int)((stbi__err("bad BMP") != 0) ? 0u : 0u);
							}
							break;
						default:
							return (void*)(int)((stbi__err("bad BMP") != 0) ? 0u : 0u);
						}
					}
				}
				else
				{
					int num3 = 0;
					if (num != 108 && num != 124)
					{
						return (void*)(int)((stbi__err("bad BMP") != 0) ? 0u : 0u);
					}
					info->mr = stbi__get32le(s);
					info->mg = stbi__get32le(s);
					info->mb = stbi__get32le(s);
					info->ma = stbi__get32le(s);
					if (num2 != 3)
					{
						stbi__bmp_set_mask_defaults(info, num2);
					}
					stbi__get32le(s);
					for (num3 = 0; num3 < 12; num3++)
					{
						stbi__get32le(s);
					}
					if (num == 124)
					{
						stbi__get32le(s);
						stbi__get32le(s);
						stbi__get32le(s);
						stbi__get32le(s);
					}
				}
			}
			return (void*)1;
		}

		public static void stbi_hdr_to_ldr_gamma(float gamma)
		{
			stbi__h2l_gamma_i = 1f / gamma;
		}

		public static void stbi_hdr_to_ldr_scale(float scale)
		{
			stbi__h2l_scale_i = 1f / scale;
		}

		public static void stbi_ldr_to_hdr_gamma(float gamma)
		{
			stbi__l2h_gamma = gamma;
		}

		public static void stbi_ldr_to_hdr_scale(float scale)
		{
			stbi__l2h_scale = scale;
		}

		public static void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
		{
			stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;
		}

		public static void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
		{
			stbi__de_iphone_flag_global = flag_true_if_should_convert;
		}

		public static void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
		{
			stbi__vertically_flip_on_load_global = flag_true_if_should_flip;
		}

		public static void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
		{
			stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;
			stbi__unpremultiply_on_load_set = 1;
		}

		public static void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)
		{
			stbi__de_iphone_flag_local = flag_true_if_should_convert;
			stbi__de_iphone_flag_set = 1;
		}

		public static void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
		{
			stbi__vertically_flip_on_load_local = flag_true_if_should_flip;
			stbi__vertically_flip_on_load_set = 1;
		}

		public unsafe static void* stbi__malloc(ulong size)
		{
			return CRuntime.malloc(size);
		}

		public static int stbi__addsizes_valid(int a, int b)
		{
			if (b < 0)
			{
				return 0;
			}
			return (a <= int.MaxValue - b) ? 1 : 0;
		}

		public static int stbi__mul2sizes_valid(int a, int b)
		{
			if (a < 0 || b < 0)
			{
				return 0;
			}
			if (b == 0)
			{
				return 1;
			}
			return (a <= int.MaxValue / b) ? 1 : 0;
		}

		public static int stbi__mad2sizes_valid(int a, int b, int add)
		{
			return (stbi__mul2sizes_valid(a, b) != 0 && stbi__addsizes_valid(a * b, add) != 0) ? 1 : 0;
		}

		public static int stbi__mad3sizes_valid(int a, int b, int c, int add)
		{
			return (stbi__mul2sizes_valid(a, b) != 0 && stbi__mul2sizes_valid(a * b, c) != 0 && stbi__addsizes_valid(a * b * c, add) != 0) ? 1 : 0;
		}

		public static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
		{
			return (stbi__mul2sizes_valid(a, b) != 0 && stbi__mul2sizes_valid(a * b, c) != 0 && stbi__mul2sizes_valid(a * b * c, d) != 0 && stbi__addsizes_valid(a * b * c * d, add) != 0) ? 1 : 0;
		}

		public unsafe static void* stbi__malloc_mad2(int a, int b, int add)
		{
			if (stbi__mad2sizes_valid(a, b, add) == 0)
			{
				return null;
			}
			return stbi__malloc((ulong)(a * b + add));
		}

		public unsafe static void* stbi__malloc_mad3(int a, int b, int c, int add)
		{
			if (stbi__mad3sizes_valid(a, b, c, add) == 0)
			{
				return null;
			}
			return stbi__malloc((ulong)(a * b * c + add));
		}

		public unsafe static void* stbi__malloc_mad4(int a, int b, int c, int d, int add)
		{
			if (stbi__mad4sizes_valid(a, b, c, d, add) == 0)
			{
				return null;
			}
			return stbi__malloc((ulong)(a * b * c * d + add));
		}

		public static int stbi__addints_valid(int a, int b)
		{
			if (a >= 0 != b >= 0)
			{
				return 1;
			}
			if (a < 0 && b < 0)
			{
				return (a >= int.MinValue - b) ? 1 : 0;
			}
			return (a <= int.MaxValue - b) ? 1 : 0;
		}

		public static int stbi__mul2shorts_valid(int a, int b)
		{
			if (b == 0 || b == -1)
			{
				return 1;
			}
			if (a >= 0 == b >= 0)
			{
				return (a <= 32767 / b) ? 1 : 0;
			}
			if (b < 0)
			{
				return (a <= -32768 / b) ? 1 : 0;
			}
			return (a >= -32768 / b) ? 1 : 0;
		}

		public unsafe static float* stbi__ldr_to_hdr(byte* data, int x, int y, int comp)
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			if (data == null)
			{
				return null;
			}
			float* ptr = (float*)stbi__malloc_mad4(x, y, comp, 4, 0);
			if (ptr == null)
			{
				CRuntime.free(data);
				return (float*)(int)((stbi__err("outofmem") != 0) ? 0u : 0u);
			}
			num3 = (((comp & 1) == 0) ? (comp - 1) : comp);
			for (num = 0; num < x * y; num++)
			{
				for (num2 = 0; num2 < num3; num2++)
				{
					ptr[num * comp + num2] = (float)(CRuntime.pow((float)(int)data[num * comp + num2] / 255f, stbi__l2h_gamma) * (double)stbi__l2h_scale);
				}
			}
			if (num3 < comp)
			{
				for (num = 0; num < x * y; num++)
				{
					ptr[num * comp + num3] = (float)(int)data[num * comp + num3] / 255f;
				}
			}
			CRuntime.free(data);
			return ptr;
		}

		public unsafe static void* stbi__load_main(stbi__context s, int* x, int* y, int* comp, int req_comp, stbi__result_info* ri, int bpc)
		{
			CRuntime.memset(ri, 0, (ulong)sizeof(stbi__result_info));
			ri->bits_per_channel = 8;
			ri->channel_order = 0;
			ri->num_channels = 0;
			if (stbi__png_test(s) != 0)
			{
				return stbi__png_load(s, x, y, comp, req_comp, ri);
			}
			if (stbi__bmp_test(s) != 0)
			{
				return stbi__bmp_load(s, x, y, comp, req_comp, ri);
			}
			if (stbi__gif_test(s) != 0)
			{
				return stbi__gif_load(s, x, y, comp, req_comp, ri);
			}
			if (stbi__psd_test(s) != 0)
			{
				return stbi__psd_load(s, x, y, comp, req_comp, ri, bpc);
			}
			if (stbi__jpeg_test(s) != 0)
			{
				return stbi__jpeg_load(s, x, y, comp, req_comp, ri);
			}
			if (stbi__hdr_test(s) != 0)
			{
				float* data = stbi__hdr_load(s, x, y, comp, req_comp, ri);
				return stbi__hdr_to_ldr(data, *x, *y, (req_comp != 0) ? req_comp : (*comp));
			}
			if (stbi__tga_test(s) != 0)
			{
				return stbi__tga_load(s, x, y, comp, req_comp, ri);
			}
			return (void*)(int)((stbi__err("unknown image type") != 0) ? 0u : 0u);
		}

		public unsafe static byte* stbi__convert_16_to_8(ushort* orig, int w, int h, int channels)
		{
			int num = 0;
			int num2 = w * h * channels;
			byte* ptr = (byte*)stbi__malloc((ulong)num2);
			if (ptr == null)
			{
				return (byte*)(int)((stbi__err("outofmem") != 0) ? 0u : 0u);
			}
			for (num = 0; num < num2; num++)
			{
				ptr[num] = (byte)((uint)(orig[num] >> 8) & 0xFFu);
			}
			CRuntime.free(orig);
			return ptr;
		}

		public unsafe static ushort* stbi__convert_8_to_16(byte* orig, int w, int h, int channels)
		{
			int num = 0;
			int num2 = w * h * channels;
			ushort* ptr = (ushort*)stbi__malloc((ulong)(num2 * 2));
			if (ptr == null)
			{
				return (ushort*)(int)((stbi__err("outofmem") != 0) ? 0u : 0u);
			}
			for (num = 0; num < num2; num++)
			{
				ptr[num] = (ushort)((orig[num] << 8) + orig[num]);
			}
			CRuntime.free(orig);
			return ptr;
		}

		public unsafe static void stbi__vertical_flip(void* image, int w, int h, int bytes_per_pixel)
		{
			int num = 0;
			int num2 = w * bytes_per_pixel;
			byte* ptr = stackalloc byte[2048];
			for (num = 0; num < h >> 1; num++)
			{
				byte* ptr2 = (byte*)image + num * num2;
				byte* ptr3 = (byte*)image + (h - num - 1) * num2;
				ulong num3 = (ulong)num2;
				while (num3 != 0)
				{
					ulong num4 = ((num3 < 2048) ? num3 : 2048);
					CRuntime.memcpy(ptr, ptr2, num4);
					CRuntime.memcpy(ptr2, ptr3, num4);
					CRuntime.memcpy(ptr3, ptr, num4);
					ptr2 += num4;
					ptr3 += num4;
					num3 -= num4;
				}
			}
		}

		public unsafe static void stbi__vertical_flip_slices(void* image, int w, int h, int z, int bytes_per_pixel)
		{
			int num = 0;
			int num2 = w * h * bytes_per_pixel;
			byte* ptr = (byte*)image;
			for (num = 0; num < z; num++)
			{
				stbi__vertical_flip(ptr, w, h, bytes_per_pixel);
				ptr += num2;
			}
		}

		public unsafe static byte* stbi__load_and_postprocess_8bit(stbi__context s, int* x, int* y, int* comp, int req_comp)
		{
			stbi__result_info stbi__result_info = default(stbi__result_info);
			void* ptr = stbi__load_main(s, x, y, comp, req_comp, &stbi__result_info, 8);
			if (ptr == null)
			{
				return null;
			}
			if (stbi__result_info.bits_per_channel != 8)
			{
				ptr = stbi__convert_16_to_8((ushort*)ptr, *x, *y, (req_comp == 0) ? (*comp) : req_comp);
				stbi__result_info.bits_per_channel = 8;
			}
			if (((stbi__vertically_flip_on_load_set != 0) ? stbi__vertically_flip_on_load_local : stbi__vertically_flip_on_load_global) != 0)
			{
				int bytes_per_pixel = ((req_comp != 0) ? req_comp : (*comp));
				stbi__vertical_flip(ptr, *x, *y, bytes_per_pixel);
			}
			return (byte*)ptr;
		}

		public unsafe static ushort* stbi__load_and_postprocess_16bit(stbi__context s, int* x, int* y, int* comp, int req_comp)
		{
			stbi__result_info stbi__result_info = default(stbi__result_info);
			void* ptr = stbi__load_main(s, x, y, comp, req_comp, &stbi__result_info, 16);
			if (ptr == null)
			{
				return null;
			}
			if (stbi__result_info.bits_per_channel != 16)
			{
				ptr = stbi__convert_8_to_16((byte*)ptr, *x, *y, (req_comp == 0) ? (*comp) : req_comp);
				stbi__result_info.bits_per_channel = 16;
			}
			if (((stbi__vertically_flip_on_load_set != 0) ? stbi__vertically_flip_on_load_local : stbi__vertically_flip_on_load_global) != 0)
			{
				int num = ((req_comp != 0) ? req_comp : (*comp));
				stbi__vertical_flip(ptr, *x, *y, num * 2);
			}
			return (ushort*)ptr;
		}

		public unsafe static void stbi__float_postprocess(float* result, int* x, int* y, int* comp, int req_comp)
		{
			if (((stbi__vertically_flip_on_load_set != 0) ? stbi__vertically_flip_on_load_local : stbi__vertically_flip_on_load_global) != 0 && result != null)
			{
				int num = ((req_comp != 0) ? req_comp : (*comp));
				stbi__vertical_flip(result, *x, *y, num * 4);
			}
		}

		public unsafe static float* stbi__loadf_main(stbi__context s, int* x, int* y, int* comp, int req_comp)
		{
			if (stbi__hdr_test(s) != 0)
			{
				stbi__result_info stbi__result_info = default(stbi__result_info);
				float* ptr = stbi__hdr_load(s, x, y, comp, req_comp, &stbi__result_info);
				if (ptr != null)
				{
					stbi__float_postprocess(ptr, x, y, comp, req_comp);
				}
				return ptr;
			}
			byte* ptr2 = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);
			if (ptr2 != null)
			{
				return stbi__ldr_to_hdr(ptr2, *x, *y, (req_comp != 0) ? req_comp : (*comp));
			}
			return (float*)(int)((stbi__err("unknown image type") != 0) ? 0u : 0u);
		}

		public static int stbi__get16be(stbi__context s)
		{
			int num = stbi__get8(s);
			return (num << 8) + stbi__get8(s);
		}

		public static uint stbi__get32be(stbi__context s)
		{
			uint num = (uint)stbi__get16be(s);
			return (uint)((num << 16) + stbi__get16be(s));
		}

		public static int stbi__get16le(stbi__context s)
		{
			int num = stbi__get8(s);
			return num + (stbi__get8(s) << 8);
		}

		public static uint stbi__get32le(stbi__context s)
		{
			uint num = (uint)stbi__get16le(s);
			return num + (uint)(stbi__get16le(s) << 16);
		}

		public static byte stbi__compute_y(int r, int g, int b)
		{
			return (byte)(r * 77 + g * 150 + 29 * b >> 8);
		}

		public unsafe static byte* stbi__convert_format(byte* data, int img_n, int req_comp, uint x, uint y)
		{
			int num = 0;
			int num2 = 0;
			if (req_comp == img_n)
			{
				return data;
			}
			byte* ptr = (byte*)stbi__malloc_mad3(req_comp, (int)x, (int)y, 0);
			if (ptr == null)
			{
				CRuntime.free(data);
				return (byte*)(int)((stbi__err("outofmem") != 0) ? 0u : 0u);
			}
			for (num2 = 0; num2 < (int)y; num2++)
			{
				byte* ptr2 = data + num2 * x * img_n;
				byte* ptr3 = ptr + num2 * x * req_comp;
				switch (img_n * 8 + req_comp)
				{
				case 10:
					num = (int)(x - 1);
					while (num >= 0)
					{
						*ptr3 = *ptr2;
						ptr3[1] = byte.MaxValue;
						num--;