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 BepInEx;
using BepInEx.Configuration;
using Bounce.Singletons;
using Bounce.Unmanaged;
using Newtonsoft.Json;
using RadialUI;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("HSVPlugin")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("HSVPlugin")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("HSVPlugin")]
[assembly: ComVisible(false)]
[assembly: Guid("c303405d-e66c-4316-9cdb-4e3ca15c6360")]
[assembly: AssemblyFileVersion("2.2.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("2.2.0.0")]
namespace LordAshes;

[BepInPlugin("org.lordashes.plugins.hsv", "HSV Plug-In", "2.2.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class HSVPlugin : BaseUnityPlugin
{
	public static class Utility
	{
		public static void PostOnMainPage(MemberInfo plugin)
		{
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Expected O, but got Unknown
				try
				{
					if (((Scene)(ref scene)).name == "UI")
					{
						TextMeshProUGUI uITextByName = GetUITextByName("BETA");
						if (Object.op_Implicit((Object)(object)uITextByName))
						{
							((TMP_Text)uITextByName).text = "INJECTED BUILD - unstable mods";
						}
					}
					else
					{
						TextMeshProUGUI uITextByName2 = GetUITextByName("TextMeshPro Text");
						if (Object.op_Implicit((Object)(object)uITextByName2))
						{
							BepInPlugin val = (BepInPlugin)Attribute.GetCustomAttribute(plugin, typeof(BepInPlugin));
							if (((TMP_Text)uITextByName2).text.EndsWith("</size>"))
							{
								((TMP_Text)uITextByName2).text = ((TMP_Text)uITextByName2).text + "\n\nMods Currently Installed:\n";
							}
							TextMeshProUGUI val2 = uITextByName2;
							((TMP_Text)val2).text = ((TMP_Text)val2).text + "\nLord Ashes' " + val.Name + " - " + val.Version;
						}
					}
				}
				catch (Exception ex)
				{
					Debug.Log((object)ex);
				}
			};
		}

		public static bool isBoardLoaded()
		{
			return SimpleSingletonBehaviour<CameraController>.HasInstance && SingletonStateMBehaviour<BoardSessionManager, State<BoardSessionManager>>.HasInstance && !BoardSessionManager.IsLoading;
		}

		public static string GetCreatureName(string name)
		{
			if (name.Contains("<"))
			{
				name = name.Substring(0, name.IndexOf("<"));
			}
			return name;
		}

		private static TextMeshProUGUI GetUITextByName(string name)
		{
			TextMeshProUGUI[] array = Object.FindObjectsOfType<TextMeshProUGUI>();
			for (int i = 0; i < array.Length; i++)
			{
				if (((Object)array[i]).name == name)
				{
					return array[i];
				}
			}
			return null;
		}

		public static GameObject GetAssetLoader(CreatureGuid cid)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CreatureBoardAsset val = null;
				CreaturePresenter.TryGetAsset(cid, ref val);
				if ((Object)(object)val != (Object)null)
				{
					Transform match = null;
					Traverse(((Component)val).transform, "AssetLoader", 0, 10, ref match);
					if ((Object)(object)match != (Object)null)
					{
						Debug.Log((object)("Proximity Roller Plugin: Asset Loader '" + ((Object)match.GetChild(0)).name + "' Found"));
						return ((Component)match.GetChild(0)).gameObject;
					}
					Debug.LogWarning((object)"Proximity Roller Plugin: Could Not Find Asset Loader");
					return null;
				}
				return null;
			}
			catch
			{
				return null;
			}
		}

		public static void Traverse(Transform root, string seek, int depth, int depthMax, ref Transform match)
		{
			try
			{
				if ((Object)(object)match != (Object)null)
				{
					return;
				}
				if (((Object)root).name == seek)
				{
					match = root;
					return;
				}
				foreach (Transform item in ExtensionMethods.Children(root))
				{
					if (depth < depthMax)
					{
						Traverse(item, seek, depth + 1, depthMax, ref match);
					}
				}
			}
			catch
			{
			}
		}
	}

	public enum MenuItemLocation
	{
		MainMenu,
		GMMenu
	}

	public const string Name = "HSV Plug-In";

	public const string Guid = "org.lordashes.plugins.hsv";

	public const string Version = "2.2.0.0";

	public bool menuOpen = false;

	public int applying = 0;

	public Dictionary<string, Texture2D> originalTextures = new Dictionary<string, Texture2D>();

	public string data = Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase.ToString().Replace("file:///", ""));

	private float h = 100f;

	private float s = 100f;

	private float v = 100f;

	private static BaseUnityPlugin self;

	private static KeyboardShortcut manualTrigger;

	private static Queue<object[]> transformations = new Queue<object[]>();

	private static int transformationsInProgress = 0;

	private static int maxtTransfromationsInProgress = 0;

	private void Awake()
	{
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Expected O, but got Unknown
		//IL_00a4: Expected O, but got Unknown
		//IL_0139: 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_0149: Unknown result type (might be due to invalid IL or missing references)
		Debug.Log((object)"HSV Plugin: Active.");
		self = (BaseUnityPlugin)(object)this;
		if (((BaseUnityPlugin)this).Config.Bind<MenuItemLocation>("Settings", "HSV Menu Location", MenuItemLocation.GMMenu, (ConfigDescription)null).Value == MenuItemLocation.GMMenu)
		{
			RadialUIPlugin.AddCustomButtonGMSubmenu("org.hollofox.plugins.RadialUIPlugin.HSL", new ItemArgs
			{
				Action = HSVMenu,
				CloseMenuOnActivate = true,
				FadeName = true,
				Icon = Image.LoadSprite("Paintbrush.png", (CacheType)999),
				Title = "HSV"
			}, (Func<NGuid, NGuid, bool>)((NGuid a, NGuid b) => true));
		}
		else
		{
			RadialUIPlugin.AddCustomButtonOnCharacter("org.hollofox.plugins.RadialUIPlugin.HSL", new ItemArgs
			{
				Action = HSVMenu,
				CloseMenuOnActivate = true,
				FadeName = true,
				Icon = Image.LoadSprite("Paintbrush.png", (CacheType)999),
				Title = "HSV"
			}, (Func<NGuid, NGuid, bool>)((NGuid a, NGuid b) => true));
		}
		manualTrigger = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keyboard", "Manual Trigger To Apply HSV Transfromations", new KeyboardShortcut((KeyCode)104, (KeyCode[])(object)new KeyCode[1] { (KeyCode)305 }), (ConfigDescription)null).Value;
		maxtTransfromationsInProgress = ((BaseUnityPlugin)this).Config.Bind<int>("Settings", "Maximum Simultaneous Transformations", 5, (ConfigDescription)null).Value;
		AssetDataPlugin.Subscribe("org.lordashes.plugins.hsv".ToString(), (Action<DatumChange>)AssetDataTransformationRequest, (Func<DatumChange, bool>)Checker.CheckSourceAsCreature);
		Utility.PostOnMainPage(((object)this).GetType());
	}

	private void OnGUI()
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Expected O, but got Unknown
		//IL_0034: 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_0045: Expected O, but got Unknown
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: 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_013b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ce: 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)
		//IL_023c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0317: Unknown result type (might be due to invalid IL or missing references)
		//IL_0296: Unknown result type (might be due to invalid IL or missing references)
		//IL_0347: Unknown result type (might be due to invalid IL or missing references)
		//IL_034c: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
		if (!menuOpen)
		{
			return;
		}
		GUIStyle val = new GUIStyle();
		val.alignment = (TextAnchor)5;
		val.fontSize = 16;
		val.fontStyle = (FontStyle)1;
		val.normal.textColor = Color.white;
		GUIStyle val2 = new GUIStyle();
		val2.alignment = (TextAnchor)3;
		val2.fontSize = 16;
		val2.fontStyle = (FontStyle)1;
		val2.normal.textColor = Color.white;
		GUI.Label(new Rect(855f, 500f, 100f, 30f), "Hue:", val);
		GUI.Label(new Rect(965f, 500f, 30f, 30f), h.ToString("0.0") + "%", val2);
		h = GUI.HorizontalSlider(new Rect(1020f, 510f, 300f, 30f), h, 0f, 200f);
		GUI.Label(new Rect(855f, 540f, 100f, 30f), "Saturation:", val);
		GUI.Label(new Rect(965f, 540f, 30f, 30f), s.ToString("0.0") + "%", val2);
		s = GUI.HorizontalSlider(new Rect(1020f, 550f, 300f, 30f), s, 0f, 200f);
		GUI.Label(new Rect(855f, 580f, 100f, 30f), "Value:", val);
		GUI.Label(new Rect(965f, 580f, 30f, 30f), v.ToString("0.0") + "%", val2);
		v = GUI.HorizontalSlider(new Rect(1020f, 590f, 300f, 30f), v, 0f, 200f);
		if (GUI.Button(new Rect(1135f, 640f, 20f, 20f), "^"))
		{
			h = 100f;
			s = 100f;
			v = 100f;
		}
		if (applying == 0)
		{
			if (GUI.Button(new Rect(895f, 620f, 60f, 30f), "Apply"))
			{
				applying = 1;
			}
			if (GUI.Button(new Rect(965f, 620f, 60f, 30f), "Exit"))
			{
				menuOpen = false;
				GameInputEnabled(setting: true);
			}
			return;
		}
		applying++;
		GUI.Label(new Rect(945f, 620f, 60f, 30f), "Applying...", val);
		if (applying == 10)
		{
			applying++;
			NGuid lastRadialTargetCreature = RadialUIPlugin.GetLastRadialTargetCreature();
			AssetDataPlugin.SetInfo(((object)(NGuid)(ref lastRadialTargetCreature)).ToString(), "org.lordashes.plugins.hsv", h + "," + s + "," + v, false);
		}
	}

	private void Update()
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		if (Utility.isBoardLoaded() && ((KeyboardShortcut)(ref manualTrigger)).IsUp())
		{
			SystemMessage.DisplayInfoText("Applying HSV Transfromations", 2.5f);
			Debug.Log((object)"HSV Plugin: Manual HSV Application Triggered");
			foreach (CreatureBoardAsset item in (IEnumerable<CreatureBoardAsset>)CreaturePresenter.GetTempReadOnlyViewOfAllCreatureAssets())
			{
				CreatureGuid creatureId = item.CreatureId;
				Debug.Log((object)("HSV Plugin: Refreshing HSV On " + ((object)(CreatureGuid)(ref creatureId)).ToString() + "."));
				((MonoBehaviour)this).StartCoroutine("RefreshHSV", (object)new object[1] { item.CreatureId });
			}
		}
		if (transformationsInProgress < maxtTransfromationsInProgress && transformations.Count > 0)
		{
			Debug.Log((object)"HSV Plugin: Dequeing Next Transformation");
			object[] array = transformations.Dequeue();
			((MonoBehaviour)this).StartCoroutine("ProcessChange", (object)array);
		}
	}

	private void HSVMenu(MapMenuItem arg1, object arg2)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: 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)
		CreatureBoardAsset val = default(CreatureBoardAsset);
		CreaturePresenter.TryGetAsset(new CreatureGuid(RadialUIPlugin.GetLastRadialTargetCreature()), ref val);
		if ((Object)(object)val != (Object)null)
		{
			string[] array = new string[3] { "100.0", "100.0", "100.0" };
			try
			{
				CreatureGuid creatureId = val.CreatureId;
				array = AssetDataPlugin.ReadInfo(((object)(CreatureGuid)(ref creatureId)).ToString(), "org.lordashes.plugins.hsv").Split(new char[1] { ',' });
			}
			catch
			{
			}
			h = float.Parse(array[0]);
			s = float.Parse(array[1]);
			v = float.Parse(array[2]);
			menuOpen = true;
			GameInputEnabled(setting: false);
		}
	}

	private void AssetDataTransformationRequest(DatumChange change)
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Invalid comparison between Unknown and I4
		string[] obj = new string[7]
		{
			"HSV Plugin: Processing ",
			change.source.ToString(),
			" -> ",
			change.value?.ToString(),
			" (",
			null,
			null
		};
		ChangeAction action = change.action;
		obj[5] = ((object)(ChangeAction)(ref action)).ToString();
		obj[6] = ")";
		Debug.Log((object)string.Concat(obj));
		string[] array = change.value.ToString().Split(new char[1] { ',' });
		float num = (((int)change.action == 2) ? ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "Delay HSV Application On New Asset", 1f, (ConfigDescription)null).Value : 0.1f);
		((MonoBehaviour)this).StartCoroutine("DelayTransformationQueuing", (object)new object[5]
		{
			change.source,
			float.Parse(array[0]),
			float.Parse(array[1]),
			float.Parse(array[2]),
			num
		});
	}

	private IEnumerator DelayTransformationQueuing(object[] inputs)
	{
		yield return (object)new WaitForSeconds((float)inputs[4]);
		Debug.Log((object)"HSV Plugin: Enqueing Transformation.");
		transformations.Enqueue(inputs);
	}

	private IEnumerator ProcessChange(object[] inputs)
	{
		Debug.Log((object)("HSV Plugin: Processing HSV Transformation " + JsonConvert.SerializeObject((object)inputs)));
		transformationsInProgress++;
		yield return (object)new WaitForSeconds(0.1f);
		CreatureGuid cid = new CreatureGuid(inputs[0].ToString());
		float dh = (float)inputs[1];
		float ds = (float)inputs[2];
		float dv = (float)inputs[3];
		CreatureBoardAsset asset = default(CreatureBoardAsset);
		CreaturePresenter.TryGetAsset(cid, ref asset);
		string phase = "";
		if ((Object)(object)asset != (Object)null)
		{
			GameObject go = null;
			try
			{
				Debug.Log((object)("HSV Plugin: Processing HSV Transformation For " + Utility.GetCreatureName(asset.Name) + " (H" + dh + ":S" + ds + ":V" + dv + ")"));
				phase = "Get Mini Reference";
				go = Utility.GetAssetLoader(asset.CreatureId);
				phase = "Get Mini Render Reference";
				Renderer[] renderers = go.GetComponentsInChildren<Renderer>();
				Debug.Log((object)("HSV Plugin: Found " + renderers.Length + " Renderers"));
				Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>();
				CreatureGuid creatureId;
				foreach (Renderer rend2 in componentsInChildren)
				{
					if (rend2.materials != null)
					{
						phase = "Get Render " + ((Object)rend2).name + " Reference (Materials Count = " + rend2.materials.Length + ")";
						for (int j = 0; j < rend2.materials.Length; j++)
						{
							if (!originalTextures.ContainsKey(((object)(CreatureGuid)(ref cid)).ToString() + ".M" + j))
							{
								if ((Object)(object)rend2.materials[j] != (Object)null && (Object)(object)rend2.materials[j].mainTexture != (Object)null)
								{
									if (((Object)rend2.materials[j].mainTexture).name == null)
									{
										((Object)rend2.materials[j].mainTexture).name = "No-Name";
									}
									Debug.Log((object)("HSV Plugin: Registering Original Texture " + (j + 1) + " of " + rend2.materials.Length + " '" + ((Object)rend2.materials[j].mainTexture).name + "'."));
									phase = "Get Mini Original Texture Reference";
									originalTextures.Add(((object)(CreatureGuid)(ref cid)).ToString() + ".M" + j, (Texture2D)rend2.materials[j].mainTexture);
								}
								else
								{
									Debug.Log((object)("HSV Plugin: Registering Null Texture " + (j + 1) + "."));
									originalTextures.Add(((object)(CreatureGuid)(ref cid)).ToString() + ".M" + j, null);
								}
							}
							Debug.Log((object)("HSV Plugin: Processing Texture " + (j + 1)));
							Texture2D tex = originalTextures[((object)(CreatureGuid)(ref cid)).ToString() + ".M" + j];
							if ((Object)(object)tex != (Object)null)
							{
								phase = "Populate Texture Object";
								Debug.Log((object)("HSV Plugin: Processing Texture '" + ((Object)tex).name + "' (Is Readable: " + ((Texture)tex).isReadable + ")"));
								Texture2D alt;
								if (!((Texture)tex).isReadable)
								{
									phase = "Extract Non-Readable Texture";
									RenderTexture tmp = RenderTexture.GetTemporary(((Texture)tex).width, ((Texture)tex).height, 0, (RenderTextureFormat)7, (RenderTextureReadWrite)1);
									Graphics.Blit((Texture)(object)tex, tmp);
									RenderTexture previous = RenderTexture.active;
									RenderTexture.active = tmp;
									alt = new Texture2D(((Texture)tex).width, ((Texture)tex).height);
									alt.ReadPixels(new Rect(0f, 0f, (float)((Texture)tmp).width, (float)((Texture)tmp).height), 0, 0);
									alt.Apply();
									RenderTexture.active = previous;
									RenderTexture.ReleaseTemporary(tmp);
								}
								else
								{
									phase = "Extract Readable Texture";
									alt = new Texture2D(((Texture)tex).width, ((Texture)tex).height, (TextureFormat)3, false);
									Color[] c = tex.GetPixels(0, 0, ((Texture)tex).width - 1, ((Texture)tex).height - 1);
									phase = "Copy Texture To New Texture Object";
									alt.SetPixels(0, 0, ((Texture)tex).width - 1, ((Texture)tex).height - 1, c);
								}
								byte[] bytes = ImageConversion.EncodeToPNG(alt);
								phase = "Write Uncompressed Texture Object";
								string text = data;
								creatureId = asset.CreatureId;
								File.WriteAllBytes(text + "/CustomData/Images/" + ((object)(CreatureGuid)(ref creatureId)).ToString() + ".png", bytes);
								Debug.Log((object)"HSV Plugin: Applying Transformation.");
								phase = "Apply Transformation To Texture Object";
								Process process = new Process();
								Process process2 = process;
								ProcessStartInfo processStartInfo = new ProcessStartInfo
								{
									FileName = data + "/ImageAdjust.exe",
									WorkingDirectory = data
								};
								ProcessStartInfo processStartInfo2 = processStartInfo;
								string[] obj = new string[10] { "\"", data, "/CustomData/Images/", null, null, null, null, null, null, null };
								creatureId = asset.CreatureId;
								obj[3] = ((object)(CreatureGuid)(ref creatureId)).ToString();
								obj[4] = ".png\" ";
								obj[5] = dh.ToString();
								obj[6] = " ";
								obj[7] = ds.ToString();
								obj[8] = " ";
								obj[9] = dv.ToString();
								processStartInfo2.Arguments = string.Concat(obj);
								processStartInfo.CreateNoWindow = true;
								processStartInfo.RedirectStandardOutput = true;
								processStartInfo.UseShellExecute = false;
								process2.StartInfo = processStartInfo;
								Process transformation = process;
								transformation.Start();
								string output = transformation.StandardOutput.ReadToEnd();
								transformation.WaitForExit();
								Debug.Log((object)("HSV Plugin: ImageAdjust Output = " + output));
								phase = "Apply New Texture";
								Debug.Log((object)"HSV Plugin: Loading Transformation.");
								Material obj2 = rend2.materials[j];
								HSVPlugin hSVPlugin = this;
								string text2 = data;
								creatureId = asset.CreatureId;
								obj2.mainTexture = (Texture)(object)hSVPlugin.LoadTexture(text2 + "/CustomData/Images/" + ((object)(CreatureGuid)(ref creatureId)).ToString() + ".png");
							}
						}
					}
					else
					{
						Debug.Log((object)("HSV Plugin: Renderer " + ((Object)rend2).name + " Has No Textures"));
					}
				}
				SkinnedMeshRenderer[] componentsInChildren2 = go.GetComponentsInChildren<SkinnedMeshRenderer>();
				foreach (SkinnedMeshRenderer rend in componentsInChildren2)
				{
					if (((Renderer)rend).sharedMaterials != null)
					{
						phase = "Get Render " + ((Object)rend).name + " Reference (Shared Materials Count = " + ((Renderer)rend).sharedMaterials.Length + ")";
						for (int i = 0; i < ((Renderer)rend).sharedMaterials.Length; i++)
						{
							if (!originalTextures.ContainsKey(((object)(CreatureGuid)(ref cid)).ToString() + ".SM" + i))
							{
								if ((Object)(object)((Renderer)rend).sharedMaterials[i] != (Object)null && (Object)(object)((Renderer)rend).sharedMaterials[i].mainTexture != (Object)null)
								{
									if (((Object)((Renderer)rend).sharedMaterials[i].mainTexture).name == null)
									{
										((Object)((Renderer)rend).sharedMaterials[i].mainTexture).name = "No-Name";
									}
									Debug.Log((object)("HSV Plugin: Registering Original Texture " + (i + 1) + " of " + ((Renderer)rend).sharedMaterials.Length + " '" + ((Object)((Renderer)rend).sharedMaterials[i].mainTexture).name + "'."));
									phase = "Get Mini Original Texture Reference";
									originalTextures.Add(((object)(CreatureGuid)(ref cid)).ToString() + ".SM" + i, (Texture2D)((Renderer)rend).sharedMaterials[i].mainTexture);
								}
								else
								{
									Debug.Log((object)("HSV Plugin: Registering Null Texture " + (i + 1) + "."));
									originalTextures.Add(((object)(CreatureGuid)(ref cid)).ToString() + ".SM" + i, null);
								}
							}
							Debug.Log((object)("HSV Plugin: Processing Texture " + (i + 1) + "."));
							Texture2D tex2 = originalTextures[((object)(CreatureGuid)(ref cid)).ToString() + ".SM" + i];
							if ((Object)(object)tex2 != (Object)null)
							{
								phase = "Populate Texture Object";
								Debug.Log((object)("HSV Plugin: Processing Texture '" + ((Object)tex2).name + "' (Is Readable: " + ((Texture)tex2).isReadable + ")"));
								Texture2D alt2;
								if (!((Texture)tex2).isReadable)
								{
									phase = "Extract Non-Readable Texture";
									RenderTexture tmp2 = RenderTexture.GetTemporary(((Texture)tex2).width, ((Texture)tex2).height, 0, (RenderTextureFormat)7, (RenderTextureReadWrite)1);
									Graphics.Blit((Texture)(object)tex2, tmp2);
									RenderTexture previous2 = RenderTexture.active;
									RenderTexture.active = tmp2;
									alt2 = new Texture2D(((Texture)tex2).width, ((Texture)tex2).height);
									alt2.ReadPixels(new Rect(0f, 0f, (float)((Texture)tmp2).width, (float)((Texture)tmp2).height), 0, 0);
									alt2.Apply();
									RenderTexture.active = previous2;
									RenderTexture.ReleaseTemporary(tmp2);
								}
								else
								{
									phase = "Extract Readable Texture";
									alt2 = new Texture2D(((Texture)tex2).width, ((Texture)tex2).height, (TextureFormat)3, false);
									Color[] c2 = tex2.GetPixels(0, 0, ((Texture)tex2).width - 1, ((Texture)tex2).height - 1);
									phase = "Copy Texture To New Texture Object";
									alt2.SetPixels(0, 0, ((Texture)tex2).width - 1, ((Texture)tex2).height - 1, c2);
								}
								byte[] bytes2 = ImageConversion.EncodeToPNG(alt2);
								phase = "Write Uncompressed Texture Object";
								string text3 = data;
								creatureId = asset.CreatureId;
								File.WriteAllBytes(text3 + "/CustomData/Images/" + ((object)(CreatureGuid)(ref creatureId)).ToString() + ".png", bytes2);
								Debug.Log((object)"HSV Plugin: Applying Transformation.");
								phase = "Apply Transformation To Texture Object";
								Process process = new Process();
								Process process3 = process;
								ProcessStartInfo processStartInfo = new ProcessStartInfo
								{
									FileName = data + "/ImageAdjust.exe",
									WorkingDirectory = data
								};
								ProcessStartInfo processStartInfo3 = processStartInfo;
								string[] obj3 = new string[10] { "\"", data, "/CustomData/Images/", null, null, null, null, null, null, null };
								creatureId = asset.CreatureId;
								obj3[3] = ((object)(CreatureGuid)(ref creatureId)).ToString();
								obj3[4] = ".png\" ";
								obj3[5] = dh.ToString();
								obj3[6] = " ";
								obj3[7] = ds.ToString();
								obj3[8] = " ";
								obj3[9] = dv.ToString();
								processStartInfo3.Arguments = string.Concat(obj3);
								processStartInfo.CreateNoWindow = true;
								processStartInfo.RedirectStandardOutput = true;
								processStartInfo.UseShellExecute = false;
								process3.StartInfo = processStartInfo;
								Process transformation2 = process;
								transformation2.Start();
								string output2 = transformation2.StandardOutput.ReadToEnd();
								transformation2.WaitForExit();
								Debug.Log((object)("HSV Plugin: ImageAdjust Output = " + output2));
								phase = "Apply New Texture";
								Debug.Log((object)"HSV Plugin: Loading Transformation.");
								Material obj4 = ((Renderer)rend).sharedMaterials[i];
								HSVPlugin hSVPlugin2 = this;
								string text4 = data;
								creatureId = asset.CreatureId;
								obj4.mainTexture = (Texture)(object)hSVPlugin2.LoadTexture(text4 + "/CustomData/Images/" + ((object)(CreatureGuid)(ref creatureId)).ToString() + ".png");
							}
						}
					}
					else
					{
						Debug.Log((object)("HSV Plugin: Renderer " + ((Object)rend).name + " Has No Textures"));
					}
				}
			}
			catch (Exception ex)
			{
				Exception x = ex;
				SystemMessage.DisplayInfoText(Utility.GetCreatureName(asset.Name) + ":\r\nAsset Texture Not Readable.\r\nThe Asset Is Not Compatible With HSV Plugin.\r\nEnsure Texture Is Set To Read/Write.", 2.5f);
				Debug.Log((object)("HSV Plugin: Exception Processing Asset (" + Utility.GetCreatureName(asset.Name) + ") Texture At Phase '" + phase + "'"));
				Debug.LogException(x);
				if ((Object)(object)go != (Object)null)
				{
					Debug.Log((object)"HSV Plugin: Enumerating Components:");
					Component[] componentsInChildren3 = go.GetComponentsInChildren<Component>();
					foreach (Component comp in componentsInChildren3)
					{
						Debug.Log((object)("HSV Plugin: Asset " + Utility.GetCreatureName(asset.Name) + " Has Component " + ((Object)comp).name + " (" + ((object)comp).GetType()?.ToString() + ")"));
					}
				}
				else
				{
					Debug.Log((object)"HSV Plugin: Asset Is Null");
				}
			}
		}
		applying = 0;
		transformationsInProgress--;
	}

	private Texture2D LoadTexture(string source)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Expected O, but got Unknown
		Texture2D val = new Texture2D(1, 1);
		ImageConversion.LoadImage(val, File.ReadAllBytes(source));
		return val;
	}

	private void GameInputEnabled(bool setting)
	{
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Expected O, but got Unknown
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Expected O, but got Unknown
		if (setting)
		{
			Debug.Log((object)"HSV Plugin: Enabling Game Input");
			(from m in typeof(GameInput).GetMethods()
				where m.Name == "Enable"
				select m).ElementAt(0).Invoke((object?)(GameInput)(from f in typeof(ControllerManager).GetRuntimeFields()
				where f.Name == "_gameInput"
				select f).ToArray()[0].GetValue(null), new object[0]);
		}
		else
		{
			Debug.Log((object)"HSV Plugin: Disabling Game Input");
			(from m in typeof(GameInput).GetMethods()
				where m.Name == "Disable"
				select m).ElementAt(0).Invoke((object?)(GameInput)(from f in typeof(ControllerManager).GetRuntimeFields()
				where f.Name == "_gameInput"
				select f).ToArray()[0].GetValue(null), new object[0]);
		}
	}
}

using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Xml;
using System.Xml.XPath;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: ComVisible(false)]
[assembly: CLSCompliant(false)]
[assembly: AssemblyCompany("Dirk Lemstra")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright 2013-2021 Dirk Lemstra")]
[assembly: AssemblyFileVersion("8.5.0")]
[assembly: AssemblyInformationalVersion("8.5.0+94caf0f2fcdec9152671e40bd1e359f82d5d8fe6")]
[assembly: AssemblyProduct("Magick.NET.Core")]
[assembly: AssemblyTitle("Magick.NET.Core")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, UnmanagedCode = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("8.5.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class NotNullAttribute : Attribute
	{
	}
}
namespace ImageMagick
{
	public interface IMagickColor<TQuantumType> : IEquatable<IMagickColor<TQuantumType>>, IComparable<IMagickColor<TQuantumType>> where TQuantumType : struct
	{
		TQuantumType A { get; set; }

		TQuantumType B { get; set; }

		TQuantumType G { get; set; }

		bool IsCmyk { get; }

		TQuantumType K { get; set; }

		TQuantumType R { get; set; }

		bool FuzzyEquals(IMagickColor<TQuantumType> other, Percentage fuzz);

		void SetFromBytes(byte red, byte green, byte blue, byte alpha);

		byte[] ToByteArray();

		string ToHexString();

		string ToShortString();

		new string ToString();
	}
	public interface IDefine
	{
		MagickFormat Format { get; }

		string Name { get; }

		string Value { get; }
	}
	public interface IDefines
	{
		IEnumerable<IDefine> Defines { get; }
	}
	public interface IReadDefines : IDefines
	{
	}
	public interface IWriteDefines : IDefines
	{
		MagickFormat Format { get; }
	}
	[GeneratedCode("Magick.NET.FileGenerator", "")]
	public interface IDrawables<TQuantumType> : IEnumerable<IDrawable>, IEnumerable where TQuantumType : struct
	{
		IDrawables<TQuantumType> Affine(double scaleX, double scaleY, double shearX, double shearY, double translateX, double translateY);

		IDrawables<TQuantumType> Alpha(double x, double y, PaintMethod paintMethod);

		IDrawables<TQuantumType> Arc(double startX, double startY, double endX, double endY, double startDegrees, double endDegrees);

		IDrawables<TQuantumType> Bezier(params PointD[] coordinates);

		IDrawables<TQuantumType> Bezier(IEnumerable<PointD> coordinates);

		IDrawables<TQuantumType> BorderColor(IMagickColor<TQuantumType> color);

		IDrawables<TQuantumType> Circle(double originX, double originY, double perimeterX, double perimeterY);

		IDrawables<TQuantumType> ClipPath(string clipPath);

		IDrawables<TQuantumType> ClipRule(FillRule fillRule);

		IDrawables<TQuantumType> ClipUnits(ClipPathUnit units);

		IDrawables<TQuantumType> Color(double x, double y, PaintMethod paintMethod);

		IDrawables<TQuantumType> Composite(IMagickGeometry offset, IMagickImage<TQuantumType> image);

		IDrawables<TQuantumType> Composite(double x, double y, IMagickImage<TQuantumType> image);

		IDrawables<TQuantumType> Composite(IMagickGeometry offset, CompositeOperator compose, IMagickImage<TQuantumType> image);

		IDrawables<TQuantumType> Composite(double x, double y, CompositeOperator compose, IMagickImage<TQuantumType> image);

		IDrawables<TQuantumType> Density(double density);

		IDrawables<TQuantumType> Density(PointD pointDensity);

		IDrawables<TQuantumType> Ellipse(double originX, double originY, double radiusX, double radiusY, double startDegrees, double endDegrees);

		IDrawables<TQuantumType> FillColor(IMagickColor<TQuantumType> color);

		IDrawables<TQuantumType> FillOpacity(Percentage opacity);

		IDrawables<TQuantumType> FillPatternUrl(string url);

		IDrawables<TQuantumType> FillRule(FillRule fillRule);

		IDrawables<TQuantumType> Font(string family);

		IDrawables<TQuantumType> Font(string family, FontStyleType style, FontWeight weight, FontStretch stretch);

		IDrawables<TQuantumType> FontPointSize(double pointSize);

		IDrawables<TQuantumType> Gravity(Gravity gravity);

		IDrawables<TQuantumType> Line(double startX, double startY, double endX, double endY);

		IDrawables<TQuantumType> Path(params IPath[] paths);

		IDrawables<TQuantumType> Path(IEnumerable<IPath> paths);

		IDrawables<TQuantumType> Point(double x, double y);

		IDrawables<TQuantumType> Polygon(params PointD[] coordinates);

		IDrawables<TQuantumType> Polygon(IEnumerable<PointD> coordinates);

		IDrawables<TQuantumType> Polyline(params PointD[] coordinates);

		IDrawables<TQuantumType> Polyline(IEnumerable<PointD> coordinates);

		IDrawables<TQuantumType> PopClipPath();

		IDrawables<TQuantumType> PopGraphicContext();

		IDrawables<TQuantumType> PopPattern();

		IDrawables<TQuantumType> PushClipPath(string clipPath);

		IDrawables<TQuantumType> PushGraphicContext();

		IDrawables<TQuantumType> PushPattern(string id, double x, double y, double width, double height);

		IDrawables<TQuantumType> Rectangle(double upperLeftX, double upperLeftY, double lowerRightX, double lowerRightY);

		IDrawables<TQuantumType> Rotation(double angle);

		IDrawables<TQuantumType> RoundRectangle(double upperLeftX, double upperLeftY, double lowerRightX, double lowerRightY, double cornerWidth, double cornerHeight);

		IDrawables<TQuantumType> Scaling(double x, double y);

		IDrawables<TQuantumType> SkewX(double angle);

		IDrawables<TQuantumType> SkewY(double angle);

		IDrawables<TQuantumType> StrokeAntialias(bool isEnabled);

		IDrawables<TQuantumType> StrokeColor(IMagickColor<TQuantumType> color);

		IDrawables<TQuantumType> StrokeDashArray(params double[] dash);

		IDrawables<TQuantumType> StrokeDashOffset(double offset);

		IDrawables<TQuantumType> StrokeLineCap(LineCap lineCap);

		IDrawables<TQuantumType> StrokeLineJoin(LineJoin lineJoin);

		IDrawables<TQuantumType> StrokeMiterLimit(int miterlimit);

		IDrawables<TQuantumType> StrokeOpacity(Percentage opacity);

		IDrawables<TQuantumType> StrokePatternUrl(string url);

		IDrawables<TQuantumType> StrokeWidth(double width);

		IDrawables<TQuantumType> Text(double x, double y, string value);

		IDrawables<TQuantumType> TextAlignment(TextAlignment alignment);

		IDrawables<TQuantumType> TextAntialias(bool isEnabled);

		IDrawables<TQuantumType> TextDecoration(TextDecoration decoration);

		IDrawables<TQuantumType> TextDirection(TextDirection direction);

		IDrawables<TQuantumType> TextEncoding(Encoding encoding);

		IDrawables<TQuantumType> TextInterlineSpacing(double spacing);

		IDrawables<TQuantumType> TextInterwordSpacing(double spacing);

		IDrawables<TQuantumType> TextKerning(double kerning);

		IDrawables<TQuantumType> TextUnderColor(IMagickColor<TQuantumType> color);

		IDrawables<TQuantumType> Translation(double x, double y);

		IDrawables<TQuantumType> Viewbox(double upperLeftX, double upperLeftY, double lowerRightX, double lowerRightY);

		IDrawables<TQuantumType> Draw(IMagickImage<TQuantumType> image);

		ITypeMetric? FontTypeMetrics(string text);

		ITypeMetric? FontTypeMetrics(string text, bool ignoreNewlines);

		IPaths<TQuantumType> Paths();
	}
	public interface IDrawable
	{
	}
	public interface IDrawableAffine
	{
		double ScaleX { get; set; }

		double ScaleY { get; set; }

		double ShearX { get; set; }

		double ShearY { get; set; }

		double TranslateX { get; set; }

		double TranslateY { get; set; }

		void Reset();

		void TransformOrigin(double translateX, double translateY);

		void TransformRotation(double angle);

		void TransformScale(double scaleX, double scaleY);

		void TransformSkewX(double skewX);

		void TransformSkewY(double skewY);
	}
	public sealed class PathArc
	{
		public double RadiusX { get; set; }

		public double RadiusY { get; set; }

		public double RotationX { get; set; }

		public bool UseLargeArc { get; set; }

		public bool UseSweep { get; set; }

		public double X { get; set; }

		public double Y { get; set; }

		public PathArc()
		{
		}

		public PathArc(double x, double y, double radiusX, double radiusY, double rotationX, bool useLargeArc, bool useSweep)
		{
			X = x;
			Y = y;
			RadiusX = radiusX;
			RadiusY = radiusY;
			RotationX = rotationX;
			UseLargeArc = useLargeArc;
			UseSweep = useSweep;
		}
	}
	[GeneratedCode("Magick.NET.FileGenerator", "")]
	public interface IPaths<TQuantumType> : IEnumerable<IPath>, IEnumerable where TQuantumType : struct
	{
		IPaths<TQuantumType> ArcAbs(params PathArc[] coordinates);

		IPaths<TQuantumType> ArcAbs(IEnumerable<PathArc> coordinates);

		IPaths<TQuantumType> ArcRel(params PathArc[] coordinates);

		IPaths<TQuantumType> ArcRel(IEnumerable<PathArc> coordinates);

		IPaths<TQuantumType> Close();

		IPaths<TQuantumType> CurveToAbs(PointD controlPointStart, PointD controlPointEnd, PointD end);

		IPaths<TQuantumType> CurveToAbs(double x1, double y1, double x2, double y2, double x, double y);

		IPaths<TQuantumType> CurveToRel(PointD controlPointStart, PointD controlPointEnd, PointD end);

		IPaths<TQuantumType> CurveToRel(double x1, double y1, double x2, double y2, double x, double y);

		IPaths<TQuantumType> LineToAbs(params PointD[] coordinates);

		IPaths<TQuantumType> LineToAbs(IEnumerable<PointD> coordinates);

		IPaths<TQuantumType> LineToAbs(double x, double y);

		IPaths<TQuantumType> LineToHorizontalAbs(double x);

		IPaths<TQuantumType> LineToHorizontalRel(double x);

		IPaths<TQuantumType> LineToRel(params PointD[] coordinates);

		IPaths<TQuantumType> LineToRel(IEnumerable<PointD> coordinates);

		IPaths<TQuantumType> LineToRel(double x, double y);

		IPaths<TQuantumType> LineToVerticalAbs(double y);

		IPaths<TQuantumType> LineToVerticalRel(double y);

		IPaths<TQuantumType> MoveToAbs(PointD coordinate);

		IPaths<TQuantumType> MoveToAbs(double x, double y);

		IPaths<TQuantumType> MoveToRel(PointD coordinate);

		IPaths<TQuantumType> MoveToRel(double x, double y);

		IPaths<TQuantumType> QuadraticCurveToAbs(PointD controlPoint, PointD end);

		IPaths<TQuantumType> QuadraticCurveToAbs(double x1, double y1, double x, double y);

		IPaths<TQuantumType> QuadraticCurveToRel(PointD controlPoint, PointD end);

		IPaths<TQuantumType> QuadraticCurveToRel(double x1, double y1, double x, double y);

		IPaths<TQuantumType> SmoothCurveToAbs(PointD controlPoint, PointD end);

		IPaths<TQuantumType> SmoothCurveToAbs(double x2, double y2, double x, double y);

		IPaths<TQuantumType> SmoothCurveToRel(PointD controlPoint, PointD end);

		IPaths<TQuantumType> SmoothCurveToRel(double x2, double y2, double x, double y);

		IPaths<TQuantumType> SmoothQuadraticCurveToAbs(PointD end);

		IPaths<TQuantumType> SmoothQuadraticCurveToAbs(double x, double y);

		IPaths<TQuantumType> SmoothQuadraticCurveToRel(PointD end);

		IPaths<TQuantumType> SmoothQuadraticCurveToRel(double x, double y);

		IDrawables<TQuantumType> Drawables();
	}
	public interface IPath
	{
	}
	public enum AlphaOption
	{
		Undefined,
		Activate,
		Associate,
		Background,
		Copy,
		Deactivate,
		Discrete,
		Disassociate,
		Extract,
		Off,
		On,
		Opaque,
		Remove,
		Set,
		Shape,
		Transparent
	}
	public enum AutoThresholdMethod
	{
		Undefined,
		Kapur,
		OTSU,
		Triangle
	}
	[Flags]
	public enum Channels
	{
		None = 0,
		Red = 1,
		Gray = 1,
		Cyan = 1,
		Green = 2,
		Magenta = 2,
		Blue = 4,
		Yellow = 4,
		Black = 8,
		Alpha = 0x10,
		Opacity = 0x10,
		Index = 0x20,
		Composite = 0x1F,
		All = 0x7FFFFFF,
		TrueAlpha = 0x100,
		RGB = 7,
		CMYK = 0xF,
		Grays = 0x400,
		Sync = 0x20000,
		Default = 0x7FFFFFF
	}
	public enum ClassType
	{
		Undefined,
		Direct,
		Pseudo
	}
	public enum ClipPathUnit
	{
		Undefined,
		UserSpace,
		UserSpaceOnUse,
		ObjectBoundingBox
	}
	public enum ColorSpace
	{
		Undefined,
		CMY,
		CMYK,
		Gray,
		HCL,
		HCLp,
		HSB,
		HSI,
		HSL,
		HSV,
		HWB,
		Lab,
		LCH,
		LCHab,
		LCHuv,
		Log,
		LMS,
		Luv,
		OHTA,
		Rec601YCbCr,
		Rec709YCbCr,
		RGB,
		scRGB,
		sRGB,
		Transparent,
		XyY,
		XYZ,
		YCbCr,
		YCC,
		YDbDr,
		YIQ,
		YPbPr,
		YUV,
		LinearGray,
		Jzazbz
	}
	public enum ColorTransformMode
	{
		HighRes,
		Quantum
	}
	public enum ColorType
	{
		Undefined,
		Bilevel,
		Grayscale,
		GrayscaleAlpha,
		Palette,
		PaletteAlpha,
		TrueColor,
		TrueColorAlpha,
		ColorSeparation,
		ColorSeparationAlpha,
		Optimize,
		PaletteBilevelAlpha
	}
	public enum ComplexOperator
	{
		Undefined,
		Add,
		Conjugate,
		Divide,
		MagnitudePhase,
		Multiply,
		RealImaginary,
		Subtract
	}
	public enum CompositeOperator
	{
		Undefined,
		Alpha,
		Atop,
		Blend,
		Blur,
		Bumpmap,
		ChangeMask,
		Clear,
		ColorBurn,
		ColorDodge,
		Colorize,
		CopyBlack,
		CopyBlue,
		Copy,
		CopyCyan,
		CopyGreen,
		CopyMagenta,
		CopyAlpha,
		CopyRed,
		CopyYellow,
		Darken,
		DarkenIntensity,
		Difference,
		Displace,
		Dissolve,
		Distort,
		DivideDst,
		DivideSrc,
		DstAtop,
		Dst,
		DstIn,
		DstOut,
		DstOver,
		Exclusion,
		HardLight,
		HardMix,
		Hue,
		In,
		Intensity,
		Lighten,
		LightenIntensity,
		LinearBurn,
		LinearDodge,
		LinearLight,
		Luminize,
		Mathematics,
		MinusDst,
		MinusSrc,
		Modulate,
		ModulusAdd,
		ModulusSubtract,
		Multiply,
		No,
		Out,
		Over,
		Overlay,
		PegtopLight,
		PinLight,
		Plus,
		Replace,
		Saturate,
		Screen,
		SoftLight,
		SrcAtop,
		Src,
		SrcIn,
		SrcOut,
		SrcOver,
		Threshold,
		VividLight,
		Xor,
		Stereo,
		Freeze,
		Interpolate,
		Negate,
		Reflect,
		SoftBurn,
		SoftDodge,
		Stamp,
		RMSE
	}
	public enum CompressionMethod
	{
		Undefined,
		B44A,
		B44,
		BZip,
		DXT1,
		DXT3,
		DXT5,
		Fax,
		Group4,
		JBIG1,
		JBIG2,
		JPEG2000,
		JPEG,
		LosslessJPEG,
		LZMA,
		LZW,
		NoCompression,
		Piz,
		Pxr24,
		RLE,
		Zip,
		ZipS,
		Zstd,
		WebP,
		DWAA,
		DWAB,
		BC7
	}
	public enum DensityUnit
	{
		Undefined,
		PixelsPerInch,
		PixelsPerCentimeter
	}
	public enum DistortMethod
	{
		Undefined,
		Affine,
		AffineProjection,
		ScaleRotateTranslate,
		Perspective,
		PerspectiveProjection,
		BilinearForward,
		BilinearReverse,
		Polynomial,
		Arc,
		Polar,
		DePolar,
		Cylinder2Plane,
		Plane2Cylinder,
		Barrel,
		BarrelInverse,
		Shepards,
		Resize,
		Sentinel,
		RigidAffine
	}
	public enum DitherMethod
	{
		Undefined,
		No,
		Riemersma,
		FloydSteinberg
	}
	public enum Endian
	{
		Undefined,
		LSB,
		MSB
	}
	public enum ErrorMetric
	{
		Undefined,
		Absolute,
		Fuzz,
		MeanAbsolute,
		MeanErrorPerPixel,
		MeanSquared,
		NormalizedCrossCorrelation,
		PeakAbsolute,
		PeakSignalToNoiseRatio,
		PerceptualHash,
		RootMeanSquared,
		StructuralSimilarity,
		StructuralDissimilarity
	}
	public enum EvaluateFunction
	{
		Undefined,
		Arcsin,
		Arctan,
		Polynomial,
		Sinusoid
	}
	public enum EvaluateOperator
	{
		Undefined,
		Abs,
		Add,
		AddModulus,
		And,
		Cosine,
		Divide,
		Exponential,
		GaussianNoise,
		ImpulseNoise,
		LaplacianNoise,
		LeftShift,
		Log,
		Max,
		Mean,
		Median,
		Min,
		MultiplicativeNoise,
		Multiply,
		Or,
		PoissonNoise,
		Pow,
		RightShift,
		RootMeanSquare,
		Set,
		Sine,
		Subtract,
		Sum,
		ThresholdBlack,
		Threshold,
		ThresholdWhite,
		UniformNoise,
		Xor,
		InverseLog
	}
	public enum FillRule
	{
		Undefined,
		EvenOdd,
		Nonzero
	}
	public enum FilterType
	{
		Undefined,
		Point,
		Box,
		Triangle,
		Hermite,
		Hann,
		Hamming,
		Blackman,
		Gaussian,
		Quadratic,
		Cubic,
		Catrom,
		Mitchell,
		Jinc,
		Sinc,
		SincFast,
		Kaiser,
		Welch,
		Parzen,
		Bohman,
		Bartlett,
		Lagrange,
		Lanczos,
		LanczosSharp,
		Lanczos2,
		Lanczos2Sharp,
		Robidoux,
		RobidouxSharp,
		Cosine,
		Spline,
		LanczosRadius,
		CubicSpline
	}
	public enum FontStretch
	{
		Undefined,
		Normal,
		UltraCondensed,
		ExtraCondensed,
		Condensed,
		SemiCondensed,
		SemiExpanded,
		Expanded,
		ExtraExpanded,
		UltraExpanded,
		Any
	}
	public enum FontStyleType
	{
		Undefined,
		Normal,
		Italic,
		Oblique,
		Any,
		Bold
	}
	public enum FontWeight
	{
		Undefined = 0,
		Thin = 100,
		ExtraLight = 200,
		UltraLight = 200,
		Light = 300,
		Normal = 400,
		Regular = 400,
		Medium = 500,
		DemiBold = 600,
		SemiBold = 600,
		Bold = 700,
		ExtraBold = 800,
		UltraBold = 800,
		Heavy = 900,
		Black = 900
	}
	public enum GifDisposeMethod
	{
		Undefined,
		None,
		Background,
		Previous
	}
	public enum Gravity
	{
		Undefined = 0,
		Forget = 0,
		Northwest = 1,
		North = 2,
		Northeast = 3,
		West = 4,
		Center = 5,
		East = 6,
		Southwest = 7,
		South = 8,
		Southeast = 9
	}
	public enum Interlace
	{
		Undefined,
		NoInterlace,
		Line,
		Plane,
		Partition,
		Gif,
		Jpeg,
		Png
	}
	public enum Kernel
	{
		Undefined,
		Unity,
		Gaussian,
		DoG,
		LoG,
		Blur,
		Comet,
		Binomial,
		Laplacian,
		Sobel,
		FreiChen,
		Roberts,
		Prewitt,
		Compass,
		Kirsch,
		Diamond,
		Square,
		Rectangle,
		Octagon,
		Disk,
		Plus,
		Cross,
		Ring,
		Peaks,
		Edges,
		Corners,
		Diagonals,
		LineEnds,
		LineJunctions,
		Ridges,
		ConvexHull,
		ThinSE,
		Skeleton,
		Chebyshev,
		Manhattan,
		Octagonal,
		Euclidean,
		UserDefined
	}
	public enum LineCap
	{
		Undefined,
		Butt,
		Round,
		Square
	}
	public enum LineJoin
	{
		Undefined,
		Miter,
		Round,
		Bevel
	}
	[Flags]
	public enum LogEvents
	{
		None = 0,
		Accelerate = 1,
		Annotate = 2,
		Blob = 4,
		Cache = 8,
		Coder = 0x10,
		Configure = 0x20,
		Deprecate = 0x40,
		Draw = 0x80,
		Exception = 0x100,
		Image = 0x200,
		Locale = 0x400,
		Module = 0x800,
		Pixel = 0x1000,
		Policy = 0x2000,
		Resource = 0x4000,
		Trace = 0x8000,
		Transform = 0x10000,
		User = 0x20000,
		Wand = 0x40000,
		Detailed = 0x7FFF7FFF,
		All = int.MaxValue
	}
	public enum MagickFormat
	{
		Unknown,
		ThreeFr,
		ThreeG2,
		ThreeGp,
		A,
		Aai,
		Ai,
		APng,
		Art,
		Arw,
		Ashlar,
		Avi,
		Avif,
		Avs,
		B,
		Bgr,
		Bgra,
		Bgro,
		Bmp,
		Bmp2,
		Bmp3,
		Brf,
		C,
		Cal,
		Cals,
		Canvas,
		Caption,
		Cin,
		Cip,
		Clip,
		Clipboard,
		Cmyk,
		Cmyka,
		Cr2,
		Cr3,
		Crw,
		Cube,
		Cur,
		Cut,
		Data,
		Dcm,
		Dcr,
		Dcraw,
		Dcx,
		Dds,
		Dfont,
		Dib,
		Dng,
		Dpx,
		Dxt1,
		Dxt5,
		Emf,
		Epdf,
		Epi,
		Eps,
		Eps2,
		Eps3,
		Epsf,
		Epsi,
		Ept,
		Ept2,
		Ept3,
		Erf,
		Exr,
		Farbfeld,
		Fax,
		Ff,
		File,
		Fits,
		Fl32,
		Flif,
		Flv,
		Fractal,
		Ftp,
		Fts,
		G,
		G3,
		G4,
		Gif,
		Gif87,
		Gradient,
		Gray,
		Graya,
		Group4,
		Hald,
		Hdr,
		Heic,
		Heif,
		Histogram,
		Hrz,
		Htm,
		Html,
		Http,
		Https,
		Icb,
		Ico,
		Icon,
		Iiq,
		Info,
		Inline,
		Ipl,
		Isobrl,
		Isobrl6,
		J2c,
		J2k,
		Jng,
		Jnx,
		Jp2,
		Jpc,
		Jpe,
		Jpeg,
		Jpg,
		Jpm,
		Jps,
		Jpt,
		Json,
		Jxl,
		K,
		K25,
		Kdc,
		Label,
		M,
		M2v,
		M4v,
		Mac,
		Map,
		Mask,
		Mat,
		Matte,
		Mef,
		Miff,
		Mkv,
		Mng,
		Mono,
		Mov,
		Mp4,
		Mpc,
		Mpeg,
		Mpg,
		Mrw,
		Msl,
		Msvg,
		Mtv,
		Mvg,
		Nef,
		Nrw,
		Null,
		O,
		Ora,
		Orf,
		Otb,
		Otf,
		Pal,
		Palm,
		Pam,
		Pango,
		Pattern,
		Pbm,
		Pcd,
		Pcds,
		Pcl,
		Pct,
		Pcx,
		Pdb,
		Pdf,
		Pdfa,
		Pef,
		Pes,
		Pfa,
		Pfb,
		Pfm,
		Pgm,
		Phm,
		Pgx,
		Picon,
		Pict,
		Pix,
		Pjpeg,
		Plasma,
		Png,
		Png00,
		Png24,
		Png32,
		Png48,
		Png64,
		Png8,
		Pnm,
		Pocketmod,
		Ppm,
		Ps,
		Ps2,
		Ps3,
		Psb,
		Psd,
		Ptif,
		Pwp,
		R,
		RadialGradient,
		Raf,
		Ras,
		Raw,
		Rgb,
		Rgb565,
		Rgba,
		Rgbo,
		Rgf,
		Rla,
		Rle,
		Rmf,
		Rsvg,
		Rw2,
		Scr,
		Screenshot,
		Sct,
		Sfw,
		Sgi,
		Shtml,
		Six,
		Sixel,
		SparseColor,
		Sr2,
		Srf,
		Stegano,
		Sun,
		Svg,
		Svgz,
		Text,
		Tga,
		Thumbnail,
		Tif,
		Tiff,
		Tiff64,
		Tile,
		Tim,
		Tm2,
		Ttc,
		Ttf,
		Txt,
		Ubrl,
		Ubrl6,
		Uil,
		Uyvy,
		Vda,
		Vicar,
		Vid,
		WebM,
		Viff,
		Vips,
		Vst,
		WebP,
		Wbmp,
		Wmf,
		Wmv,
		Wpg,
		X3f,
		Xbm,
		Xc,
		Xcf,
		Xpm,
		Xps,
		Xv,
		Y,
		Yaml,
		Ycbcr,
		Ycbcra,
		Yuv
	}
	public enum MorphologyMethod
	{
		Undefined,
		Convolve,
		Correlate,
		Erode,
		Dilate,
		ErodeIntensity,
		DilateIntensity,
		IterativeDistance,
		Open,
		Close,
		OpenIntensity,
		CloseIntensity,
		Smooth,
		EdgeIn,
		EdgeOut,
		Edge,
		TopHat,
		BottomHat,
		HitAndMiss,
		Thinning,
		Thicken,
		Distance,
		Voronoi
	}
	public enum NoiseType
	{
		Undefined,
		Uniform,
		Gaussian,
		MultiplicativeGaussian,
		Impulse,
		Laplacian,
		Poisson,
		Random
	}
	public enum OpenCLDeviceType
	{
		Undefined,
		Cpu,
		Gpu
	}
	public enum OrientationType
	{
		Undefined,
		TopLeft,
		TopRight,
		BottomRight,
		BottomLeft,
		LeftTop,
		RightTop,
		RightBottom,
		LeftBotom
	}
	public enum PaintMethod
	{
		Undefined,
		Point,
		Replace,
		Floodfill,
		FillToBorder,
		Reset
	}
	public enum PixelChannel
	{
		Red = 0,
		Cyan = 0,
		Gray = 0,
		Green = 1,
		Magenta = 1,
		Blue = 2,
		Yellow = 2,
		Black = 3,
		Alpha = 4,
		Index = 5,
		Composite = 64
	}
	public enum PixelIntensityMethod
	{
		Undefined,
		Average,
		Brightness,
		Lightness,
		MS,
		Rec601Luma,
		Rec601Luminance,
		Rec709Luma,
		Rec709Luminance,
		RMS
	}
	public enum PixelInterpolateMethod
	{
		Undefined,
		Average,
		Average9,
		Average16,
		Background,
		Bilinear,
		Blend,
		Catrom,
		Integer,
		Mesh,
		Nearest,
		Spline
	}
	public enum PixelMapping
	{
		RGB,
		BGR,
		RGBA,
		ABGR,
		CMYK
	}
	public enum RenderingIntent
	{
		Undefined,
		Saturation,
		Perceptual,
		Absolute,
		Relative
	}
	public enum SparseColorMethod
	{
		Undefined = 0,
		Barycentric = 1,
		Bilinear = 7,
		Polynomial = 8,
		Shepards = 16,
		Voronoi = 18,
		Inverse = 19,
		Manhattan = 20
	}
	public enum StatisticType
	{
		Undefined,
		Gradient,
		Maximum,
		Mean,
		Median,
		Minimum,
		Mode,
		Nonpeak,
		RootMeanSquare,
		StandardDeviation
	}
	public enum StorageType
	{
		Undefined,
		Char,
		Double,
		Float,
		Int32,
		Int64,
		Quantum,
		Short
	}
	public enum TextAlignment
	{
		Undefined,
		Left,
		Center,
		Right
	}
	public enum TextDecoration
	{
		Undefined,
		None,
		Underline,
		Overline,
		LineThrough
	}
	public enum TextDirection
	{
		Undefined,
		RightToLeft,
		LeftToRight
	}
	public enum VirtualPixelMethod
	{
		Undefined,
		Background,
		Dither,
		Edge,
		Mirror,
		Random,
		Tile,
		Transparent,
		Mask,
		Black,
		Gray,
		White,
		HorizontalTile,
		VerticalTile,
		HorizontalTileEdge,
		VerticalTileEdge,
		CheckerTile
	}
	public sealed class LogEventArgs : EventArgs
	{
		public LogEvents EventType { get; }

		public string? Message { get; }

		public LogEventArgs(LogEvents eventType, string? message)
		{
			EventType = eventType;
			Message = message;
		}
	}
	public sealed class ProgressEventArgs : EventArgs
	{
		public string? Origin { get; }

		public Percentage Progress { get; }

		public bool Cancel { get; set; }

		public ProgressEventArgs(string? origin, int offset, int extent)
		{
			Origin = origin;
			Progress = new Percentage((double)(offset + 1) / (double)extent * 100.0);
		}
	}
	public sealed class WarningEventArgs : EventArgs
	{
		public string Message => Exception.Message;

		public MagickWarningException Exception { get; }

		public WarningEventArgs(MagickWarningException exception)
		{
			Exception = exception;
		}
	}
	public sealed class MagickBlobErrorException : MagickErrorException
	{
		public MagickBlobErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickCacheErrorException : MagickErrorException
	{
		public MagickCacheErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickCoderErrorException : MagickErrorException
	{
		public MagickCoderErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickConfigureErrorException : MagickErrorException
	{
		public MagickConfigureErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickCorruptImageErrorException : MagickErrorException
	{
		public MagickCorruptImageErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickDelegateErrorException : MagickErrorException
	{
		public MagickDelegateErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickDrawErrorException : MagickErrorException
	{
		public MagickDrawErrorException(string message)
			: base(message)
		{
		}
	}
	public class MagickErrorException : MagickException
	{
		public MagickErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickFileOpenErrorException : MagickErrorException
	{
		public MagickFileOpenErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickImageErrorException : MagickErrorException
	{
		public MagickImageErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickMissingDelegateErrorException : MagickErrorException
	{
		public MagickMissingDelegateErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickModuleErrorException : MagickErrorException
	{
		public MagickModuleErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickOptionErrorException : MagickErrorException
	{
		public MagickOptionErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickPolicyErrorException : MagickErrorException
	{
		public MagickPolicyErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickRegistryErrorException : MagickErrorException
	{
		public MagickRegistryErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickResourceLimitErrorException : MagickErrorException
	{
		public MagickResourceLimitErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickStreamErrorException : MagickErrorException
	{
		public MagickStreamErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickTypeErrorException : MagickErrorException
	{
		public MagickTypeErrorException(string message)
			: base(message)
		{
		}
	}
	public abstract class MagickException : Exception
	{
		private List<MagickException>? _relatedExceptions;

		public IEnumerable<MagickException> RelatedExceptions
		{
			get
			{
				if (_relatedExceptions == null)
				{
					return new MagickException[0];
				}
				return _relatedExceptions;
			}
		}

		public MagickException(string message)
			: base(message)
		{
		}

		public void SetRelatedException(List<MagickException> relatedExceptions)
		{
			_relatedExceptions = relatedExceptions;
		}
	}
	public sealed class MagickBlobWarningException : MagickWarningException
	{
		public MagickBlobWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickCacheWarningException : MagickWarningException
	{
		public MagickCacheWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickCoderWarningException : MagickWarningException
	{
		public MagickCoderWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickConfigureWarningException : MagickWarningException
	{
		public MagickConfigureWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickCorruptImageWarningException : MagickWarningException
	{
		public MagickCorruptImageWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickDelegateWarningException : MagickWarningException
	{
		public MagickDelegateWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickDrawWarningException : MagickWarningException
	{
		public MagickDrawWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickFileOpenWarningException : MagickWarningException
	{
		public MagickFileOpenWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickImageWarningException : MagickWarningException
	{
		public MagickImageWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickMissingDelegateWarningException : MagickWarningException
	{
		public MagickMissingDelegateWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickModuleWarningException : MagickWarningException
	{
		public MagickModuleWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickOptionWarningException : MagickWarningException
	{
		public MagickOptionWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickPolicyWarningException : MagickErrorException
	{
		public MagickPolicyWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickRegistryWarningException : MagickWarningException
	{
		public MagickRegistryWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickResourceLimitWarningException : MagickWarningException
	{
		public MagickResourceLimitWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickStreamWarningException : MagickWarningException
	{
		public MagickStreamWarningException(string message)
			: base(message)
		{
		}
	}
	public sealed class MagickTypeWarningException : MagickWarningException
	{
		public MagickTypeWarningException(string message)
			: base(message)
		{
		}
	}
	public class MagickWarningException : MagickException
	{
		public MagickWarningException(string message)
			: base(message)
		{
		}
	}
	public interface IDrawablesFactory<TQuantumType> where TQuantumType : struct
	{
		IDrawables<TQuantumType> Create();
	}
	public interface IMagickColorFactory<TQuantumType> where TQuantumType : struct
	{
		IMagickColor<TQuantumType> Create();

		IMagickColor<TQuantumType> Create(IMagickColor<TQuantumType> color);

		IMagickColor<TQuantumType> Create(TQuantumType red, TQuantumType green, TQuantumType blue);

		IMagickColor<TQuantumType> Create(TQuantumType red, TQuantumType green, TQuantumType blue, TQuantumType alpha);

		IMagickColor<TQuantumType> Create(TQuantumType cyan, TQuantumType magenta, TQuantumType yellow, TQuantumType black, TQuantumType alpha);

		IMagickColor<TQuantumType> Create(string color);
	}
	public interface IMagickFactory
	{
		IMagickGeometryFactory Geometry { get; }

		IMagickImageInfoFactory ImageInfo { get; }

		IMatrixFactory Matrix { get; }
	}
	public interface IMagickFactory<TQuantumType> : IMagickFactory where TQuantumType : struct
	{
		IMagickColorFactory<TQuantumType> Color { get; }

		IDrawablesFactory<TQuantumType> Drawables { get; }

		IMagickImageFactory<TQuantumType> Image { get; }

		IMagickImageCollectionFactory<TQuantumType> ImageCollection { get; }

		IQuantumInfo<TQuantumType> QuantumInfo { get; }

		ISettingsFactory<TQuantumType> Settings { get; }
	}
	public interface IMagickGeometryFactory
	{
		IMagickGeometry Create();

		IMagickGeometry Create(int widthAndHeight);

		IMagickGeometry Create(int width, int height);

		IMagickGeometry Create(int x, int y, int width, int height);

		IMagickGeometry Create(Percentage percentageWidth, Percentage percentageHeight);

		IMagickGeometry Create(int x, int y, Percentage percentageWidth, Percentage percentageHeight);

		IMagickGeometry Create(string value);

		IMagickGeometry CreateFromPageSize(string pageSize);
	}
	public interface IMagickImageCollectionFactory<TQuantumType> where TQuantumType : struct
	{
		IMagickImageCollection<TQuantumType> Create();

		IMagickImageCollection<TQuantumType> Create(byte[] data);

		IMagickImageCollection<TQuantumType> Create(byte[] data, int offset, int count);

		IMagickImageCollection<TQuantumType> Create(byte[] data, int offset, int count, IMagickReadSettings<TQuantumType> readSettings);

		IMagickImageCollection<TQuantumType> Create(byte[] data, IMagickReadSettings<TQuantumType> readSettings);

		IMagickImageCollection<TQuantumType> Create(FileInfo file);

		IMagickImageCollection<TQuantumType> Create(FileInfo file, IMagickReadSettings<TQuantumType> readSettings);

		IMagickImageCollection<TQuantumType> Create(IEnumerable<IMagickImage<TQuantumType>> images);

		IMagickImageCollection<TQuantumType> Create(Stream stream);

		IMagickImageCollection<TQuantumType> Create(Stream stream, IMagickReadSettings<TQuantumType> readSettings);

		IMagickImageCollection<TQuantumType> Create(string fileName);

		IMagickImageCollection<TQuantumType> Create(string fileName, IMagickReadSettings<TQuantumType> readSettings);
	}
	public interface IMagickImageFactory<TQuantumType> where TQuantumType : struct
	{
		IMagickImage<TQuantumType> Create();

		IMagickImage<TQuantumType> Create(byte[] data);

		IMagickImage<TQuantumType> Create(byte[] data, int offset, int count);

		IMagickImage<TQuantumType> Create(byte[] data, int offset, int count, IMagickReadSettings<TQuantumType> readSettings);

		IMagickImage<TQuantumType> Create(byte[] data, int offset, int count, IPixelReadSettings<TQuantumType> settings);

		IMagickImage<TQuantumType> Create(byte[] data, IMagickReadSettings<TQuantumType> readSettings);

		IMagickImage<TQuantumType> Create(byte[] data, IPixelReadSettings<TQuantumType> settings);

		IMagickImage<TQuantumType> Create(FileInfo file);

		IMagickImage<TQuantumType> Create(FileInfo file, IMagickReadSettings<TQuantumType> readSettings);

		IMagickImage<TQuantumType> Create(FileInfo file, IPixelReadSettings<TQuantumType> settings);

		IMagickImage<TQuantumType> Create(IMagickColor<TQuantumType> color, int width, int height);

		IMagickImage<TQuantumType> Create(Stream stream);

		IMagickImage<TQuantumType> Create(Stream stream, IMagickReadSettings<TQuantumType> readSettings);

		IMagickImage<TQuantumType> Create(Stream stream, IPixelReadSettings<TQuantumType> settings);

		IMagickImage<TQuantumType> Create(string fileName);

		IMagickImage<TQuantumType> Create(string fileName, int width, int height);

		IMagickImage<TQuantumType> Create(string fileName, IMagickReadSettings<TQuantumType> readSettings);

		IMagickImage<TQuantumType> Create(string fileName, IPixelReadSettings<TQuantumType> settings);
	}
	public interface IMagickImageInfoFactory
	{
		IMagickImageInfo Create();

		IMagickImageInfo Create(byte[] data);

		IMagickImageInfo Create(byte[] data, int offset, int count);

		IMagickImageInfo Create(FileInfo file);

		IMagickImageInfo Create(Stream stream);

		IMagickImageInfo Create(string fileName);
	}
	public interface IMatrixFactory
	{
		IMagickColorMatrix CreateColorMatrix(int order);

		IMagickColorMatrix CreateColorMatrix(int order, params double[] values);

		IConvolveMatrix CreateConvolveMatrix(int order);

		IConvolveMatrix CreateConvolveMatrix(int order, params double[] values);
	}
	public interface ISettingsFactory<TQuantumType> where TQuantumType : struct
	{
		ICompareSettings<TQuantumType> CreateCompareSettings();

		IComplexSettings CreateComplexSettings();

		IConnectedComponentsSettings CreateConnectedComponentsSettings();

		IDeskewSettings CreateDeskewSettings();

		IDistortSettings CreateDistortSettings();

		IKmeansSettings CreateKmeansSettings();

		IMagickReadSettings<TQuantumType> CreateMagickReadSettings();

		IMontageSettings<TQuantumType> CreateMontageSettings();

		IMorphologySettings CreateMorphologySettings();

		IPixelReadSettings<TQuantumType> CreatePixelReadSettings();

		IQuantizeSettings CreateQuantizeSettings();
	}
	internal static class XmlHelper
	{
		public static XmlReaderSettings CreateReaderSettings()
		{
			return new XmlReaderSettings
			{
				XmlResolver = null
			};
		}

		public static XmlDocument CreateDocument()
		{
			return new XmlDocument
			{
				XmlResolver = null
			};
		}

		public static XmlElement CreateElement(XmlNode node, string name)
		{
			XmlElement xmlElement = (((object)node.GetType() == typeof(XmlDocument)) ? ((XmlDocument)node) : node.OwnerDocument).CreateElement(name);
			node.AppendChild(xmlElement);
			return xmlElement;
		}

		public static void SetAttribute<TType>(XmlElement element, string name, TType value)
		{
			XmlAttribute xmlAttribute = ((!element.HasAttribute(name)) ? element.Attributes.Append(element.OwnerDocument.CreateAttribute(name)) : element.Attributes[name]);
			if ((object)typeof(TType) == typeof(string))
			{
				xmlAttribute.Value = (string)(object)value;
			}
			else
			{
				xmlAttribute.Value = (string)Convert.ChangeType(value, typeof(string), CultureInfo.InvariantCulture);
			}
		}
	}
	internal static class ByteConverter
	{
		public static int ToUInt(byte[] data, ref int offset)
		{
			if (offset + 4 > data.Length)
			{
				return 0;
			}
			int num = (int)(((data[offset++] << 24) | (data[offset++] << 16) | (data[offset++] << 8) | data[offset++]) & 0xFFFFFFFFu);
			if (num >= 0)
			{
				return num;
			}
			return 0;
		}

		public static short ToShort(byte[] data, ref int offset)
		{
			if (offset + 2 > data.Length)
			{
				return 0;
			}
			return (short)((short)((short)(data[offset++] << 8) | data[offset++]) & 0xFFFF);
		}
	}
	public interface IMagickFormatInfo : IEquatable<IMagickFormatInfo>
	{
		bool CanReadMultithreaded { get; }

		bool CanWriteMultithreaded { get; }

		string? Description { get; }

		MagickFormat Format { get; }

		bool IsMultiFrame { get; }

		bool IsReadable { get; }

		bool IsWritable { get; }

		string? MimeType { get; }

		MagickFormat ModuleFormat { get; }

		new string ToString();

		bool Unregister();
	}
	public interface IMagickImage : IDisposable
	{
		int AnimationDelay { get; set; }

		int AnimationIterations { get; set; }

		int AnimationTicksPerSecond { get; set; }

		IEnumerable<string> ArtifactNames { get; }

		IEnumerable<string> AttributeNames { get; }

		int BaseHeight { get; }

		int BaseWidth { get; }

		bool BlackPointCompensation { get; set; }

		IMagickGeometry? BoundingBox { get; }

		int ChannelCount { get; }

		IEnumerable<PixelChannel> Channels { get; }

		IPrimaryInfo? ChromaBluePrimary { get; set; }

		IPrimaryInfo? ChromaGreenPrimary { get; set; }

		IPrimaryInfo? ChromaRedPrimary { get; set; }

		IPrimaryInfo? ChromaWhitePoint { get; set; }

		ClassType ClassType { get; set; }

		Percentage ColorFuzz { get; set; }

		int ColormapSize { get; set; }

		ColorSpace ColorSpace { get; set; }

		ColorType ColorType { get; set; }

		string? Comment { get; set; }

		CompositeOperator Compose { get; set; }

		CompressionMethod Compression { get; }

		Density Density { get; set; }

		int Depth { get; set; }

		IMagickGeometry? EncodingGeometry { get; }

		Endian Endian { get; set; }

		string? FileName { get; }

		FilterType FilterType { get; set; }

		MagickFormat Format { get; set; }

		IMagickFormatInfo? FormatInfo { get; }

		double Gamma { get; }

		GifDisposeMethod GifDisposeMethod { get; set; }

		bool HasClippingPath { get; }

		bool HasAlpha { get; set; }

		int Height { get; }

		Interlace Interlace { get; set; }

		PixelInterpolateMethod Interpolate { get; set; }

		bool IsDisposed { get; }

		bool IsOpaque { get; }

		string? Label { get; set; }

		OrientationType Orientation { get; set; }

		IMagickGeometry Page { get; set; }

		IEnumerable<string> ProfileNames { get; }

		int Quality { get; set; }

		RenderingIntent RenderingIntent { get; set; }

		string Signature { get; }

		int TotalColors { get; }

		VirtualPixelMethod VirtualPixelMethod { get; set; }

		int Width { get; }

		event EventHandler<ProgressEventArgs> Progress;

		event EventHandler<WarningEventArgs> Warning;

		void AdaptiveBlur();

		void AdaptiveBlur(double radius);

		void AdaptiveBlur(double radius, double sigma);

		void AdaptiveResize(int width, int height);

		void AdaptiveResize(IMagickGeometry geometry);

		void AdaptiveSharpen();

		void AdaptiveSharpen(Channels channels);

		void AdaptiveSharpen(double radius, double sigma);

		void AdaptiveSharpen(double radius, double sigma, Channels channels);

		void AdaptiveThreshold(int width, int height);

		void AdaptiveThreshold(int width, int height, Channels channels);

		void AdaptiveThreshold(int width, int height, double bias);

		void AdaptiveThreshold(int width, int height, double bias, Channels channels);

		void AdaptiveThreshold(int width, int height, Percentage biasPercentage);

		void AdaptiveThreshold(int width, int height, Percentage biasPercentage, Channels channels);

		void AddNoise(NoiseType noiseType);

		void AddNoise(NoiseType noiseType, Channels channels);

		void AddNoise(NoiseType noiseType, double attenuate);

		void AddNoise(NoiseType noiseType, double attenuate, Channels channels);

		void AffineTransform(IDrawableAffine affineMatrix);

		void Alpha(AlphaOption value);

		void Annotate(string text, IMagickGeometry boundingArea);

		void Annotate(string text, IMagickGeometry boundingArea, Gravity gravity);

		void Annotate(string text, IMagickGeometry boundingArea, Gravity gravity, double angle);

		void Annotate(string text, Gravity gravity);

		void AutoGamma();

		void AutoGamma(Channels channels);

		void AutoLevel();

		void AutoLevel(Channels channels);

		void AutoOrient();

		void AutoThreshold(AutoThresholdMethod method);

		void BilateralBlur(int width, int height);

		void BilateralBlur(int width, int height, double intensitySigma, double spatialSigma);

		void BlackThreshold(Percentage threshold);

		void BlackThreshold(Percentage threshold, Channels channels);

		void BlueShift();

		void BlueShift(double factor);

		int BitDepth();

		int BitDepth(Channels channels);

		void BitDepth(Channels channels, int value);

		void BitDepth(int value);

		void Blur();

		void Blur(Channels channels);

		void Blur(double radius, double sigma);

		void Blur(double radius, double sigma, Channels channels);

		void Border(int size);

		void Border(int width, int height);

		void BrightnessContrast(Percentage brightness, Percentage contrast);

		void BrightnessContrast(Percentage brightness, Percentage contrast, Channels channels);

		void CannyEdge();

		void CannyEdge(double radius, double sigma, Percentage lower, Percentage upper);

		void Charcoal();

		void Charcoal(double radius, double sigma);

		void Chop(IMagickGeometry geometry);

		void ChopHorizontal(int offset, int width);

		void ChopVertical(int offset, int height);

		void Clahe(Percentage xTiles, Percentage yTiles, int numberBins, double clipLimit);

		void Clahe(int xTiles, int yTiles, int numberBins, double clipLimit);

		void Clamp();

		void Clamp(Channels channels);

		void Clip();

		void Clip(string pathName, bool inside);

		void Clut(IMagickImage image);

		void Clut(IMagickImage image, PixelInterpolateMethod method);

		void Clut(IMagickImage image, PixelInterpolateMethod method, Channels channels);

		void ColorDecisionList(string fileName);

		void ColorMatrix(IMagickColorMatrix matrix);

		IMagickErrorInfo Compare(IMagickImage image);

		double Compare(IMagickImage image, ErrorMetric metric);

		double Compare(IMagickImage image, ErrorMetric metric, Channels channels);

		double Compare(IMagickImage image, ErrorMetric metric, IMagickImage difference);

		double Compare(IMagickImage image, ErrorMetric metric, IMagickImage difference, Channels channels);

		void Composite(IMagickImage image);

		void Composite(IMagickImage image, Channels channels);

		void Composite(IMagickImage image, CompositeOperator compose);

		void Composite(IMagickImage image, CompositeOperator compose, Channels channels);

		void Composite(IMagickImage image, CompositeOperator compose, string? args);

		void Composite(IMagickImage image, CompositeOperator compose, string? args, Channels channels);

		void Composite(IMagickImage image, int x, int y);

		void Composite(IMagickImage image, int x, int y, Channels channels);

		void Composite(IMagickImage image, int x, int y, CompositeOperator compose);

		void Composite(IMagickImage image, int x, int y, CompositeOperator compose, Channels channels);

		void Composite(IMagickImage image, int x, int y, CompositeOperator compose, string? args);

		void Composite(IMagickImage image, int x, int y, CompositeOperator compose, string? args, Channels channels);

		void Composite(IMagickImage image, PointD offset);

		void Composite(IMagickImage image, PointD offset, Channels channels);

		void Composite(IMagickImage image, PointD offset, CompositeOperator compose);

		void Composite(IMagickImage image, PointD offset, CompositeOperator compose, Channels channels);

		void Composite(IMagickImage image, PointD offset, CompositeOperator compose, string? args);

		void Composite(IMagickImage image, PointD offset, CompositeOperator compose, string? args, Channels channels);

		void Composite(IMagickImage image, Gravity gravity);

		void Composite(IMagickImage image, Gravity gravity, Channels channels);

		void Composite(IMagickImage image, Gravity gravity, CompositeOperator compose);

		void Composite(IMagickImage image, Gravity gravity, CompositeOperator compose, Channels channels);

		void Composite(IMagickImage image, Gravity gravity, CompositeOperator compose, string? args);

		void Composite(IMagickImage image, Gravity gravity, CompositeOperator compose, string? args, Channels channels);

		void Composite(IMagickImage image, Gravity gravity, int x, int y);

		void Composite(IMagickImage image, Gravity gravity, int x, int y, Channels channels);

		void Composite(IMagickImage image, Gravity gravity, int x, int y, CompositeOperator compose);

		void Composite(IMagickImage image, Gravity gravity, int x, int y, CompositeOperator compose, Channels channels);

		void Composite(IMagickImage image, Gravity gravity, int x, int y, CompositeOperator compose, string? args);

		void Composite(IMagickImage image, Gravity gravity, int x, int y, CompositeOperator compose, string? args, Channels channels);

		void Composite(IMagickImage image, Gravity gravity, PointD offset);

		void Composite(IMagickImage image, Gravity gravity, PointD offset, Channels channels);

		void Composite(IMagickImage image, Gravity gravity, PointD offset, CompositeOperator compose);

		void Composite(IMagickImage image, Gravity gravity, PointD offset, CompositeOperator compose, Channels channels);

		void Composite(IMagickImage image, Gravity gravity, PointD offset, CompositeOperator compose, string? args);

		void Composite(IMagickImage image, Gravity gravity, PointD offset, CompositeOperator compose, string? args, Channels channels);

		void Contrast();

		void Contrast(bool enhance);

		void ContrastStretch(Percentage blackPoint);

		void ContrastStretch(Percentage blackPoint, Percentage whitePoint);

		void ContrastStretch(Percentage blackPoint, Percentage whitePoint, Channels channels);

		IEnumerable<PointD> ConvexHull();

		void Convolve(IConvolveMatrix convolveMatrix);

		void CopyPixels(IMagickImage source);

		void CopyPixels(IMagickImage source, Channels channels);

		void CopyPixels(IMagickImage source, IMagickGeometry geometry);

		void CopyPixels(IMagickImage source, IMagickGeometry geometry, Channels channels);

		void CopyPixels(IMagickImage source, IMagickGeometry geometry, PointD offset);

		void CopyPixels(IMagickImage source, IMagickGeometry geometry, PointD offset, Channels channels);

		void CopyPixels(IMagickImage source, IMagickGeometry geometry, int x, int y);

		void CopyPixels(IMagickImage source, IMagickGeometry geometry, int x, int y, Channels channels);

		void Crop(int width, int height);

		void Crop(int width, int height, Gravity gravity);

		void Crop(IMagickGeometry geometry);

		void Crop(IMagickGeometry geometry, Gravity gravity);

		void CycleColormap(int amount);

		void Decipher(string passphrase);

		double Deskew(Percentage threshold);

		double Deskew(IDeskewSettings settings);

		void Despeckle();

		ColorType DetermineColorType();

		void Distort(DistortMethod method, params double[] arguments);

		void Distort(DistortMethod method, IDistortSettings settings, params double[] arguments);

		void Draw(params IDrawable[] drawables);

		void Draw(IEnumerable<IDrawable> drawables);

		void Edge(double radius);

		void Emboss();

		void Emboss(double radius, double sigma);

		void Encipher(string passphrase);

		void Enhance();

		void Equalize();

		void Evaluate(Channels channels, EvaluateFunction evaluateFunction, params double[] arguments);

		void Evaluate(Channels channels, EvaluateOperator evaluateOperator, double value);

		void Evaluate(Channels channels, EvaluateOperator evaluateOperator, Percentage percentage);

		void Evaluate(Channels channels, IMagickGeometry geometry, EvaluateOperator evaluateOperator, double value);

		void Evaluate(Channels channels, IMagickGeometry geometry, EvaluateOperator evaluateOperator, Percentage percentage);

		void Extent(int width, int height);

		void Extent(int x, int y, int width, int height);

		void Extent(int width, int height, Gravity gravity);

		void Extent(IMagickGeometry geometry);

		void Extent(IMagickGeometry geometry, Gravity gravity);

		void Flip();

		void Flop();

		ITypeMetric? FontTypeMetrics(string text);

		ITypeMetric? FontTypeMetrics(string text, bool ignoreNewlines);

		string? FormatExpression(string expression);

		void Frame();

		void Frame(IMagickGeometry geometry);

		void Frame(int width, int height);

		void Frame(int width, int height, int innerBevel, int outerBevel);

		void Fx(string expression);

		void Fx(string expression, Channels channels);

		void GammaCorrect(double gamma);

		void GammaCorrect(double gamma, Channels channels);

		void GaussianBlur(double radius);

		void GaussianBlur(double radius, Channels channels);

		void GaussianBlur(double radius, double sigma);

		void GaussianBlur(double radius, double sigma, Channels channels);

		IEightBimProfile? Get8BimProfile();

		string? GetArtifact(string name);

		string? GetAttribute(string name);

		string? GetClippingPath();

		string? GetClippingPath(string pathName);

		IColorProfile? GetColorProfile();

		IExifProfile? GetExifProfile();

		IIptcProfile? GetIptcProfile();

		IImageProfile? GetProfile(string name);

		IXmpProfile? GetXmpProfile();

		void Grayscale();

		void Grayscale(PixelIntensityMethod method);

		void HaldClut(IMagickImage image);

		bool HasProfile(string name);

		void HoughLine();

		void HoughLine(int width, int height, int threshold);

		void Implode(double amount, PixelInterpolateMethod method);

		void InterpolativeResize(int width, int height, PixelInterpolateMethod method);

		void InterpolativeResize(IMagickGeometry geometry, PixelInterpolateMethod method);

		void InterpolativeResize(Percentage percentage, PixelInterpolateMethod method);

		void InterpolativeResize(Percentage percentageWidth, Percentage percentageHeight, PixelInterpolateMethod method);

		void InverseLevel(Percentage blackPointPercentage, Percentage whitePointPercentage);

		void InverseLevel(Percentage blackPointPercentage, Percentage whitePointPercentage, Channels channels);

		void InverseLevel(Percentage blackPointPercentage, Percentage whitePointPercentage, double midpoint);

		void InverseLevel(Percentage blackPointPercentage, Percentage whitePointPercentage, double midpoint, Channels channels);

		void Kmeans(IKmeansSettings settings);

		void Kuwahara();

		void Kuwahara(double radius, double sigma);

		void Level(Percentage blackPointPercentage, Percentage whitePointPercentage);

		void Level(Percentage blackPointPercentage, Percentage whitePointPercentage, Channels channels);

		void Level(Percentage blackPointPercentage, Percentage whitePointPercentage, double gamma);

		void Level(Percentage blackPointPercentage, Percentage whitePointPercentage, double gamma, Channels channels);

		void LinearStretch(Percentage blackPoint, Percentage whitePoint);

		void LiquidRescale(int width, int height);

		void LiquidRescale(int width, int height, double deltaX, double rigidity);

		void LiquidRescale(IMagickGeometry geometry);

		void LiquidRescale(Percentage percentage);

		void LiquidRescale(Percentage percentageWidth, Percentage percentageHeight);

		void LiquidRescale(Percentage percentageWidth, Percentage percentageHeight, double deltaX, double rigidity);

		void LocalContrast(double radius, Percentage strength);

		void LocalContrast(double radius, Percentage strength, Channels channels);

		void Lower(int size);

		void Magnify();

		IMagickErrorInfo Map(IMagickImage image);

		IMagickErrorInfo Map(IMagickImage image, IQuantizeSettings settings);

		void MeanShift(int size);

		void MeanShift(int size, Percentage colorDistance);

		void MeanShift(int width, int height);

		void MeanShift(int width, int height, Percentage colorDistance);

		void MedianFilter();

		void MedianFilter(int radius);

		void Minify();

		IEnumerable<PointD> MinimumBoundingBox();

		void Modulate(Percentage brightness);

		void Modulate(Percentage brightness, Percentage saturation);

		void Modulate(Percentage brightness, Percentage saturation, Percentage hue);

		void Morphology(MorphologyMethod method, Kernel kernel);

		void Morphology(MorphologyMethod method, Kernel kernel, Channels channels);

		void Morphology(MorphologyMethod method, Kernel kernel, Channels channels, int iterations);

		void Morphology(MorphologyMethod method, Kernel kernel, int iterations);

		void Morphology(MorphologyMethod method, Kernel kernel, string? arguments);

		void Morphology(MorphologyMethod method, Kernel kernel, string? arguments, Channels channels);

		void Morphology(MorphologyMethod method, Kernel kernel, string? arguments, Channels channels, int iterations);

		void Morphology(MorphologyMethod method, Kernel kernel, string? arguments, int iterations);

		void Morphology(MorphologyMethod method, string userKernel);

		void Morphology(MorphologyMethod method, string userKernel, Channels channels);

		void Morphology(MorphologyMethod method, string userKernel, Channels channels, int iterations);

		void Morphology(MorphologyMethod method, string userKernel, int iterations);

		void Morphology(IMorphologySettings settings);

		IMoments Moments();

		void MotionBlur(double radius, double sigma, double angle);

		void Negate();

		void Negate(bool onlyGrayscale);

		void Negate(bool onlyGrayscale, Channels channels);

		void Negate(Channels channels);

		void Normalize();

		void OilPaint();

		void OilPaint(double radius, double sigma);

		void OrderedDither(string thresholdMap);

		void OrderedDither(string thresholdMap, Channels channels);

		void Perceptible(double epsilon);

		void Perceptible(double epsilon, Channels channels);

		IPerceptualHash? PerceptualHash();

		void Ping(byte[] data);

		void Ping(byte[] data, int offset, int count);

		void Ping(FileInfo file);

		void Ping(Stream stream);

		void Ping(string fileName);

		void Polaroid(string caption, double angle, PixelInterpolateMethod method);

		void Posterize(int levels);

		void Posterize(int levels, DitherMethod method);

		void Posterize(int levels, DitherMethod method, Channels channels);

		void Posterize(int levels, Channels channels);

		void PreserveColorType();

		IMagickErrorInfo? Quantize(IQuantizeSettings settings);

		void Raise(int size);

		void RandomThreshold(Percentage percentageLow, Percentage percentageHigh);

		void RandomThreshold(Percentage percentageLow, Percentage percentageHigh, Channels channels);

		void RangeThreshold(Percentage percentageLowBlack, Percentage percentageLowWhite, Percentage percentageHighWhite, Percentage percentageHighBlack);

		void Read(byte[] data);

		void Read(byte[] data, int offset, int count);

		void Read(byte[] data, int offset, int count, MagickFormat format);

		void Read(byte[] data, MagickFormat format);

		void Read(FileInfo file);

		void Read(FileInfo file, int width, int height);

		void Read(FileInfo file, MagickFormat format);

		void Read(Stream stream);

		void Read(Stream stream, MagickFormat format);

		void Read(string fileName);

		void Read(string fileName, int width, int height);

		void Read(string fileName, MagickFormat format);

		void ReduceNoise();

		void ReduceNoise(int order);

		void RegionMask(IMagickGeometry region);

		void RemoveArtifact(string name);

		void RemoveAttribute(string name);

		void RemoveRegionMask();

		void RemoveProfile(IImageProfile profile);

		void RemoveProfile(string name);

		void RemoveReadMask();

		void RemoveWriteMask();

		void RePage();

		void Resample(double resolutionX, double resolutionY);

		void Resample(PointD density);

		void Resize(int width, int height);

		void Resize(IMagickGeometry geometry);

		void Resize(Percentage percentage);

		void Resize(Percentage percentageWidth, Percentage percentageHeight);

		void Roll(int x, int y);

		void Rotate(double degrees);

		void RotationalBlur(double angle);

		void RotationalBlur(double angle, Channels channels);

		void Sample(int width, int height);

		void Sample(IMagickGeometry geometry);

		void Sample(Percentage percentage);

		void Sample(Percentage percentageWidth, Percentage percentageHeight);

		void Scale(int width, int height);

		void Scale(IMagickGeometry geometry);

		void Scale(Percentage percentage);

		void Scale(Percentage percentageWidth, Percentage percentageHeight);

		void Segment();

		void Segment(ColorSpace quantizeColorSpace, double clusterThreshold, double smoothingThreshold);

		void SelectiveBlur(double radius, double sigma, double threshold);

		void SelectiveBlur(double radius, double sigma, double threshold, Channels channels);

		void SelectiveBlur(double radius, double sigma, Percentage thresholdPercentage);

		void SelectiveBlur(double radius, double sigma, Percentage thresholdPercentage, Channels channels);

		void SepiaTone();

		void SepiaTone(Percentage threshold);

		void SetArtifact(string name, string value);

		void SetArtifact(string name, bool flag);

		void SetAttenuate(double attenuate);

		void SetAttribute(string name, string value);

		void SetAttribute(string name, bool flag);

		void SetClippingPath(string value);

		void SetClippingPath(string value, string pathName);

		void SetCompression(CompressionMethod compression);

		void SetProfile(IImageProfile profile);

		void SetProfile(IColorProfile profile);

		void SetProfile(IColorProfile profile, ColorTransformMode mode);

		void SetReadMask(IMagickImage image);

		void SetWriteMask(IMagickImage image);

		void Shadow(int x, int y, double sigma, Percentage alpha);

		void Sharpen();

		void Sharpen(Channels channels);

		void Sharpen(double radius, double sigma);

		void Sharpen(double radius, double sigma, Channels channels);

		void Shave(int leftRight, int topBottom);

		void Shear(double xAngle, double yAngle);

		void SigmoidalContrast(double contrast);

		void SigmoidalContrast(bool sharpen, double contrast);

		void SigmoidalContrast(double contrast, double midpoint);

		void SigmoidalContrast(bool sharpen, double contrast, double midpoint);

		void SigmoidalContrast(double contrast, Percentage midpointPercentage);

		void SigmoidalContrast(bool sharpen, double contrast, Percentage midpointPercentage);

		void Sketch();

		void Sketch(double radius, double sigma, double angle);

		void Solarize();

		void Solarize(double factor);

		void SortPixels();

		void Solarize(Percentage factorPercentage);

		void Splice(IMagickGeometry geometry);

		void Spread();

		void Spread(double radius);

		void Spread(PixelInterpolateMethod method, double radius);

		void Statistic(StatisticType type, int width, int height);

		IStatistics Statistics();

		IStatistics Statistics(Channels channels);

		void Shade();

		void Shade(double azimuth, double elevation);

		void Shade(double azimuth, double elevation, bool colorShading);

		void Shade(double azimuth, double elevation, bool colorShading, Channels channels);

		void Shadow();

		void Stegano(IMagickImage watermark);

		void Stereo(IMagickImage rightImage);

		void Strip();

		void Swirl(double degrees);

		void Swirl(PixelInterpolateMethod method, double degrees);

		void Texture(IMagickImage image);

		void Threshold(Percentage percentage);

		void Threshold(Percentage percentage, Channels channels);

		void Thumbnail(int width, int height);

		void Thumbnail(IMagickGeometry geometry);

		void Thumbnail(Percentage percentage);

		void Thumbnail(Percentage percentageWidth, Percentage percentageHeight);

		void Tile(IMagickImage image, CompositeOperator compose);

		void Tile(IMagickImage image, CompositeOperator compose, string? args);

		void Tint(string opacity);

		string ToBase64();

		string ToBase64(MagickFormat format);

		byte[] ToByteArray();

		byte[] ToByteArray(IWriteDefines defines);

		byte[] ToByteArray(MagickFormat format);

		bool TransformColorSpace(IColorProfile target);

		bool TransformColorSpace(IColorProfile target, ColorTransformMode mode);

		bool TransformColorSpace(IColorProfile source, IColorProfile target);

		bool TransformColorSpace(IColorProfile source, IColorProfile target, ColorTransformMode mode);

		void Transpose();

		void Transverse();

		void Trim();

		void Trim(params Gravity[] edges);

		void Trim(Percentage percentBackground);

		void UnsharpMask(double radius, double sigma);

		void UnsharpMask(double radius, double sigma, Channels channels);

		void UnsharpMask(double radius, double sigma, double amount, double threshold);

		void UnsharpMask(double radius, double sigma, double amount, double threshold, Channels channels);

		void Vignette();

		void Vignette(double radius, double sigma, int x, int y);

		void Wave();

		void Wave(PixelInterpolateMethod method, double amplitude, double length);

		void WaveletDenoise(Percentage thresholdPercentage);

		void WaveletDenoise(Percentage thresholdPercentage, double softness);

		void WhiteBalance();

		void WhiteBalance(Percentage vibrance);

		void WhiteThreshold(Percentage threshold);

		void WhiteThreshold(Percentage threshold, Channels channels);

		void Write(FileInfo file);

		void Write(FileInfo file, IWriteDefines defines);

		void Write(FileInfo file, MagickFormat format);

		void Write(Stream stream);

		void Write(Stream stream, IWriteDefines defines);

		void Write(Stream stream, MagickFormat format);

		void Write(string fileName);

		void Write(string fileName, IWriteDefines defines);

		void Write(string fileName, MagickFormat format);
	}
	public interface IMagickImageCollection : IDisposable
	{
		event EventHandler<WarningEventArgs> Warning;

		void Add(string fileName);

		void AddRange(byte[] data);

		void AddRange(string fileName);

		void AddRange(Stream stream);

		void Coalesce();

		void Complex(IComplexSettings complexSettings);

		void Deconstruct();

		void Insert(int index, string fileName);

		void Morph(int frames);

		void Optimize();

		void OptimizePlus();

		void OptimizeTransparency();

		void Ping(byte[] data);

		void Ping(byte[] data, int offset, int count);

		void Ping(FileInfo file);

		void Ping(Stream stream);

		void Ping(string fileName);

		IMagickErrorInfo? Quantize();

		IMagickErrorInfo? Quantize(IQuantizeSettings settings);

		void Read(byte[] data);

		void Read(byte[] data, int offset, int count);

		void Read(byte[] data, int offset, int count, MagickFormat format);

		void Read(byte[] data, MagickFormat format);

		void Read(FileInfo file);

		void Read(FileInfo file, MagickFormat format);

		void Read(Stream stream);

		void Read(Stream stream, MagickFormat format);

		void Read(string fileName);

		void Read(string fileName, MagickFormat format);

		void RePage();

		void Reverse();

		byte[] ToByteArray();

		byte[] ToByteArray(IWriteDefines defines);

		byte[] ToByteArray(MagickFormat format);

		string ToBase64();

		string ToBase64(MagickFormat format);

		void TrimBounds();

		void Write(FileInfo file);

		void Write(FileInfo file, IWriteDefines defines);

		void Write(FileInfo file, MagickFormat format);

		void Write(Stream stream);

		void Write(Stream stream, IWriteDefines defines);

		void Write(Stream stream, MagickFormat format);

		void Write(string fileName);

		void Write(string fileName, IWriteDefines defines);

		void Write(string fileName, MagickFormat format);
	}
	public interface IMagickImageCollection<TQuantumType> : IMagickImageCollection, IDisposable, IList<IMagickImage<TQuantumType>>, ICollection<IMagickImage<TQuantumType>>, IEnumerable<IMagickImage<TQuantumType>>, IEnumerable where TQuantumType : struct
	{
		void AddRange(byte[] data, IMagickReadSettings<TQuantumType>? readSettings);

		void AddRange(IEnumerable<IMagickImage<TQuantumType>> images);

		void AddRange(string fileName, IMagickReadSettings<TQuantumType>? readSettings);

		void AddRange(Stream stream, IMagickReadSettings<TQuantumType>? readSettings);

		IMagickImage<TQuantumType> AppendHorizontally();

		IMagickImage<TQuantumType> AppendVertically();

		IMagickImageCollection<TQuantumType> Clone();

		IMagickImage<TQuantumType> Combine();

		IMagickImage<TQuantumType> Combine(ColorSpace colorSpace);

		IMagickImage<TQuantumType> Evaluate(EvaluateOperator evaluateOperator);

		IMagickImage<TQuantumType> Flatten();

		IMagickImage<TQuantumType> Flatten(IMagickColor<TQuantumType> backgroundColor);

		void Map(IMagickImage<TQuantumType> image);

		void Map(IMagickImage<TQuantumType> image, IQuantizeSettings settings);

		IMagickImage<TQuantumType> Merge();

		IMagickImage<TQuantumType> Montage(IMontageSettings<TQuantumType> settings);

		IMagickImage<TQuantumType> Mosaic();

		void Ping(byte[] data, int offset, int count, IMagickReadSettings<TQuantumType>? readSettings);

		void Ping(byte[] data, IMagickReadSettings<TQuantumType>? readSettings);

		void Ping(FileInfo file, IMagickReadSettings<TQuantumType>? readSettings);

		void Ping(Stream stream, IMagickReadSettings<TQuantumType>? readSettings);

		void Ping(string fileName, IMagickReadSettings<TQuantumType>? readSettings);

		IMagickImage<TQuantumType> Polynomial(double[] terms);

		void Read(byte[] data, int offset, int count, IMagickReadSettings<TQuantumType>? readSettings);

		void Read(byte[] data, IMagickReadSettings<TQuantumType>? readSettings);

		void Read(FileInfo file, IMagickReadSettings<TQuantumType>? readSettings);

		void Read(Stream stream, IMagickReadSettings<TQuantumType>? readSettings);

		void Read(string fileName, IMagickReadSettings<TQuantumType>? readSettings);

		IMagickImage<TQuantumType> SmushHorizontal(int offset);

		IMagickImage<TQuantumType> SmushVertical(int offset);
	}
	public interface IMagickImageInfo
	{
		ColorSpace ColorSpace { get; }

		CompressionMethod Compression { get; }

		Density? Density { get; }

		string? FileName { get; }

		MagickFormat Format { get; }

		int Height { get; }

		Interlace Interlace { get; }

		int Quality { get; }

		int Width { get; }

		void Read(byte[] data);

		void Read(byte[] data, int offset, int count);

		void Read(FileInfo file);

		void Read(Stream stream);

		void Read(string fileName);
	}
	public interface IMagickImage<TQuantumType> : IMagickImage, IDisposable, IEquatable<IMagickImage<TQuantumType>>, IComparable<IMagickImage<TQuantumType>> where TQuantumType : struct
	{
		IMagickColor<TQuantumType>? BackgroundColor { get; set; }

		IMagickColor<TQuantumType>? BorderColor { get; set; }

		IMagickColor<TQuantumType>? MatteColor { get; set; }

		IMagickSettings<TQuantumType> Settings { get; }

		IMagickImage<TQuantumType> Clone();

		IMagickImage<TQuantumType> Clone(IMagickGeometry geometry);

		IMagickImage<TQuantumType> Clone(int width, int height);

		IMagickImage<TQuantumType> Clone(int x, int y, int width, int height);

		void ColorAlpha(IMagickColor<TQuantumType> color);

		void Colorize(IMagickColor<TQuantumType> color, Percentage alpha);

		void Colorize(IMagickColor<TQuantumType> color, Percentage alphaRed, Percentage alphaGreen, Percentage alphaBlue);

		void ColorThreshold(IMagickColor<TQuantumType> startColor, IMagickColor<TQuantumType> stopColor);

		double Compare(IMagickImage image, ICompareSettings<TQuantumType> settings, IMagickImage difference);

		double Compare(IMagickImage image, ICompareSettings<TQuantumType> settings, IMagickImage difference, Channels channels);

		IEnumerable<IConnectedComponent<TQuantumType>> ConnectedComponents(int connectivity);

		IEnumerable<IConnectedComponent<TQuantumType>> ConnectedComponents(IConnectedComponentsSettings settings);

		IEnumerable<IMagickImage<TQuantumType>> CropToTiles(int width, int height);

		IEnumerable<IMagickImage<TQuantumType>> CropToTiles(IMagickGeometry geometry);

		void Draw(IDrawables<TQuantumType> drawables);

		void Extent(int width, int height, IMagickColor<TQuantumType> backgroundColor);

		void Extent(int width, int height, Gravity gravity, IMagickColor<TQuantumType> backgroundColor);

		void Extent(IMagickGeometry geometry, IMagickColor<TQuantumType> backgroundColor);

		void Extent(IMagickGeometry geometry, Gravity gravity, IMagickColor<TQuantumType> backgroundColor);

		void FloodFill(TQuantumType alpha, int x, int y);

		void FloodFill(IMagickColor<TQuantumType> color, int x, int y);

		void FloodFill(IMagickColor<TQuantumType> color, int x, int y, IMagickColor<TQuantumType> target);

		void FloodFill(IMagickColor<TQuantumType> color, PointD coordinate);

		void FloodFill(IMagickColor<TQuantumType> color, PointD coordinate, IMagickColor<TQuantumType> target);

		void FloodFill(IMagickImage<TQuantumType> image, int x, int y);

		void FloodFill(IMagickImage<TQuantumType> image, int x, int y, IMagickColor<TQuantumType> target);

		void FloodFill(IMagickImage<TQuantumType> image, PointD coordinate);

		void FloodFill(IMagickImage<TQuantumType> image, PointD coordinate, IMagickColor<TQuantumType> target);

		IMagickColor<TQuantumType>? GetColormap(int index);

		IPixelCollection<TQuantumType> GetPixels();

		IUnsafePixelCollection<TQuantumType> GetPixelsUnsafe();

		IMagickImage<TQuantumType>? GetReadMask();

		IMagickImage<TQuantumType>? GetWriteMask();

		Dictionary<IMagickColor<TQuantumType>, int> Histogram();

		void InverseFloodFill(TQuantumType alpha, int x, int y);

		void InverseFloodFill(IMagickColor<TQuantumType> color, int x, int y);

		void InverseFloodFill(IMagickColor<TQuantumType> color, int x, int y, IMagickColor<TQuantumType> target);

		void InverseFloodFill(IMagickColor<TQuantumType> color, PointD coordinate);

		void InverseFloodFill(IMagickColor<TQuantumType> color, PointD coordinate, IMagickColor<TQuantumType> target);

		void InverseFloodFill(IMagickImage<TQuantumType> image, int x, int y);

		void InverseFloodFill(IMagickImage<TQuantumType> image, int x, int y, IMagickColor<TQuantumType> target);

		void InverseFloodFill(IMagickImage<TQuantumType> image, PointD coordinate);

		void InverseFloodFill(IMagickImage<TQuantumType> image, PointD coordinate, IMagickColor<TQuantumType> target);

		void InverseLevel(TQuantumType blackPoint, TQuantumType whitePoint);

		void InverseLevel(TQuantumType blackPoint, TQuantumType whitePoint, Channels channels);

		void InverseLevel(TQuantumType blackPoint, TQuantumType whitePoint, double midpoint);

		void InverseLevel(TQuantumType blackPoint, TQuantumType whitePoint, double midpoint, Channels channels);

		void InverseLevelColors(IMagickColor<TQuantumType> blackColor, IMagickColor<TQuantumType> whiteColor);

		void InverseLevelColors(IMagickColor<TQuantumType> blackColor, IMagickColor<TQuantumType> whiteColor, Channels channels);

		void InverseOpaque(IMagickColor<TQuantumType> target, IMagickColor<TQuantumType> fill);

		void InverseTransparent(IMagickColor<TQuantumType> color);

		void InverseTransparentChroma(IMagickColor<TQuantumType> colorLow, IMagickColor<TQuantumType> colorHigh);

		void Level(TQuantumType blackPoint, TQuantumType whitePoint);

		void Level(TQuantumType blackPoint, TQuantumType whitePoint, Channels channels);

		void Level(TQuantumType blackPoint, TQuantumType whitePoint, double gamma);

		void Level(TQuantumType blackPoint, TQuantumType whitePoint, double gamma, Channels channels);

		void LevelColors(IMagickColor<TQuantumType> blackColor, IMagickColor<TQuantumType> whiteColor);

		void LevelColors(IMagickColor<TQuantumType> blackColor, IMagickColor<TQuantumType> whiteColor, Channels channels);

		IMagickErrorInfo Map(IEnumerable<IMagickColor<TQuantumType>> colors);

		IMagickErrorInfo Map(IEnumerable<IMagickColor<TQuantumType>> colors, IQuantizeSettings settings);

		void Opaque(IMagickColor<TQuantumType> target, IMagickColor<TQuantumType> fill);

		void Ping(byte[] data, int offset, int count, IMagickReadSettings<TQuantumType>? readSettings);

		void Ping(byte[] data, IMagickReadSettings<TQuantumType>? readSettings);

		void Ping(FileInfo file, IMagickReadSettings<TQuantumType>? readSettings);

		void Ping(Stream stream, IMagickReadSettings<TQuantumType>? readSettings);

		void Ping(string fileName, IMagickReadSettings<TQuantumType>? readSettings);

		void RandomThreshold(TQuantumType low, TQuantumType high);

		void RandomThreshold(TQuantumType low, TQuantumType high, Channels channels);

		void RangeThreshold(TQuantumType lowBlack, TQuantumType lowWhite, TQuantumType highWhite, TQuantumType highBlack);

		void Read(byte[] data, int offset, int count, IMagickReadSettings<TQuantumType>? readSettings);

		void Read(byte[] data, IMagickReadSettings<TQuantumType>? readSettings);

		void Read(FileInfo file, IMagickReadSettings<TQuantumType>? readSettings);

		void Read(IMagickColor<TQuantumType> color, int width, int height);

		void Read(Stream stream, IMagickReadSettings<TQuantumType>? readSettings);

		void Read(string fileName, IMagickReadSettings<TQuantumType>? readSettings);

		void ReadPixels(byte[] data, IPixelReadSettings<TQuantumType>? settings);

		void ReadPixels(byte[] data, int offset, int count, IPixelReadSettings<TQuantumType>? settings);

		void ReadPixels(FileInfo file, IPixelReadSettings<TQuantumType>? settings);

		void ReadPixels(Stream stream, IPixelReadSettings<TQuantumType>? settings);

		void ReadPixels(string fileName, IPixelReadSettings<TQuantumType>? settings);

		IEnumerable<IMagickImage<TQuantumType>> Separate();

		IEnumerable<IMagickImage<TQuantumType>> Separate(Channels channels);

		void SetColormap(int index, IMagickColor<TQuantumType> color);

		void Shadow(IMagickColor<TQuantumType> color);

		void Shadow(int x, int y, double sigma, Percentage alpha, IMagickColor<TQuantumType> color);

		void SparseColor(SparseColorMethod method, IEnumerable<ISparseColorArg<TQuantumType>> args);

		void SparseColor(SparseColorMethod method, params ISparseColorArg<TQuantumType>[] args);

		void SparseColor(Channels channels, SparseColorMethod method, IEnumerable<ISparseColorArg<TQuantumType>> args);

		void SparseColor(Channels channels, SparseColorMethod method, params ISparseColorArg<TQuantumType>[] args);

		IMagickSearchResult<TQuantumType> SubImageSearch(IMagickImage<TQuantumType> image);

		IMagickSearchResult<TQuantumType> SubImageSearch(IMagickImage<TQuantumType> image, ErrorMetric metric);

		IMagickSearchResult<TQuantumType> SubImageSearch(IMagickImage<TQuantumType> image, ErrorMetric metric, double similarityThreshold);

		void Tint(string opacity, IMagickColor<TQuantumType> color);

		void Transparent(IMagickColor<TQuantumType> color);

		void TransparentChroma(IMagickColor<TQuantumType> colorLow, IMagickColor<TQuantumType> colorHigh);

		IMagickImage<TQuantumType>? UniqueColors();

		void WaveletDenoise(TQuantumType threshold);

		void WaveletDenoise(TQuantumType threshold, double softness);
	}
	public interface IConvolveMatrix : IDoubleMatrix
	{
	}
	public interface IDoubleMatrix
	{
		int Order { get; }

		double this[int x, int y] { get; set; }

		double GetValue(int x, int y);

		void SetColumn(int x, params double[] values);

		void SetRow(int y, params double[] values);

		void SetValue(int x, int y, double value);

		double[] ToArray();
	}
	public interface IMagickColorMatrix : IDoubleMatrix
	{
	}
	public interface IOpenCLDevice
	{
		double BenchmarkScore { get; }

		OpenCLDeviceType DeviceType { get; }

		bool IsEnabled { get; set; }

		IEnumerable<IOpenCLKernelProfileRecord> KernelProfileRecords { get; }

		string Name { get; }

		bool ProfileKernels { get; set; }

		string Version { get; }
	}
	public interface IOpenCLKernelProfileRecord
	{
		long AverageDuration { get; }

		long Count { get; }

		long MaximumDuration { get; }

		long MinimumDuration { get; }

		string Name { get; }

		long TotalDuration { get; }
	}
	public interface IPixelCollection<TQuantumType> : IEnumerable<IPixel<TQuantumType>>, IEnumerable, IDisposable where TQuantumType : struct
	{
		int Channels { get; }

		IPixel<TQuantumType>? this[int x, int y] { get; }

		TQuantumType[]? GetArea(int x, int y, int width, int height);

		TQuantumType[]? GetArea(IMagickGeometry geometry);

		int GetIndex(PixelChannel channel);

		IPixel<TQuantumType> GetPixel(int x, int y);

		TQuantumType[]? GetValue(int x, int y);

		TQuantumType[]? GetValues();

		void SetArea(int x, int y, int width, int height, TQuantumType[] values);

		void SetArea(IMagickGeometry geometry, TQuantumType[] values);

		void SetByteArea(int x, int y, int width, int height, byte[] values);

		void SetByteArea(IMagickGeometry geometry, byte[] values);

		void SetBytePixels(byte[] values);

		void SetDoubleArea(int x, int y, int width, int height, double[] values);

		void SetDoubleArea(IMagickGeometry geometry, double[] values);

		void SetDoublePixels(double[] values);

		void SetIntArea(int x, int y, int width, int height, int[] values);

		void SetIntArea(IMagickGeometry geometry, int[] values);

		void SetIntPixels(int[] values);

		void SetPixel(IPixel<TQuantumType> pixel);

		void SetPixel(IEnumerable<IPixel<TQuantumType>> pixels);

		void SetPixel(int x, int y, TQuantumType[] value);

		void SetPixels(TQuantumType[] values);

		TQuantumType[]? ToArray();

		byte[]? ToByteArray(int x, int y, int width, int height, string mapping);

		byte[]? ToByteArray(int x, int y, int width, int height, PixelMapping mapping);

		byte[]? ToByteArray(IMagickGeometry geometry, string mapping);

		byte[]? ToByteArray(IMagickGeometry geometry, PixelMapping mapping);

		byte[]? ToByteArray(string mapping);

		byte[]? ToByteArray(PixelMapping mapping);

		ushort[]? ToShortArray(int x, int y, int width, int height, string mapping);

		ushort[]? ToShortArray(int x, int y, int width, int height, PixelMapping mapping);

		ushort[]? ToShortArray(IMagickGeometry geometry, string mapping);

		ushort[]? ToShortArray(IMagickGeometry geometry, PixelMapping mapping);

		ushort[]? ToShortArray(string mapping);

		ushort[]? ToShortArray(PixelMapping mapping);
	}
	public interface IPixel<TQuantumType> : IEquatable<IPixel<TQuantumType>> where TQuantumType : struct
	{
		int Channels { get; }

		int X { get; }

		int Y { get; }

		TQuantumType this[int channel] { get; set; }

		TQuantumType GetChannel(int channel);

		void SetChannel(int channel, TQuantumType value);

		void SetValues(TQuantumType[] values);

		TQuantumType[] ToArray();

		IMagickColor<TQuantumType>? ToColor();
	}
	public interface IUnsafePixelCollection<TQuantumType> : IPixelCollection<TQuantumType>, IEnumerable<IPixel<TQuantumType>>, IEnumerable, IDisposable where TQuantumType : struct
	{
		IntPtr GetAreaPointer(int x, int y, int width, int height);

		IntPtr GetAreaPointer(IMagickGeometry geometry);
	}
	public sealed class ClipPath : IClipPath
	{
		public string Name { get; }

		public IXPathNavigable Path { get; }

		internal ClipPath(string name, IXPathNavigable path)
		{
			Name = name;
			Path = path;
		}
	}
	internal sealed class ClipPathReader
	{
		private readonly int _height;

		private readonly int _width;

		private readonly int _offset;

		private readonly PointD[] _first = new PointD[3];

		private readonly PointD[] _last = new PointD[3];

		private readonly StringBuilder _path = new StringBuilder();

		private int _index;

		private bool _inSubpath;

		private int _knotCount;

		public ClipPathReader(int width, int height, int offset)
		{
			_width = width;
			_height = height;
			_offset = offset;
			_index = _offset;
		}

		public static string Read(int width, int height, byte[] data, int offset, int length)
		{
			return new ClipPathReader(width, height, offset).Read(data, length);
		}

		private string Read(byte[] data, int length)
		{
			while (_index < _offset + length)
			{
				switch (ByteConverter.ToShort(data, ref _index))
				{
				case 0:
				case 3:
					SetKnotCount(data);
					break;
				case 1:
				case 2:
				case 4:
				case 5:
					AddPath(data);
					break;
				default:
					_index += 24;
					break;
				}
			}
			return _path.ToString();
		}

		private void AddPath(byte[] data)
		{
			if (_knotCount == 0)
			{
				_index += 24;
				return;
			}
			PointD[] array = CreatePoint(data);
			if (!_inSubpath)
			{
				_path.AppendFormat(CultureInfo.InvariantCulture, "M {0:0.###} {1:0.###}\n", new object[2]
				{
					array[1].X,
					array[1].Y
				});
				for (int i = 0; i < 3; i++)
				{
					_first[i] = array[i];
					_last[i] = array[i];
				}
			}
			else
			{
				if (_last[1].X == _last[2].X && _last[1].Y == _last[2].Y && array[0].X == array[1].X && array[0].Y == array[1].Y)
				{
					_path.AppendFormat(CultureInfo.InvariantCulture, "L {0:0.###} {1:0.###}\n", new object[2]
					{
						array[1].X,
						array[1].Y
					});
				}
				else
				{
					_path.AppendFormat(CultureInfo.InvariantCulture, "C {0:0.###} {1:0.###} {2:0.###} {3:0.###} {4:0.###} {5:0.###}\n", _last[2].X, _last[2].Y, array[0].X, array[0].Y, array[1].X, array[1].Y);
				}
				for (int j = 0; j < 3; j++)
				{
					_last[j] = array[j];
				}
			}
			_inSubpath = true;
			_knotCount--;
			if (_knotCount == 0)
			{
				ClosePath();
				_inSubpath = false;
			}
		}

		private void ClosePath()
		{
			if (_last[1].X == _last[2].X && _last[1].Y == _last[2].Y && _first[0].X == _first[1].X && _first[0].Y == _first[1].Y)
			{
				_path.AppendFormat(CultureInfo.InvariantCulture, "L {0:0.###} {1:0.###} Z\n", new object[2]
				{
					_first[1].X,
					_first[1].Y
				});
				return;
			}
			_path.AppendFormat(CultureInfo.InvariantCulture, "C {0:0.###} {1:0.###} {2:0.###} {3:0.###} {4:0.###} {5:0.###} Z\n", _last[2].X, _last[2].Y, _first[0].X, _first[0].Y, _first[1].X, _first[1].Y);
		}

		private PointD[] CreatePoint(byte[] data)
		{
			PointD[] array = new PointD[3];
			for (int i = 0; i < 3; i++)
			{
				uint num = (uint)ByteConverter.ToUInt(data, ref _index);
				int num2 = (int)num;
				if (num > int.MaxValue)
				{
					num2 = (int)num - -1 - 1;
				}
				uint num3 = (uint)ByteConverter.ToUInt(data, ref _index);
				int num4 = (int)num3;
				if (num3 > int.MaxValue)
				{
					num4 = (int)num3 - -1 - 1;
				}
				array[i] = new PointD((double)num4 * (double)_width / 4096.0 / 4096.0, (double)num2 * (double)_height / 4096.0 / 4096.0);
			}
			return array;
		}

		private void Reset(int offset)
		{
			_index = offset;
		}

		private void SetKnotCount(byte[] data)
		{
			if (_knotCount != 0)
			{
				_index += 24;
				return;
			}
			_knotCount = ByteConverter.ToShort(data, ref _index);
			_index += 22;
		}
	}
	public sealed class EightBimProfile : ImageProfile, IEightBimProfile, IImageProfile, IEquatable<IImageProfile>
	{
		private readonly int _height;

		private readonly int _width;

		private Collection<IClipPath>? _clipPaths;

		private Collection<IEightBimValue>? _values;

		public IEnumerable<IClipPath> ClipPaths
		{
			get
			{
				Initialize();
				return _clipPaths;
			}
		}

		public IEnumerable<IEightBimValue> Values
		{
			get
			{
				Initialize();
				return _values;
			}
		}

		public EightBimProfile(byte[] data)
			: base("8bim", data)
		{
		}

		public EightBimProfile(string fileName)
			: base("8bim", fileName)
		{
		}

		public EightBimProfile(Stream stream)
			: base("8bim", stream)
		{
		}

		public EightBimProfile(IMagickImage image, byte[] data)
			: base("8bim", data)
		{
			Throw.IfNull("image", image);
			_width = image.Width;
			_height = image.Height;
		}

		private ClipPath? CreateClipPath(string name, int offset, int length)
		{
			string clipPath = GetClipPath(offset, length);
			if (string.IsNullOrEmpty(clipPath))
			{
				return null;
			}
			XmlDocument xmlDocument = XmlHelper.CreateDocument();
			xmlDocument.CreateXmlDeclaration("1.0", "iso-8859-1", null);
			XmlElement xmlElement = XmlHelper.CreateElement(xmlDocument, "svg");
			XmlHelper.SetAttribute(xmlElement, "width", _width);
			XmlHelper.SetAttribute(xmlElement, "height", _height);
			XmlElement element = XmlHelper.CreateElement(XmlHelper.CreateElement(xmlElement, "g"), "path");
			XmlHelper.SetAttribute(element, "fill", "#00000000");
			XmlHelper.SetAttribute(element, "stroke", "#00000000");
			XmlHelper.SetAttribute(element, "stroke-width", "0");
			XmlHelper.SetAttribute(element, "stroke-antialiasing", "false");
			XmlHelper.SetAttribute(element, "d", clipPath);
			return new ClipPath(name, xmlDocument.CreateNavigator());
		}

		private string? GetClipPath(int offset, int length)
		{
			if (_width == 0 || _height == 0)
			{
				return null;
			}
			byte[] data = GetData();
			if (data == null)
			{
				return null;
			}
			return ClipPathReader.Read(_width, _height, data, offset, length);
		}

		[MemberNotNull(new string[] { "_clipPaths", "_values" })]
		private void Initialize()
		{
			if (_clipPaths != null && _values != null)
			{
				return;
			}
			_clipPaths = new Collection<IClipPath>();
			_values = new Collection<IEightBimValue>();
			byte[] data = GetData();
			if (data == null)
			{
				return;
			}
			int offset = 0;
			while (offset < data.Length)
			{
				if (data[offset++] != 56 || data[offset++] != 66 || data[offset++] != 73 || data[offset++] != 77)
				{
					continue;
				}
				if (offset + 7 > data.Length)
				{
					break;
				}
				short num = ByteConverter.ToShort(data, ref offset);
				bool flag = num > 1999 && num < 2998;
				string name = null;
				int num2 = data[offset++];
				if (num2 != 0)
				{
					if (flag && offset + num2 < data.Length)
					{
						name = Encoding.ASCII.GetString(data, offset, num2);
					}
					offset += num2;
				}
				if ((num2 & 1) == 0)
				{
					offset++;
				}
				num2 = ByteConverter.ToUInt(data, ref offset);
				if (offset + num2 > data.Length || num2 < 0)
				{
					break;
				}
				if (num2 != 0)
				{
					if (flag)
					{
						ClipPath clipPath = CreateClipPath(name, offset, num2);
						if (clipPath != null)
						{
							_clipPaths.Add(clipPath);
						}
					}
					byte[] array = new byte[num2];
					Array.Copy(data, offset, array, 0, num2);
					_values.Add(new EightBimValue(num, array));
				}
				offset += num2;
			}
		}
	}
	public sealed class EightBimValue : IEightBimValue, IEquatable<IEightBimValue>
	{
		private readonly byte[] _data;

		public short ID { get; }

		internal EightBimValue(short id, byte[] data)
		{
			ID = id;
			_data = data;
		}

		public override bool Equals(object? obj)
		{
			if (this == obj)
			{
				return true;
			}
			return Equals(obj as IEightBimValue);
		}

		public bool Equals(IEightBimValue? other)
		{
			if (other == null)
			{
				return false;
			}
			if (this == other)
			{
				return true;
			}
			if (ID != other.ID)
			{
				return false;
			}
			byte[] array = other.ToByteArray();
			if (_data.Length != array.Length)
			{
				return false;
			}
			for (int i = 0; i < _data.Length; i++)
			{
				if (_data[i] != array[i])
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			return _data.GetHashCode() ^ ID.GetHashCode();
		}

		public byte[] ToByteArray()
		{
			byte[] array = new byte[_data.Length];
			Array.Copy(_data, 0, array, 0, _data.Length);
			return array;
		}

		public override string ToString()
		{
			return ToString(Encoding.UTF8);
		}

		public string ToString(Encoding encoding)
		{
			Throw.IfNull("encoding", encoding);
			return encoding.GetString(_data);
		}
	}
	public interface IClipPath
	{
		string Name { get; }

		IXPathNavigable Path { get; }
	}
	public interface IEightBimProfile : IImageProfile, IEquatable<IImageProfile>
	{
		IEnumerable<IClipPath> ClipPaths { get; }

		IEnumerable<IEightBimValue> Values { get; }
	}
	public interface IEightBimValue : IEquatable<IEightBimValue>
	{
		short ID { get; }

		byte[] ToByteArray();

		string ToString(Encoding encoding);
	}
	public sealed class ColorProfile : ImageProfile, IColorProfile, IImageProfile, IEquatable<IImageProfile>
	{
		private static readonly object _SyncRoot = new object();

		private static readonly Dictionary<string, ColorProfile> _profiles = new Dictionary<string, ColorProfile>();

		private ColorProfileData? _data;

		public static ColorProfile AdobeRGB1998 => Load("ImageMagick.Resources.ColorProfiles.RGB", "AdobeRGB1998.icc");

		public static ColorProfile AppleRGB => Load("ImageMagick.Resources.ColorProfiles.RGB", "AppleRGB.icc");

		public static ColorProfile CoatedFOGRA39 => Load("ImageMagick.Resources.ColorProfiles.CMYK", "CoatedFOGRA39.icc");

		public static ColorProfile ColorMatchRGB => Load("ImageMagick.Resources.ColorProfiles.RGB", "ColorMatchRGB.icc");

		public static ColorProfile SRGB => Load("ImageMagick.Resources.ColorProfiles.RGB", "SRGB.icm");

		public static ColorProfile USWebCoatedSWOP => Load("ImageMagick.Resources.ColorProfiles.CMYK", "USWebCoatedSWOP.icc");

		public ColorSpace ColorSpace
		{
			get
			{
				Initialize();
				return _data.ColorSpace;
			}
		}

		public string? Copyright
		{
			get
			{
				Initialize();
				return _data.Copyright;
			}
		}

		public string? Description
		{
			get
			{
				Initialize();
				return _data.Description;
			}
		}

		public string? Manufacturer
		{
			get
			{
				Initialize();
				return _data.Manufacturer;
			}
		}

		public string? Model
		{
			get
			{
				Initialize();
				return _data.Model;
			}
		}

		public ColorProfile(byte[] data)
			: base("icc", data)
		{
		}

		public ColorProfile(Stream stream)
			: base("icc", stream)
		{
		}

		public ColorProfile(string fileName)
			: base("icc", fileName)
		{
		}

		public ColorProfile(string name, byte[] data)
			: base(name, data)
		{
		}

		private static ColorProfile Load(string resourcePath, string resourceName)
		{
			lock (_SyncRoot)
			{
				if (!_profiles.ContainsKey(resourceName))
				{
					using Stream stream = TypeHelper.GetManifestResourceStream(typeof(ColorProfile), resourcePath, resourceName);
					_profiles[resourceName] = new ColorProfile(stream);
				}
			}
			return _profiles[resourceName];
		}

		[MemberNotNull("_data")]
		private void Initialize()
		{
			_data = ColorProfileReader.Read(GetData());
		}
	}
	internal sealed class ColorProfileData
	{
		public ColorSpace ColorSpace { get; set; }

		public string? Copyright { get; set; }

		public string? Description { get; set; }

		public string? Manufacturer { get; set; }

		public string? Model { get; set; }
	}
	internal sealed class ColorProfileReader
	{
		private readonly ColorProfileData _data = new ColorProfileData();

		private readonly EndianReader _reader;

		private ColorProfileReader(byte[] data)
		{
			_reader = new EndianReader(data);
		}

		public static ColorProfileData Read(byte[]? data)
		{
			if (data == null)
			{
				return new ColorProfileData();
			}
			ColorProfileReader colorProfileReader = new ColorProfileReader(data);
			colorProfileReader.ReadColorSpace();
			colorProfileReader.ReadTagTable();
			return colorProfileReader._data;
		}

		private static ColorSpace DetermineColorSpace(string colorSpace)
		{
			return colorSpace switch
			{
				"CMY" => ColorSpace.CMY, 
				"CMYK" => ColorSpace.CMYK, 
				"GRAY" => ColorSpace.Gray, 
				"HSL" => ColorSpace.HSL, 
				"HSV" => ColorSpace.HSV, 
				"Lab" => ColorSpace.Lab, 
				"Luv" => ColorSpace.YUV, 
				"RGB" => ColorSpace.sRGB, 
				"XYZ" => ColorSpace.XYZ, 
				"YCbr" => ColorSpace.YCbCr, 
				_ => throw new NotSupportedException(colorSpace), 
			};
		}

		private void ReadColorSpace()
		{
			_reader.Seek(16u);
			string text = _reader.ReadString(4u);
			if (text != null)
			{
				_data.ColorSpace = DetermineColorSpace(text.TrimEnd(new char[0]));
			}
		}

		private void ReadTagTable()
		{
			if (!_reader.Seek(128u))
			{
				return;
			}
			uint? num = _reader.ReadLong();
			for (int i = 0; i < num; i++)
			{
				switch (_reader.ReadLong())
				{
				case 1668313716u:
					_data.Copyright = ReadTag();
					break;
				case 1684370275u:
					_data.Description = ReadTag();
					break;
				case 1684893284u:
					_data.Manufacturer = ReadTag();
					break;
				case 1684890724u:
					_data.Model = ReadTag();
					break;
				default:
					_reader.Skip(8u);
					break;
				}
			}
		}

		private string? ReadTag()
		{
			uint? num = _reader.ReadLong();
			uint? num2 = _reader.ReadLong();
			if (!num.HasValue || !num2.HasValue)
			{
				return null;
			}
			uint index = _reader.Index;
			if (!_reader.Seek(num.Value))
			{
				return null;
			}
			string? result = ReadTagValue(num2.Value);
			_reader.Seek(index);
			return result;
		}

		private string? ReadTagValue(uint length)
		{
			string text = _reader.ReadString(4u);
			if (!(text == "desc"))
			{
				if (text == "text")
				{
					return ReadTextTypeValue(length);
				}
				return null;
			}
			return ReadTextDescriptionTypeValue();
		}

		private string? ReadTextDescriptionTypeValue()
		{
			if (!_reader.Skip(4u))
			{
				return null;
			}
			uint? num = _reader.ReadLong();
			if (!num.HasValue)
			{
				return null;
			}
			return _reader.ReadString(num.Value);
		}

		private string? ReadTextTypeValue(uint length)
		{
			if (!_reader.Skip(4u))
			{
				return null;
			}
			return _reader.ReadString(length);
		}
	}
	public interface IColorProfile : IImageProfile, IEquatable<IImageProfile>
	{
		ColorSpace ColorSpace { get; }

		string? Copyright { get; }

		string? Description { get; }

		string? Manufacturer { get; }

		string? Model { get; }
	}
	internal sealed class EndianReader
	{
		private readonly byte[] _data;

		public uint Index { get; private set; }

		public bool IsLittleEndian { get; set; }

		public EndianReader(byte[] data)
		{
			Throw.IfNullOrEmpty("data", data);
			_data = data;
			Index = 0u;
		}

		public bool CanRead(uint length)
		{
			if (length > _data.Length)
			{
				return false;
			}
			return Index + length <= _data.Length;
		}

		public bool Seek(uint index)
		{
			if (index >= _data.Length)
			{
				return false;
			}
			Index = index;
			return true;
		}

		public bool Skip(uint value)
		{
			if (Index + value >= _data.Length)
			{
				return false;
			}
			Index += value;
			return true;
		}

		public byte? ReadByte()
		{
			if (Index >= _data.Length)
			{
				return null;
			}
			byte value = _data[Index];
			Index++;
			return value;
		}

		public double? ReadDouble()
		{
			if (!CanRead(8u))
			{
				return null;
			}
			return IsLittleEndian ? ReadDoubleLSB() : ReadDoubleMSB();
		}

		public uint? ReadLong()
		{
			if (!CanRead(4u))
			{
				return null;
			}
			return IsLittleEndian ? ReadLongLSB() : ReadLongMSB();
		}

		public ushort? ReadShort()
		{
			if (!CanRead(2u))
			{
				return null;
			}
			return IsLittleEndian ? ReadShortLSB() : ReadShortMSB();
		}

		public unsafe float? ReadFloat()
		{
			uint? num = ReadLong();
			if (!num.HasValue)
			{
				return null;
			}
			uint value = num.Value;
			return *(float*)(&value);
		}

		public string? ReadString(uint length)
		{
			if (length == 0)
			{
				return string.Empty;
			}
			if (!CanRead(length))
			{
				return null;
			}
			string text = Encoding.UTF8.GetString(_data, (int)Index, (int)length);
			int num = text.IndexOf('\0');
			if (num != -1)
			{
				text = text.Substring(0, num);
			}
			Index += length;
			return text;
		}

		private unsafe double ReadDoubleLSB()
		{
			ulong num = _data[Index];
			num |= (ulong)_data[Index + 1] << 8;
			num |= (ulong)_data[Index + 2] << 16;
			num |= (ulong)_data[Index + 3] << 24;
			num |= (ulong)_data[Index + 4] << 32;
			num |= (ulong)_data[Index + 5] << 40;
			num |= (ulong)_data[Index + 6] << 48;
			num |= (ulong)_data[Index + 7] << 56;
			Index += 8u;
			return *(double*)(&num);
		}

		private unsafe double ReadDoubleMSB()
		{
			ulong num = (ulong)_data[Index] << 56;
			num |= (ulong)_data[Index + 1] << 48;
			num |= (ulong)_data[Index + 2] << 40;
			num |= (ulong)_data[Index + 3] << 32;
			num |= (ulong)_data[Index + 4] << 24;
			num |= (ulong)_data[Index + 5] << 16;
			num |= (ulong)_data[Index + 6] << 8;
			num |= _data[Index + 7];
			Index += 8u;
			return *(double*)(&num);
		}

		private uint ReadLongLSB()
		{
			int result = _data[Index] | (_data[Index + 1] << 8) | (_data[Index + 2] << 16) | (_data[Index + 3] << 24);
			Index += 4u;
			return (uint)result;
		}

		private uint ReadLongMSB()
		{
			int result = (_data[Index] << 24) | (_data[Index + 1] << 16) | (_data[Index + 2] << 8) | _data[Index + 3];
			Index += 4u;
			return (uint)result;
		}

		private ushort ReadShortLSB()
		{
			ushort result = (ushort)(_data[Index] | (ushort)(_data[Index + 1] << 8));
			Index += 2u;
			return result;
		}

		private ushort ReadShortMSB()
		{
			ushort result = (ushort)((ushort)(_data[Index] << 8) | _data[Index + 1]);
			Index += 2u;
			return result;
		}
	}
	internal sealed class ExifData
	{
		public uint ThumbnailLength { get; set; }

		public uint ThumbnailOffset { get; set; }

		public List<ExifTag> InvalidTags { get; } = new List<ExifTag>();


		public List<IExifValue> Values { get; } = new List<IExifValue>();

	}
	public enum ExifDataType
	{
		Unknown,
		Byte,
		String,
		Short,
		Long,
		Rational,
		SignedByte,
		Undefined,
		SignedShort,
		SignedLong,
		SignedRational,
		Float,
		Double
	}
	internal static class ExifDataTypes
	{
		public static uint GetSize(ExifDataType dataType)
		{
			switch (dataType)
			{
			case ExifDataType.Byte:
			case ExifDataType.String:
			case ExifDataType.SignedByte:
			case ExifDataType.Undefined:
				return 1u;
			case ExifDataType.Short:
			case ExifDataType.SignedShort:
				return 2u;
			case ExifDataType.Long:
			case ExifDataType.SignedLong:
			case ExifDataType.Float:
				return 4u;
			case ExifDataType.Rational:
			case ExifDataType.SignedRational:
			case ExifDataType.Double:
				return 8u;
			default:
				throw new NotSupportedException(dataType.ToString());
			}
		}
	}
	[Flags]
	public enum ExifParts
	{
		None = 0,
		IfdTags = 1,
		ExifTags = 4,
		GpsTags = 8,
		All = 0xD
	}
	public sealed class ExifProfile : ImageProfile, IExifProfile, IImageProfile, IEquatable<IImageProfile>
	{
		private ExifData? _data;

		public ExifParts Parts { get; set; } = ExifParts.All;


		public IEnumerable<ExifTag> InvalidTags
		{
			get
			{
				InitializeValues();
				return _data.InvalidTags;
			}
		}

		public int ThumbnailLength
		{
			get
			{
				InitializeValues();
				return (int)_data.ThumbnailLength;
			}
		}

		public int ThumbnailOffset
		{
			get
			{
				InitializeValues();
				return (int)_data.ThumbnailOffset;
			}
		}

		public IEnumerable<IExifValue> Values
		{
			get
			{
				InitializeValues();
				return _data.Values;
			}
		}

		public ExifProfile()
			: base("exif")
		{
		}

		public ExifProfile(byte[] data)
			: base("exif", data)
		{
		}

		public ExifProfile(string fileName)
			: base("exif", fileName)
		{
		}

		public ExifProfile(Stream stream)
			: base("exif", stream)
		{
		}

		public IExifValue<TValueType>? GetValue<TValueType>(ExifTag<TValueType> tag)
		{
			foreach (IExifValue value in Values)
			{
				if (value.Tag == tag)
				{
					return (IExifValue<TValueType>)value;
				}
			}
			return null;
		}

		public void RemoveThumbnail()
		{
			InitializeValues();
			_data.ThumbnailLength = 0u;
			_data.ThumbnailOffset = 0u;
		}

		public bool RemoveValue(ExifTag tag)
		{
			InitializeValues();
			for (int i = 0; i < _data.Values.Count; i++)
			{
				if (_data.Values[i].Tag == tag)
				{
					_data.Values.RemoveAt(i);
					return true;
				}
			}
			return false;
		}

		public void Rewrite()
		{
			InitializeValues();
			UpdateData();
		}

		public void SetValue<TValueType>(ExifTag<TValueType> tag, TValueType value)
		{
			Throw.IfNull("value", value);
			InitializeValues();
			foreach (IExifValue value2 in _data.Values)
			{
				if (value2.Tag == tag)
				{
					value2.SetValue(value);
					return;
				}
			}
			ExifValue exifValue = ExifValues.Create(tag);
			if (exifValue == null)
			{
				throw new NotSupportedException();
			}
			exifValue.SetValue(value);
			_data.Values.Add(exifValue);
		}

		protected override void UpdateData()
		{
			if (_data != null)
			{
				if (_data.Values.Count == 0)
				{
					SetData(null);
					return;
				}
				ExifWriter exifWrit