Vortice.Win32/src/Vortice.Win32.Graphics.Imaging/Generated/Graphics.Imaging.Apis.cs

// ------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------

using Win32.Graphics.Direct2D.Common;

namespace Win32.Graphics.Imaging;

public static partial class Apis
{
	public const uint WINCODEC_SDK_VERSION1 = 566;

	public const uint WINCODEC_SDK_VERSION2 = 567;

	public static ref readonly Guid CLSID_WICImagingFactory
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x62, 0xF2, 0xCA, 0xCA,
				0x70, 0x93,
				0x15, 0x46,
				0xA1,
				0x3B,
				0x9F,
				0x55,
				0x39,
				0xDA,
				0x4C,
				0x0A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICImagingFactory1
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x62, 0xF2, 0xCA, 0xCA,
				0x70, 0x93,
				0x15, 0x46,
				0xA1,
				0x3B,
				0x9F,
				0x55,
				0x39,
				0xDA,
				0x4C,
				0x0A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICImagingFactory2
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE8, 0x06, 0x7D, 0x31,
				0x24, 0x5F,
				0x3D, 0x43,
				0xBD,
				0xF7,
				0x79,
				0xCE,
				0x68,
				0xD8,
				0xAB,
				0xC2
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public const uint WINCODEC_SDK_VERSION = 567;

	public static ref readonly Guid GUID_VendorMicrosoft
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xCA, 0x49, 0xE7, 0xF0,
				0xEF, 0xED,
				0x89, 0x45,
				0xA7,
				0x3A,
				0xEE,
				0x0E,
				0x62,
				0x6A,
				0x2A,
				0x2B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_VendorMicrosoftBuiltIn
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xFD, 0x30, 0x7A, 0x25,
				0xB6, 0x06,
				0x2B, 0x46,
				0xAE,
				0xA4,
				0x63,
				0xF7,
				0x0B,
				0x86,
				0xE5,
				0x33
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x7B, 0xA1, 0x9E, 0x38,
				0x78, 0x50,
				0xDE, 0x4C,
				0xB6,
				0xEF,
				0x25,
				0xC1,
				0x51,
				0x75,
				0xC7,
				0x51
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngDecoder1
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x7B, 0xA1, 0x9E, 0x38,
				0x78, 0x50,
				0xDE, 0x4C,
				0xB6,
				0xEF,
				0x25,
				0xC1,
				0x51,
				0x75,
				0xC7,
				0x51
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngDecoder2
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x5B, 0x94, 0x18, 0xE0,
				0x86, 0xAA,
				0x08, 0x40,
				0x9B,
				0xD4,
				0x67,
				0x77,
				0xA1,
				0xE4,
				0x0C,
				0x11
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICBmpDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x62, 0x20, 0x46, 0x6B,
				0xBF, 0x7C,
				0x0D, 0x40,
				0x9F,
				0xDB,
				0x81,
				0x3D,
				0xD1,
				0x0F,
				0x27,
				0x78
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICIcoDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xDF, 0xFC, 0x1B, 0xC6,
				0x0F, 0x2E,
				0xAD, 0x4A,
				0xA8,
				0xD7,
				0xE0,
				0x6B,
				0xAF,
				0xEB,
				0xCD,
				0xFE
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICJpegDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x80, 0xA4, 0x56, 0x94,
				0x8B, 0xE8,
				0xEA, 0x43,
				0x9E,
				0x73,
				0x0B,
				0x2D,
				0x9B,
				0x71,
				0xB1,
				0xCA
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICGifDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x3C, 0xDA, 0x1D, 0x38,
				0xE9, 0x9C,
				0x34, 0x48,
				0xA2,
				0x3E,
				0x1F,
				0x98,
				0xF8,
				0xFC,
				0x52,
				0xBE
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICTiffDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xD9, 0x85, 0x4E, 0xB5,
				0x23, 0xFE,
				0x9F, 0x49,
				0x8B,
				0x88,
				0x6A,
				0xCE,
				0xA7,
				0x13,
				0x75,
				0x2B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICWmpDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x36, 0xEC, 0x6C, 0xA2,
				0x4C, 0x23,
				0x50, 0x49,
				0xAE,
				0x16,
				0xE3,
				0x4A,
				0xAC,
				0xE7,
				0x1D,
				0x0D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICDdsDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x9F, 0x69, 0x53, 0x90,
				0x41, 0xA3,
				0x9D, 0x42,
				0x9E,
				0x90,
				0xEE,
				0x43,
				0x7C,
				0xF8,
				0x0C,
				0x73
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICBmpEncoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xB4, 0x8B, 0xBE, 0x69,
				0x6D, 0xD6,
				0xC8, 0x47,
				0x86,
				0x5A,
				0xED,
				0x15,
				0x89,
				0x43,
				0x37,
				0x82
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngEncoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x69, 0x99, 0x94, 0x27,
				0x6A, 0x87,
				0xD7, 0x41,
				0x94,
				0x47,
				0x56,
				0x8F,
				0x6A,
				0x35,
				0xA4,
				0xDC
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICJpegEncoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC1, 0xF5, 0x34, 0x1A,
				0x5A, 0x4A,
				0xDC, 0x46,
				0xB6,
				0x44,
				0x1F,
				0x45,
				0x67,
				0xE7,
				0xA6,
				0x76
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICGifEncoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x98, 0x55, 0x4F, 0x11,
				0x22, 0x0B,
				0xA0, 0x40,
				0x86,
				0xA1,
				0xC8,
				0x3E,
				0xA4,
				0x95,
				0xAD,
				0xBD
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICTiffEncoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x10, 0xBE, 0x31, 0x01,
				0x01, 0x20,
				0x5F, 0x4C,
				0xA9,
				0xB0,
				0xCC,
				0x88,
				0xFA,
				0xB6,
				0x4C,
				0xE8
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICWmpEncoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xCB, 0xE3, 0x4C, 0xAC,
				0xC1, 0xE1,
				0xCD, 0x44,
				0x82,
				0x15,
				0x5A,
				0x16,
				0x65,
				0x50,
				0x9E,
				0xC2
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICDdsEncoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x94, 0xDE, 0x1D, 0xA6,
				0xCE, 0x66,
				0xC1, 0x4A,
				0x88,
				0x1B,
				0x71,
				0x68,
				0x05,
				0x88,
				0x89,
				0x5E
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICAdngDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x11, 0x94, 0x1D, 0x98,
				0x9E, 0x90,
				0xA7, 0x42,
				0x8F,
				0x5D,
				0xA7,
				0x47,
				0xFF,
				0x05,
				0x2E,
				0xDB
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICJpegQualcommPhoneEncoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x62, 0x5C, 0xED, 0x68,
				0x34, 0xF5,
				0x79, 0x49,
				0xB2,
				0xB3,
				0x68,
				0x6A,
				0x12,
				0xB2,
				0xB3,
				0x4C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICHeifDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0A, 0xA8, 0xA4, 0xE9,
				0xFE, 0x44,
				0xE4, 0x4D,
				0x89,
				0x71,
				0x71,
				0x50,
				0xB1,
				0x0A,
				0x51,
				0x99
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICHeifEncoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC1, 0xCE, 0xBE, 0x0D,
				0xB3, 0x9E,
				0x60, 0x48,
				0x9C,
				0x6F,
				0xDD,
				0xBE,
				0x86,
				0x63,
				0x45,
				0x75
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICWebpDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x86, 0xE8, 0x93, 0x76,
				0xC9, 0x51,
				0x70, 0x40,
				0x84,
				0x19,
				0x9F,
				0x70,
				0x73,
				0x8E,
				0xC8,
				0xFA
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICRAWDecoder
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x02, 0x57, 0x94, 0x41,
				0x02, 0x83,
				0xA6, 0x44,
				0x94,
				0x45,
				0xAC,
				0x98,
				0xE8,
				0xAF,
				0xA0,
				0x86
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatBmp
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x7E, 0xD8, 0xF1, 0x0A,
				0xFE, 0xFC,
				0x88, 0x41,
				0xBD,
				0xEB,
				0xA7,
				0x90,
				0x64,
				0x71,
				0xCB,
				0xE3
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatPng
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xF4, 0xFA, 0x7C, 0x1B,
				0x3F, 0x71,
				0x3C, 0x47,
				0xBB,
				0xCD,
				0x61,
				0x37,
				0x42,
				0x5F,
				0xAE,
				0xAF
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatIco
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC4, 0x60, 0xA8, 0xA3,
				0x8F, 0x33,
				0x17, 0x4C,
				0x91,
				0x9A,
				0xFB,
				0xA4,
				0xB5,
				0x62,
				0x8F,
				0x21
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatJpeg
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xAA, 0xA5, 0xE4, 0x19,
				0x62, 0x56,
				0xC5, 0x4F,
				0xA0,
				0xC0,
				0x17,
				0x58,
				0x02,
				0x8E,
				0x10,
				0x57
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatTiff
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x30, 0xCC, 0x3B, 0x16,
				0xE9, 0xE2,
				0x0B, 0x4F,
				0x96,
				0x1D,
				0xA3,
				0xE9,
				0xFD,
				0xB7,
				0x88,
				0xA3
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatGif
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x01, 0x56, 0x8A, 0x1F,
				0x4D, 0x7D,
				0xBD, 0x4C,
				0x9C,
				0x82,
				0x1B,
				0xC8,
				0xD4,
				0xEE,
				0xB9,
				0xA5
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatWmp
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xAA, 0x7C, 0xA3, 0x57,
				0x7A, 0x36,
				0x40, 0x45,
				0x91,
				0x6B,
				0xF1,
				0x83,
				0xC5,
				0x09,
				0x3A,
				0x4B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatDds
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x95, 0xCB, 0x67, 0x99,
				0x85, 0x2E,
				0xC8, 0x4A,
				0x8C,
				0xA2,
				0x83,
				0xD7,
				0xCC,
				0xD4,
				0x25,
				0xC9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatAdng
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0D, 0x6D, 0xFF, 0xF3,
				0xC0, 0x38,
				0xC4, 0x41,
				0xB1,
				0xFE,
				0x1F,
				0x38,
				0x24,
				0xF1,
				0x7B,
				0x84
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatHeif
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x21, 0x25, 0xE6, 0xE1,
				0x87, 0x67,
				0x5B, 0x40,
				0xA3,
				0x39,
				0x50,
				0x07,
				0x15,
				0xB5,
				0x76,
				0x3F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatWebp
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE2, 0xB0, 0x94, 0xE0,
				0xF2, 0x67,
				0xB3, 0x45,
				0xB0,
				0xEA,
				0x11,
				0x53,
				0x37,
				0xCA,
				0x7C,
				0xF3
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_ContainerFormatRaw
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x60, 0xCE, 0x99, 0xFE,
				0x9C, 0xF1,
				0x3C, 0x43,
				0xA3,
				0xAE,
				0x00,
				0xAC,
				0xEF,
				0xA9,
				0xCA,
				0x21
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICImagingCategories
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x80, 0xD3, 0xE3, 0xFA,
				0xA4, 0xFE,
				0x23, 0x46,
				0x8C,
				0x75,
				0xC6,
				0xB6,
				0x11,
				0x10,
				0xB6,
				0x81
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CATID_WICBitmapDecoders
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x37, 0x68, 0xD9, 0x7E,
				0xF0, 0x96,
				0x12, 0x48,
				0xB2,
				0x11,
				0xF1,
				0x3C,
				0x24,
				0x11,
				0x7E,
				0xD3
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CATID_WICBitmapEncoders
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x96, 0x72, 0x75, 0xAC,
				0x22, 0x35,
				0x11, 0x4E,
				0x98,
				0x62,
				0xC1,
				0x7B,
				0xE5,
				0xA1,
				0x76,
				0x7E
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CATID_WICPixelFormats
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0F, 0xE7, 0x46, 0x2B,
				0xA7, 0xCD,
				0x3E, 0x47,
				0x89,
				0xF6,
				0xDC,
				0x96,
				0x30,
				0xA2,
				0x39,
				0x0B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CATID_WICFormatConverters
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE8, 0xEA, 0x35, 0x78,
				0x14, 0xBF,
				0xD1, 0x49,
				0x93,
				0xCE,
				0x53,
				0x3A,
				0x40,
				0x7B,
				0x22,
				0x48
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CATID_WICMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xD8, 0x94, 0xAF, 0x05,
				0x74, 0x71,
				0xD2, 0x4C,
				0xBE,
				0x4A,
				0x41,
				0x24,
				0xB8,
				0x0E,
				0xE4,
				0xB8
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CATID_WICMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xA4, 0xB9, 0xE3, 0xAB,
				0x7D, 0x25,
				0x97, 0x4B,
				0xBD,
				0x1A,
				0x29,
				0x4A,
				0xF4,
				0x96,
				0x22,
				0x2E
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICDefaultFormatConverter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xDC, 0x11, 0x3F, 0x1A,
				0x14, 0xB5,
				0x17, 0x4B,
				0x8C,
				0x5F,
				0x21,
				0x54,
				0x51,
				0x38,
				0x52,
				0xF1
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICFormatConverterHighColor
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x54, 0xD4, 0x75, 0xAC,
				0x37, 0x9F,
				0xF8, 0x48,
				0xB9,
				0x72,
				0x4E,
				0x19,
				0xBC,
				0x85,
				0x60,
				0x11
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICFormatConverterNChannel
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xB2, 0xAB, 0x7C, 0xC1,
				0xA3, 0xD4,
				0xD7, 0x47,
				0xA5,
				0x57,
				0x33,
				0x9B,
				0x2E,
				0xFB,
				0xD4,
				0xF1
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICFormatConverterWMPhoto
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x2B, 0x17, 0xB5, 0x9C,
				0x00, 0xD6,
				0xBA, 0x46,
				0xAB,
				0x77,
				0x77,
				0xBB,
				0x7E,
				0x3A,
				0x00,
				0xD9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPlanarFormatConverter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xB8, 0x32, 0x41, 0x18,
				0xF8, 0x32,
				0x84, 0x47,
				0x91,
				0x31,
				0xDD,
				0x72,
				0x24,
				0xB2,
				0x34,
				0x38
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public const uint WIC_JPEG_MAX_COMPONENT_COUNT = 4;

	public const uint WIC_JPEG_MAX_TABLE_INDEX = 3;

	public const uint WIC_JPEG_SAMPLE_FACTORS_ONE = 17;

	public const uint WIC_JPEG_SAMPLE_FACTORS_THREE_420 = 1118498;

	public const uint WIC_JPEG_SAMPLE_FACTORS_THREE_422 = 1118497;

	public const uint WIC_JPEG_SAMPLE_FACTORS_THREE_440 = 1118482;

	public const uint WIC_JPEG_SAMPLE_FACTORS_THREE_444 = 1118481;

	public const uint WIC_JPEG_QUANTIZATION_BASELINE_ONE = 0;

	public const uint WIC_JPEG_QUANTIZATION_BASELINE_THREE = 65792;

	public const uint WIC_JPEG_HUFFMAN_BASELINE_ONE = 0;

	public const uint WIC_JPEG_HUFFMAN_BASELINE_THREE = 1118464;

	public static ref readonly Guid GUID_WICPixelFormatDontCare
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x00
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat1bppIndexed
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x01
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat2bppIndexed
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x02
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat4bppIndexed
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x03
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat8bppIndexed
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x04
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormatBlackWhite
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x05
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat2bppGray
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x06
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat4bppGray
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x07
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat8bppGray
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x08
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat8bppAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x16, 0x01, 0xCD, 0xE6,
				0xBA, 0xEE,
				0x61, 0x41,
				0xAA,
				0x85,
				0x27,
				0xDD,
				0x9F,
				0xB3,
				0xA8,
				0x95
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat16bppBGR555
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x09
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat16bppBGR565
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x0A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat16bppBGRA5551
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x2B, 0x7C, 0xEC, 0x05,
				0xE6, 0xF1,
				0x61, 0x49,
				0xAD,
				0x46,
				0xE1,
				0xCC,
				0x81,
				0x0A,
				0x87,
				0xD2
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat16bppGray
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x0B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat24bppBGR
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x0C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat24bppRGB
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x0D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppBGR
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x0E
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppBGRA
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x0F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppPBGRA
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x10
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppGrayFloat
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x11
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppRGB
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x95, 0x6B, 0x8C, 0xD9,
				0xFE, 0x3E,
				0xD6, 0x47,
				0xBB,
				0x25,
				0xEB,
				0x17,
				0x48,
				0xAB,
				0x0C,
				0xF1
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppRGBA
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x2D, 0xAD, 0xC7, 0xF5,
				0x8D, 0x6A,
				0xDD, 0x43,
				0xA7,
				0xA8,
				0xA2,
				0x99,
				0x35,
				0x26,
				0x1A,
				0xE9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppPRGBA
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x50, 0xA6, 0xC4, 0x3C,
				0x27, 0xA5,
				0x37, 0x4D,
				0xA9,
				0x16,
				0x31,
				0x42,
				0xC7,
				0xEB,
				0xED,
				0xBA
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat48bppRGB
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x15
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat48bppBGR
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x84, 0xA3, 0x05, 0xE6,
				0x68, 0xB4,
				0xCE, 0x46,
				0xBB,
				0x2E,
				0x36,
				0xF1,
				0x80,
				0xE6,
				0x43,
				0x13
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppRGB
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x11, 0x21, 0x18, 0xA1,
				0x6D, 0x18,
				0x42, 0x4D,
				0xBC,
				0x6A,
				0x9C,
				0x83,
				0x03,
				0xA8,
				0xDF,
				0xF9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppRGBA
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x16
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppBGRA
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x7C, 0xFF, 0x62, 0x15,
				0x52, 0xD3,
				0xF9, 0x46,
				0x97,
				0x9E,
				0x42,
				0x97,
				0x6B,
				0x79,
				0x22,
				0x46
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppPRGBA
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x17
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppPBGRA
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x8E, 0x8E, 0x51, 0x8C,
				0xEC, 0xA4,
				0x8B, 0x46,
				0xAE,
				0x70,
				0xC9,
				0xA3,
				0x5A,
				0x9C,
				0x55,
				0x30
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat16bppGrayFixedPoint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x13
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppBGR101010
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x14
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat48bppRGBFixedPoint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x12
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat48bppBGRFixedPoint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0E, 0x14, 0xCA, 0x49,
				0xB6, 0xCA,
				0x3B, 0x49,
				0x9D,
				0xDF,
				0x60,
				0x18,
				0x7C,
				0x37,
				0x53,
				0x2A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat96bppRGBFixedPoint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x18
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat96bppRGBFloat
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x8F, 0xD7, 0xFE, 0xE3,
				0xDB, 0xE8,
				0xCF, 0x4A,
				0x84,
				0xC1,
				0xE9,
				0x7F,
				0x61,
				0x36,
				0xB3,
				0x27
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat128bppRGBAFloat
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x19
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat128bppPRGBAFloat
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x1A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat128bppRGBFloat
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x1B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppCMYK
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x1C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppRGBAFixedPoint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x1D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppBGRAFixedPoint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x3C, 0xE3, 0x6D, 0x35,
				0xD2, 0x54,
				0x23, 0x4A,
				0xBB,
				0x04,
				0x9B,
				0x7B,
				0xF9,
				0xB1,
				0xD4,
				0x2D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppRGBFixedPoint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x40
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat128bppRGBAFixedPoint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x1E
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat128bppRGBFixedPoint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x41
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppRGBAHalf
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x3A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppPRGBAHalf
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC2, 0x26, 0xAD, 0x58,
				0x23, 0xC6,
				0x9D, 0x4D,
				0xB3,
				0x20,
				0x38,
				0x7E,
				0x49,
				0xF8,
				0xC4,
				0x42
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppRGBHalf
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x42
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat48bppRGBHalf
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x3B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppRGBE
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x3D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat16bppGrayHalf
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x3E
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppGrayFixedPoint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x3F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppRGBA1010102
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x72, 0x8D, 0x23, 0x25,
				0xF9, 0xFC,
				0x22, 0x45,
				0xB5,
				0x14,
				0x55,
				0x78,
				0xE5,
				0xAD,
				0x55,
				0xE0
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppRGBA1010102XR
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x9A, 0x6B, 0xDE, 0x00,
				0x01, 0xC1,
				0x4B, 0x43,
				0xB5,
				0x02,
				0xD0,
				0x16,
				0x5E,
				0xE1,
				0x12,
				0x2C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppR10G10B10A2
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xB5, 0x1B, 0x4E, 0x60,
				0x3C, 0x8A,
				0x65, 0x4B,
				0xB1,
				0x1C,
				0xBC,
				0x0B,
				0x8D,
				0xD7,
				0x5B,
				0x7F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bppR10G10B10A2HDR10
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x5D, 0x5C, 0x21, 0x9C,
				0xCC, 0x1A,
				0x0E, 0x4F,
				0xA4,
				0xBC,
				0x70,
				0xFB,
				0x3A,
				0xE8,
				0xFD,
				0x28
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bppCMYK
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x1F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat24bpp3Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x20
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bpp4Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x21
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat40bpp5Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x22
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat48bpp6Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x23
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat56bpp7Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x24
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bpp8Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x25
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat48bpp3Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x26
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bpp4Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x27
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat80bpp5Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x28
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat96bpp6Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x29
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat112bpp7Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x2A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat128bpp8Channels
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x2B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat40bppCMYKAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x2C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat80bppCMYKAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x2D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat32bpp3ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x2E
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat40bpp4ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x2F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat48bpp5ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x30
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat56bpp6ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x31
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bpp7ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x32
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat72bpp8ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x33
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat64bpp3ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x34
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat80bpp4ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x35
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat96bpp5ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x36
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat112bpp6ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x37
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat128bpp7ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x38
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat144bpp8ChannelsAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xC3, 0xDD, 0x6F,
				0x03, 0x4E,
				0xFE, 0x4B,
				0xB1,
				0x85,
				0x3D,
				0x77,
				0x76,
				0x8D,
				0xC9,
				0x39
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat8bppY
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x54, 0xDB, 0xB4, 0x91,
				0xF9, 0x2D,
				0xF0, 0x42,
				0xB4,
				0x49,
				0x29,
				0x09,
				0xBB,
				0x3D,
				0xF8,
				0x8E
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat8bppCb
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x24, 0xF2, 0x39, 0x13,
				0xFE, 0x6B,
				0x3E, 0x4C,
				0x93,
				0x02,
				0xE4,
				0xF3,
				0xA6,
				0xD0,
				0xCA,
				0x2A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat8bppCr
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x53, 0x50, 0x14, 0xB8,
				0x16, 0x21,
				0xF0, 0x49,
				0x88,
				0x35,
				0xED,
				0x84,
				0x4B,
				0x20,
				0x5C,
				0x51
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat16bppCbCr
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x6E, 0xBA, 0x95, 0xFF,
				0xE0, 0x11,
				0x63, 0x42,
				0xBB,
				0x45,
				0x01,
				0x72,
				0x1F,
				0x34,
				0x60,
				0xA4
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat16bppYQuantizedDctCoefficients
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x33, 0xF4, 0x55, 0xA3,
				0xE8, 0x48,
				0x42, 0x4A,
				0x84,
				0xD8,
				0xE2,
				0xAA,
				0x26,
				0xCA,
				0x80,
				0xA4
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat16bppCbQuantizedDctCoefficients
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x61, 0xFF, 0xC4, 0xD2,
				0xA5, 0x56,
				0xC2, 0x49,
				0x8B,
				0x5C,
				0x4C,
				0x19,
				0x25,
				0x96,
				0x48,
				0x37
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_WICPixelFormat16bppCrQuantizedDctCoefficients
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xF0, 0x54, 0xE3, 0x2F,
				0x80, 0x16,
				0xD8, 0x42,
				0x92,
				0x31,
				0xE7,
				0x3C,
				0x05,
				0x65,
				0xBF,
				0xC1
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public const uint FACILITY_WINCODEC_ERR = 2200;

	public const uint WINCODEC_ERR_BASE = 8192;

	public const int WINCODEC_ERR_GENERIC_ERROR = -2147467259;

	public const int WINCODEC_ERR_INVALIDPARAMETER = -2147024809;

	public const int WINCODEC_ERR_OUTOFMEMORY = -2147024882;

	public const int WINCODEC_ERR_NOTIMPLEMENTED = -2147467263;

	public const int WINCODEC_ERR_ABORTED = -2147467260;

	public const int WINCODEC_ERR_ACCESSDENIED = -2147024891;

	public const uint WICRawChangeNotification_ExposureCompensation = 1;

	public const uint WICRawChangeNotification_NamedWhitePoint = 2;

	public const uint WICRawChangeNotification_KelvinWhitePoint = 4;

	public const uint WICRawChangeNotification_RGBWhitePoint = 8;

	public const uint WICRawChangeNotification_Contrast = 16;

	public const uint WICRawChangeNotification_Gamma = 32;

	public const uint WICRawChangeNotification_Sharpness = 64;

	public const uint WICRawChangeNotification_Saturation = 128;

	public const uint WICRawChangeNotification_Tint = 256;

	public const uint WICRawChangeNotification_NoiseReduction = 512;

	public const uint WICRawChangeNotification_DestinationColorContext = 1024;

	public const uint WICRawChangeNotification_ToneCurve = 2048;

	public const uint WICRawChangeNotification_Rotation = 4096;

	public const uint WICRawChangeNotification_RenderMode = 8192;

	public static ref readonly Guid GUID_MetadataFormatUnknown
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x2F, 0x59, 0x5E, 0xA4,
				0x78, 0x90,
				0x7C, 0x4A,
				0xAD,
				0xB5,
				0x4E,
				0xDC,
				0x4F,
				0xD6,
				0x1B,
				0x1F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatIfd
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC6, 0x96, 0x73, 0x53,
				0x8A, 0x2D,
				0xB6, 0x4B,
				0x9B,
				0xF8,
				0x2F,
				0x0A,
				0x8E,
				0x2A,
				0x3A,
				0xDF
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatSubIfd
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x28, 0xE1, 0xA2, 0x58,
				0xB9, 0x2D,
				0x57, 0x4E,
				0xBB,
				0x14,
				0x51,
				0x77,
				0x89,
				0x1E,
				0xD3,
				0x31
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatExif
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x9D, 0x4F, 0x3C, 0x1C,
				0x4A, 0xB8,
				0x7D, 0x46,
				0x94,
				0x93,
				0x36,
				0xCF,
				0xBD,
				0x59,
				0xEA,
				0x57
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatGps
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x8A, 0xAB, 0x34, 0x71,
				0x51, 0x93,
				0xAD, 0x44,
				0xAF,
				0x62,
				0x44,
				0x8D,
				0xB6,
				0xB5,
				0x02,
				0xEC
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatInterop
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x8E, 0x6F, 0x68, 0xED,
				0x1F, 0x68,
				0x8B, 0x4C,
				0xBD,
				0x41,
				0xA8,
				0xAD,
				0xDB,
				0xF6,
				0xB3,
				0xFC
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatApp0
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x28, 0x70, 0x00, 0x79,
				0x8D, 0x26,
				0xD6, 0x45,
				0xA3,
				0xC2,
				0x35,
				0x4E,
				0x6A,
				0x50,
				0x4B,
				0xC9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatApp1
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC3, 0xDF, 0xD3, 0x8F,
				0x51, 0xF9,
				0x2B, 0x49,
				0x81,
				0x7F,
				0x69,
				0xC2,
				0xE6,
				0xD9,
				0xA5,
				0xB0
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatApp13
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xA2, 0x56, 0x65, 0x32,
				0x02, 0xF5,
				0x54, 0x43,
				0x9C,
				0xC0,
				0x8E,
				0x3F,
				0x48,
				0xEA,
				0xF6,
				0xB5
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatIPTC
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x14, 0x09, 0xAB, 0x4F,
				0x29, 0xE1,
				0x87, 0x40,
				0xA1,
				0xD1,
				0xBC,
				0x81,
				0x2D,
				0x45,
				0xA7,
				0xB5
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatIRB
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x66, 0x0D, 0x10, 0x16,
				0x70, 0x85,
				0xB9, 0x4B,
				0xB9,
				0x2D,
				0xFD,
				0xA4,
				0xB2,
				0x3E,
				0xCE,
				0x67
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormat8BIMIPTC
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x8C, 0x56, 0x10, 0x00,
				0x52, 0x08,
				0x6A, 0x4E,
				0xB1,
				0x91,
				0x5C,
				0x33,
				0xAC,
				0x5B,
				0x04,
				0x30
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormat8BIMResolutionInfo
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x5D, 0x30, 0x9F, 0x73,
				0xDB, 0x81,
				0xCB, 0x43,
				0xAC,
				0x5E,
				0x55,
				0x01,
				0x3E,
				0xF9,
				0xF0,
				0x03
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormat8BIMIPTCDigest
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x85, 0x22, 0xA3, 0x1C,
				0xCD, 0x9C,
				0x86, 0x47,
				0x8B,
				0xD8,
				0x79,
				0x53,
				0x9D,
				0xB6,
				0xA0,
				0x06
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatXMP
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x38, 0xCC, 0x5A, 0xBB,
				0x16, 0xF2,
				0xEC, 0x4C,
				0xA6,
				0xC5,
				0x5F,
				0x6E,
				0x73,
				0x97,
				0x63,
				0xA9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatThumbnail
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE9, 0xCE, 0x3D, 0x24,
				0x03, 0x87,
				0xEE, 0x40,
				0x8E,
				0xF0,
				0x22,
				0xA6,
				0x00,
				0xB8,
				0x05,
				0x8C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatChunktEXt
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x36, 0x89, 0x8D, 0x56,
				0xA9, 0xC0,
				0x23, 0x49,
				0x90,
				0x5D,
				0xDF,
				0x2B,
				0x38,
				0x23,
				0x8F,
				0xBC
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatXMPStruct
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xF1, 0x3C, 0x38, 0x22,
				0x17, 0xED,
				0x2E, 0x4E,
				0xAF,
				0x17,
				0xD8,
				0x5B,
				0x8F,
				0x6B,
				0x30,
				0xD0
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatXMPBag
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x5F, 0xCA, 0x3C, 0x83,
				0xB7, 0xDC,
				0x16, 0x45,
				0x80,
				0x6F,
				0x65,
				0x96,
				0xAB,
				0x26,
				0xDC,
				0xE4
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatXMPSeq
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x02, 0xDF, 0xE8, 0x63,
				0x6C, 0xEB,
				0x6C, 0x45,
				0xA2,
				0x24,
				0xB2,
				0x5E,
				0x79,
				0x4F,
				0xD6,
				0x48
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatXMPAlt
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x75, 0xA6, 0x08, 0x7B,
				0xAA, 0x91,
				0x1B, 0x48,
				0xA7,
				0x98,
				0x4D,
				0xA9,
				0x49,
				0x08,
				0x61,
				0x3B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatLSD
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x1E, 0x03, 0x56, 0xE2,
				0x99, 0x62,
				0x29, 0x49,
				0xB9,
				0x8D,
				0x5A,
				0xC8,
				0x84,
				0xAF,
				0xBA,
				0x92
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatIMD
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x86, 0xB0, 0x2B, 0xBD,
				0x52, 0x4D,
				0xDD, 0x48,
				0x96,
				0x77,
				0xDB,
				0x48,
				0x3E,
				0x85,
				0xAE,
				0x8F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatGCE
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xD8, 0xCA, 0x25, 0x2A,
				0xEB, 0xDE,
				0x69, 0x4C,
				0xA7,
				0x88,
				0x0E,
				0xC2,
				0x26,
				0x6D,
				0xCA,
				0xFD
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatAPE
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC2, 0x3D, 0x04, 0x2E,
				0x67, 0xC9,
				0x05, 0x4E,
				0x87,
				0x5E,
				0x61,
				0x8B,
				0xF6,
				0x7E,
				0x85,
				0xC3
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatJpegChrominance
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xCF, 0x0D, 0x3D, 0xF7,
				0xC6, 0xCE,
				0x85, 0x4F,
				0x9B,
				0x0E,
				0x1C,
				0x39,
				0x56,
				0xB1,
				0xBE,
				0xF7
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatJpegLuminance
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x07, 0x80, 0x90, 0x86,
				0xFC, 0xED,
				0x60, 0x48,
				0x8D,
				0x4B,
				0x4E,
				0xE6,
				0xE8,
				0x3E,
				0x60,
				0x58
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatJpegComment
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x33, 0x5F, 0x0E, 0x22,
				0xD3, 0xAF,
				0x4E, 0x47,
				0x9D,
				0x31,
				0x7D,
				0x4F,
				0xE7,
				0x30,
				0xF5,
				0x57
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatGifComment
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE0, 0xE0, 0xB6, 0xC4,
				0xB4, 0xCF,
				0xD3, 0x4A,
				0xAB,
				0x33,
				0x9A,
				0xAD,
				0x23,
				0x55,
				0xA3,
				0x4A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatChunkgAMA
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xA5, 0x35, 0x09, 0xF0,
				0x5D, 0x1D,
				0xD1, 0x4C,
				0x81,
				0xB2,
				0x93,
				0x24,
				0xD7,
				0xEC,
				0xA7,
				0x81
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatChunkbKGD
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x71, 0x35, 0x4D, 0xE1,
				0x47, 0x6B,
				0xEA, 0x4D,
				0xB6,
				0x0A,
				0x87,
				0xCE,
				0x0A,
				0x78,
				0xDF,
				0xB7
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatChunkiTXt
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x29, 0xC7, 0xBE, 0xC2,
				0x68, 0x0B,
				0x77, 0x4B,
				0xAA,
				0x0E,
				0x62,
				0x95,
				0xA6,
				0xAC,
				0x18,
				0x14
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatChunkcHRM
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x5B, 0x65, 0xB3, 0x9D,
				0x42, 0x28,
				0xB3, 0x44,
				0x80,
				0x67,
				0x12,
				0xE9,
				0xB3,
				0x75,
				0x55,
				0x6A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatChunkhIST
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xDA, 0x82, 0x9A, 0xC5,
				0x74, 0xDB,
				0xA4, 0x48,
				0xBD,
				0x6A,
				0xB6,
				0x9C,
				0x49,
				0x31,
				0xEF,
				0x95
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatChunkiCCP
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xAB, 0x49, 0x43, 0xEB,
				0x85, 0xB6,
				0x0F, 0x45,
				0x91,
				0xB5,
				0xE8,
				0x02,
				0xE8,
				0x92,
				0x53,
				0x6C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatChunksRGB
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x36, 0xFD, 0x15, 0xC1,
				0x6F, 0xCC,
				0x3F, 0x4E,
				0x83,
				0x63,
				0x52,
				0x4B,
				0x87,
				0xC6,
				0xB0,
				0xD9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatChunktIME
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x2D, 0xAE, 0x00, 0x6B,
				0x4B, 0xE2,
				0x0A, 0x46,
				0x98,
				0xB6,
				0x87,
				0x8B,
				0xD0,
				0x30,
				0x72,
				0xFD
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatDds
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x03, 0x46, 0x06, 0x4A,
				0x33, 0x8C,
				0x60, 0x4E,
				0x9C,
				0x29,
				0x13,
				0x62,
				0x31,
				0x70,
				0x2D,
				0x08
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatHeif
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE1, 0xF3, 0x7E, 0x81,
				0x88, 0x12,
				0xF4, 0x45,
				0xA8,
				0x52,
				0x26,
				0x0D,
				0x9E,
				0x7C,
				0xCE,
				0x83
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatHeifHDR
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x8A, 0x8D, 0x8B, 0x56,
				0x65, 0x1E,
				0x8C, 0x43,
				0x89,
				0x68,
				0xD6,
				0x0E,
				0x10,
				0x12,
				0xBE,
				0xB9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatWebpANIM
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xA6, 0xFD, 0xC4, 0x6D,
				0xE6, 0x78,
				0x02, 0x41,
				0xAE,
				0x35,
				0xBC,
				0xFA,
				0x1E,
				0xDC,
				0xC7,
				0x8B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid GUID_MetadataFormatWebpANMF
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xEE, 0x05, 0xC1, 0x43,
				0x3B, 0xB9,
				0xBB, 0x4A,
				0xB0,
				0x03,
				0xA0,
				0x8C,
				0x0D,
				0x87,
				0x04,
				0x71
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICUnknownMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC2, 0x45, 0x97, 0x69,
				0x66, 0x50,
				0x82, 0x4B,
				0xA8,
				0xE3,
				0xD4,
				0x04,
				0x78,
				0xDB,
				0xEC,
				0x8C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICUnknownMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x86, 0xCA, 0x9C, 0xA0,
				0xBA, 0x27,
				0x39, 0x4F,
				0x90,
				0x53,
				0x12,
				0x1F,
				0xA4,
				0xDC,
				0x08,
				0xFC
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICApp0MetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xA2, 0x33, 0xC6, 0xF3,
				0xC8, 0x46,
				0x8E, 0x49,
				0x8F,
				0xBB,
				0xCC,
				0x6F,
				0x72,
				0x1B,
				0xBC,
				0xDE
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICApp0MetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x33, 0x4B, 0x32, 0x43,
				0x8F, 0xA7,
				0x0F, 0x48,
				0x91,
				0x11,
				0x96,
				0x38,
				0xAA,
				0xCC,
				0xC8,
				0x32
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICApp1MetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x69, 0x60, 0x36, 0xEE,
				0x32, 0x18,
				0x0F, 0x42,
				0xB3,
				0x81,
				0x04,
				0x79,
				0xAD,
				0x06,
				0x6F,
				0x19
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICApp1MetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x13, 0x35, 0xE3, 0xDD,
				0x4E, 0x77,
				0xCD, 0x4B,
				0xAE,
				0x79,
				0x02,
				0xF4,
				0xAD,
				0xFE,
				0x62,
				0xFC
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICApp13MetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x19, 0xA9, 0x19, 0x7B,
				0xD6, 0xA9,
				0xE5, 0x49,
				0xBD,
				0x45,
				0x02,
				0xC3,
				0x4E,
				0x4E,
				0x4C,
				0xD5
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICApp13MetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x50, 0x3C, 0x7E, 0xAA,
				0x4C, 0x86,
				0x04, 0x46,
				0xBC,
				0x04,
				0x8B,
				0x0B,
				0x76,
				0xE6,
				0x37,
				0xF6
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICIfdMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x56, 0x46, 0x91, 0x8F,
				0x0A, 0x9D,
				0xB2, 0x4E,
				0x90,
				0x19,
				0x0B,
				0xF9,
				0x6D,
				0x8A,
				0x9E,
				0xE6
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICIfdMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x28, 0xFC, 0xEB, 0xB1,
				0xBD, 0xC9,
				0xA2, 0x47,
				0x8D,
				0x33,
				0xB9,
				0x48,
				0x76,
				0x97,
				0x77,
				0xA7
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICSubIfdMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x09, 0x2F, 0xD4, 0x50,
				0xD1, 0xEC,
				0x41, 0x4B,
				0xB6,
				0x5D,
				0xDA,
				0x1F,
				0xDA,
				0xA7,
				0x56,
				0x63
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICSubIfdMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x86, 0x53, 0xDE, 0x8A,
				0x9B, 0x8E,
				0x4C, 0x4F,
				0xAC,
				0xF2,
				0xF0,
				0x00,
				0x87,
				0x06,
				0xB2,
				0x38
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICExifMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x60, 0x38, 0x40, 0xD9,
				0x7F, 0x29,
				0x49, 0x4A,
				0xBF,
				0x9B,
				0x77,
				0x89,
				0x81,
				0x50,
				0xA4,
				0x42
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICExifMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xDA, 0x4C, 0xA1, 0xC9,
				0x39, 0xC3,
				0x0B, 0x46,
				0x90,
				0x78,
				0xD4,
				0xDE,
				0xBC,
				0xFA,
				0xBE,
				0x91
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICGpsMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0B, 0x79, 0x97, 0x36,
				0x3B, 0x22,
				0x4E, 0x48,
				0x99,
				0x25,
				0xC4,
				0x86,
				0x92,
				0x18,
				0xF1,
				0x7A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICGpsMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE4, 0x13, 0x8C, 0xCB,
				0xB5, 0x62,
				0x96, 0x4C,
				0xA4,
				0x8B,
				0x6B,
				0xA6,
				0xAC,
				0xE3,
				0x9C,
				0x76
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICInteropMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x98, 0xB8, 0xC8, 0xB5,
				0x74, 0x00,
				0x9F, 0x45,
				0xB7,
				0x00,
				0x86,
				0x0D,
				0x46,
				0x51,
				0xEA,
				0x14
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICInteropMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x45, 0xC6, 0x2E, 0x12,
				0x7E, 0xCD,
				0xD8, 0x44,
				0xB1,
				0x86,
				0x2C,
				0x8C,
				0x20,
				0xC3,
				0xB5,
				0x0F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICThumbnailMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x59, 0x29, 0x01, 0xFB,
				0xF6, 0xF4,
				0xD7, 0x44,
				0x9D,
				0x09,
				0xDA,
				0xA0,
				0x87,
				0xA9,
				0xDB,
				0x57
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICThumbnailMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0C, 0xB2, 0x49, 0xD0,
				0xD0, 0x5D,
				0xFE, 0x44,
				0xB0,
				0xB3,
				0x8F,
				0x92,
				0xC8,
				0xE6,
				0xD0,
				0x80
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICIPTCMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x59, 0x29, 0x01, 0x03,
				0xF6, 0xF4,
				0xD7, 0x44,
				0x9D,
				0x09,
				0xDA,
				0xA0,
				0x87,
				0xA9,
				0xDB,
				0x57
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICIPTCMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0C, 0xB2, 0x49, 0x12,
				0xD0, 0x5D,
				0xFE, 0x44,
				0xB0,
				0xB3,
				0x8F,
				0x92,
				0xC8,
				0xE6,
				0xD0,
				0x80
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICIRBMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xD7, 0xD3, 0xDC, 0xD4,
				0xC2, 0xB4,
				0xD9, 0x47,
				0xA6,
				0xBF,
				0xB8,
				0x9B,
				0xA3,
				0x96,
				0xA4,
				0xA3
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICIRBMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x35, 0x19, 0x5C, 0x5C,
				0x35, 0x02,
				0x34, 0x44,
				0x80,
				0xBC,
				0x25,
				0x1B,
				0xC1,
				0xEC,
				0x39,
				0xC6
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WIC8BIMIPTCMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x8C, 0x66, 0x10, 0x00,
				0x01, 0x08,
				0xA6, 0x4D,
				0xA4,
				0xA4,
				0x82,
				0x65,
				0x22,
				0xB6,
				0xD2,
				0x8F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WIC8BIMIPTCMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x26, 0x82, 0x10, 0x00,
				0x41, 0xEE,
				0xA2, 0x44,
				0x9E,
				0x9C,
				0x4B,
				0xE4,
				0xD5,
				0xB1,
				0xD2,
				0xCD
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WIC8BIMResolutionInfoMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x7A, 0x13, 0x05, 0x58,
				0x48, 0xE3,
				0x7C, 0x4F,
				0xB3,
				0xCC,
				0x6D,
				0xB9,
				0x96,
				0x5A,
				0x05,
				0x99
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WIC8BIMResolutionInfoMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0E, 0xFE, 0xF2, 0x4F,
				0x4A, 0xE7,
				0x71, 0x4B,
				0x98,
				0xC4,
				0xAB,
				0x7D,
				0xC1,
				0x67,
				0x07,
				0xBA
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WIC8BIMIPTCDigestMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x1E, 0x5F, 0x80, 0x02,
				0xAA, 0xD5,
				0x5B, 0x41,
				0x82,
				0xC5,
				0x61,
				0xC0,
				0x33,
				0xA9,
				0x88,
				0xA6
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WIC8BIMIPTCDigestMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x2B, 0xE6, 0xB5, 0x2D,
				0x67, 0x0D,
				0x5F, 0x49,
				0x8F,
				0x9D,
				0xC2,
				0xF0,
				0x18,
				0x86,
				0x47,
				0xAC
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngTextMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xCC, 0xAF, 0x59, 0x4B,
				0xC3, 0xB8,
				0x8A, 0x40,
				0xB6,
				0x70,
				0x89,
				0xE5,
				0xFA,
				0xB6,
				0xFD,
				0xA7
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngTextMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xB9, 0xAF, 0xEB, 0xB5,
				0x3E, 0x25,
				0x72, 0x4A,
				0xA7,
				0x44,
				0x07,
				0x62,
				0xD2,
				0x68,
				0x56,
				0x83
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICXMPMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xDF, 0x24, 0xB6, 0x72,
				0x11, 0xAE,
				0x48, 0x49,
				0xA6,
				0x5C,
				0x35,
				0x1E,
				0xB0,
				0x82,
				0x94,
				0x19
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICXMPMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x4E, 0xE1, 0x65, 0x17,
				0xD4, 0x1B,
				0x2E, 0x46,
				0xB6,
				0xB1,
				0x59,
				0x0B,
				0xF1,
				0x26,
				0x2A,
				0xC6
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICXMPStructMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x9A, 0x0D, 0xB9, 0x01,
				0x09, 0x82,
				0xF7, 0x47,
				0x9C,
				0x52,
				0xE1,
				0x24,
				0x4B,
				0xF5,
				0x0C,
				0xED
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICXMPStructMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x93, 0x1F, 0xC2, 0x22,
				0xDB, 0x7D,
				0x1C, 0x41,
				0x9B,
				0x17,
				0xC5,
				0xB7,
				0xBD,
				0x06,
				0x4A,
				0xBC
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICXMPBagMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x30, 0x9A, 0xE7, 0xE7,
				0x2C, 0x4F,
				0xAB, 0x4F,
				0x8D,
				0x00,
				0x39,
				0x4F,
				0x2D,
				0x6B,
				0xBE,
				0xBE
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICXMPBagMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x8C, 0x2C, 0x82, 0xED,
				0xBE, 0xD6,
				0x01, 0x43,
				0xA6,
				0x31,
				0x0E,
				0x14,
				0x16,
				0xBA,
				0xD2,
				0x8F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICXMPSeqMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x53, 0xE7, 0x12, 0x7F,
				0x71, 0xFC,
				0xD7, 0x43,
				0xA5,
				0x1D,
				0x92,
				0xF3,
				0x59,
				0x77,
				0xAB,
				0xB5
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICXMPSeqMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xDE, 0xD1, 0x68, 0x6D,
				0x32, 0xD4,
				0x0F, 0x4B,
				0x92,
				0x3A,
				0x09,
				0x11,
				0x83,
				0xA9,
				0xBD,
				0xA7
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICXMPAltMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC2, 0xDC, 0x94, 0xAA,
				0xB0, 0xB8,
				0x98, 0x48,
				0xB8,
				0x35,
				0x00,
				0x0A,
				0xAB,
				0xD7,
				0x43,
				0x93
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICXMPAltMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x6C, 0x2A, 0x6C, 0x07,
				0x8F, 0xF7,
				0x46, 0x4C,
				0xA7,
				0x23,
				0x35,
				0x83,
				0xE7,
				0x08,
				0x76,
				0xEA
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICLSDMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x93, 0x07, 0x07, 0x41,
				0xE4, 0x59,
				0x9A, 0x47,
				0xA1,
				0xF7,
				0x95,
				0x4A,
				0xDC,
				0x2E,
				0xF5,
				0xFC
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICLSDMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE7, 0x37, 0xC0, 0x73,
				0xD9, 0xE5,
				0x54, 0x49,
				0x87,
				0x6A,
				0x6D,
				0xA8,
				0x1D,
				0x6E,
				0x57,
				0x68
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICGCEMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x5D, 0x34, 0x2E, 0xB9,
				0x2D, 0xF5,
				0xF3, 0x41,
				0xB5,
				0x62,
				0x08,
				0x1B,
				0xC7,
				0x72,
				0xE3,
				0xB9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICGCEMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x76, 0xDC, 0x95, 0xAF,
				0xB2, 0x16,
				0xF4, 0x47,
				0xB3,
				0xEA,
				0x3C,
				0x31,
				0x79,
				0x66,
				0x93,
				0xE7
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICIMDMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x67, 0xA2, 0x47, 0x74,
				0x15, 0x00,
				0xC8, 0x42,
				0xA8,
				0xF1,
				0xFB,
				0x3B,
				0x94,
				0xC6,
				0x83,
				0x61
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICIMDMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x1F, 0x07, 0x89, 0x8C,
				0x2E, 0x45,
				0x95, 0x4E,
				0x96,
				0x82,
				0x9D,
				0x10,
				0x24,
				0x62,
				0x71,
				0x72
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICAPEMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x3A, 0xB9, 0x67, 0x17,
				0x21, 0xB0,
				0xEA, 0x44,
				0x92,
				0x0F,
				0x86,
				0x3C,
				0x11,
				0xF4,
				0xF7,
				0x68
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICAPEMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xCA, 0xDF, 0x6E, 0xBD,
				0x90, 0x28,
				0x2F, 0x48,
				0xB2,
				0x33,
				0x8D,
				0x73,
				0x39,
				0xA1,
				0xCF,
				0x8D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICJpegChrominanceMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x4B, 0x90, 0xB1, 0x50,
				0x8F, 0xF2,
				0x74, 0x45,
				0x93,
				0xF4,
				0x0B,
				0xAD,
				0xE8,
				0x2C,
				0x69,
				0xE9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICJpegChrominanceMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xF0, 0x66, 0xF5, 0x3F,
				0x6B, 0x6E,
				0xD4, 0x49,
				0x96,
				0xE6,
				0xB7,
				0x88,
				0x86,
				0x69,
				0x2C,
				0x62
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICJpegLuminanceMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x88, 0x2F, 0x6F, 0x35,
				0xA6, 0x05,
				0x28, 0x47,
				0xB9,
				0xA4,
				0x1B,
				0xFB,
				0xCE,
				0x04,
				0xD8,
				0x38
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICJpegLuminanceMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xBC, 0x3A, 0x58, 0x1D,
				0x0E, 0x8A,
				0x57, 0x46,
				0x99,
				0x82,
				0xA3,
				0x80,
				0xCA,
				0x58,
				0xFB,
				0x4B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICJpegCommentMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x7C, 0x34, 0x66, 0x9F,
				0xC4, 0x60,
				0x4D, 0x4C,
				0xAB,
				0x58,
				0xD2,
				0x35,
				0x86,
				0x85,
				0xF6,
				0x07
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICJpegCommentMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x6F, 0x23, 0x73, 0xE5,
				0xB1, 0x55,
				0xDA, 0x4E,
				0x81,
				0xEA,
				0x9F,
				0x65,
				0xDB,
				0x02,
				0x90,
				0xD3
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICGifCommentMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x3B, 0x7D, 0x55, 0x32,
				0xDC, 0x69,
				0x95, 0x4F,
				0x83,
				0x6E,
				0xF5,
				0x97,
				0x2B,
				0x2F,
				0x61,
				0x59
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICGifCommentMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xFC, 0x97, 0x27, 0xA0,
				0xAE, 0xC4,
				0x8C, 0x41,
				0xAF,
				0x95,
				0xE6,
				0x37,
				0xC7,
				0xEA,
				0xD2,
				0xA1
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngGamaMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x39, 0xCA, 0x92, 0x36,
				0x82, 0xE0,
				0x50, 0x43,
				0x9E,
				0x1F,
				0x37,
				0x04,
				0xCB,
				0x08,
				0x3C,
				0xD5
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngGamaMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x13, 0x6D, 0x03, 0xFF,
				0x4B, 0x5D,
				0xDD, 0x46,
				0xB1,
				0x0F,
				0x10,
				0x66,
				0x93,
				0xD9,
				0xFE,
				0x4F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngBkgdMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xA6, 0xA4, 0xE7, 0x0C,
				0xE8, 0x03,
				0x60, 0x4A,
				0x9D,
				0x15,
				0x28,
				0x2E,
				0xF3,
				0x2E,
				0xE7,
				0xDA
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngBkgdMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xFD, 0xF2, 0xE3, 0x68,
				0xAE, 0x31,
				0x41, 0x44,
				0xBB,
				0x6A,
				0xFD,
				0x70,
				0x47,
				0x52,
				0x5F,
				0x90
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngItxtMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xFA, 0xB2, 0xBF, 0xAA,
				0x1E, 0x3E,
				0x8F, 0x4A,
				0x89,
				0x77,
				0x55,
				0x56,
				0xFB,
				0x94,
				0xEA,
				0x23
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngItxtMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x19, 0x97, 0x87, 0x31,
				0x51, 0xE7,
				0xF8, 0x4D,
				0x98,
				0x1D,
				0x68,
				0xDF,
				0xF6,
				0x77,
				0x04,
				0xED
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngChrmMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x36, 0x5F, 0x0B, 0xF9,
				0x7B, 0x36,
				0x2A, 0x40,
				0x9D,
				0xD1,
				0xBC,
				0x0F,
				0xD5,
				0x9D,
				0x8F,
				0x62
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngChrmMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xEB, 0xE3, 0x3C, 0xE2,
				0x08, 0x56,
				0x83, 0x4E,
				0xBC,
				0xEF,
				0x27,
				0xB1,
				0x98,
				0x7E,
				0x51,
				0xD7
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngHistMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xB7, 0x0B, 0x7A, 0x87,
				0x13, 0xA3,
				0x91, 0x44,
				0x87,
				0xB5,
				0x2E,
				0x6D,
				0x05,
				0x94,
				0xF5,
				0x20
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngHistMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x49, 0xE7, 0x03, 0x8A,
				0x2E, 0x67,
				0x6E, 0x44,
				0xBF,
				0x1F,
				0x2C,
				0x11,
				0xD2,
				0x33,
				0xB6,
				0xFF
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngIccpMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x3B, 0xE6, 0xD3, 0xF5,
				0x0F, 0xCB,
				0x28, 0x46,
				0xA4,
				0x78,
				0x6D,
				0x82,
				0x44,
				0xBE,
				0x36,
				0xB1
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngIccpMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x5F, 0x1E, 0x67, 0x16,
				0xE6, 0x0C,
				0xC4, 0x4C,
				0x97,
				0x68,
				0xE8,
				0x9F,
				0xE5,
				0x01,
				0x8A,
				0xDE
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngSrgbMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0C, 0x36, 0x40, 0xFB,
				0x7E, 0x54,
				0x56, 0x49,
				0xA3,
				0xB9,
				0xD4,
				0x41,
				0x88,
				0x59,
				0xBA,
				0x66
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngSrgbMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC6, 0x35, 0xEE, 0xA6,
				0xEC, 0x87,
				0xDF, 0x47,
				0x9F,
				0x22,
				0x1D,
				0x5A,
				0xAD,
				0x84,
				0x0C,
				0x82
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngTimeMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x02, 0xDF, 0x4E, 0xD9,
				0xE5, 0xEF,
				0x0D, 0x4F,
				0x85,
				0xC8,
				0xF5,
				0xA6,
				0x8B,
				0x30,
				0x00,
				0xB1
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICPngTimeMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x00, 0x84, 0xB7, 0x1A,
				0xA3, 0xB5,
				0x91, 0x4D,
				0x8A,
				0xCE,
				0x33,
				0xFC,
				0xD1,
				0x49,
				0x9B,
				0xE6
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICDdsMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xCA, 0x88, 0x6C, 0x27,
				0x33, 0x75,
				0x86, 0x4A,
				0xB6,
				0x76,
				0x66,
				0xB3,
				0x60,
				0x80,
				0xD4,
				0x84
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICDdsMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xBD, 0x8B, 0x68, 0xFD,
				0xED, 0x31,
				0xB7, 0x4D,
				0xA7,
				0x23,
				0x93,
				0x49,
				0x27,
				0xD3,
				0x83,
				0x67
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICHeifMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x3F, 0xFC, 0xDD, 0xAC,
				0xEC, 0x85,
				0xBC, 0x41,
				0xBD,
				0xEF,
				0x1B,
				0xC2,
				0x62,
				0xE4,
				0xDB,
				0x05
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICHeifMetadataWriter
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x79, 0x5E, 0xE4, 0x3A,
				0xBC, 0x40,
				0x01, 0x44,
				0xAC,
				0xE5,
				0xDD,
				0x3C,
				0xB1,
				0x6E,
				0x6A,
				0xFE
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICHeifHDRMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x3D, 0xDE, 0x38, 0x24,
				0xD9, 0x94,
				0xE8, 0x4B,
				0x84,
				0xA8,
				0x4D,
				0xE9,
				0x5A,
				0x57,
				0x5E,
				0x75
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICWebpAnimMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x11, 0x99, 0x6F, 0x07,
				0x48, 0xA3,
				0x5C, 0x46,
				0xA8,
				0x07,
				0xA2,
				0x52,
				0xF3,
				0xF2,
				0xD3,
				0xDE
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_WICWebpAnmfMetadataReader
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x03, 0x0B, 0xA1, 0x85,
				0xF6, 0xC9,
				0x9F, 0x43,
				0xBE,
				0x5E,
				0xC0,
				0xFB,
				0xEF,
				0x67,
				0x80,
				0x7C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public const AlphaMode D2D1_ALPHA_MODE_UNKNOWN = AlphaMode.Unknown;
	public const AlphaMode D2D1_ALPHA_MODE_PREMULTIPLIED = AlphaMode.Premultiplied;
	public const AlphaMode D2D1_ALPHA_MODE_STRAIGHT = AlphaMode.Straight;
	public const AlphaMode D2D1_ALPHA_MODE_IGNORE = AlphaMode.Ignore;
	public const FigureBegin D2D1_FIGURE_BEGIN_FILLED = FigureBegin.Filled;
	public const FigureBegin D2D1_FIGURE_BEGIN_HOLLOW = FigureBegin.Hollow;
	public const FigureEnd D2D1_FIGURE_END_OPEN = FigureEnd.Open;
	public const FigureEnd D2D1_FIGURE_END_CLOSED = FigureEnd.Closed;
	public const PathSegment D2D1_PATH_SEGMENT_NONE = PathSegment.None;
	public const PathSegment D2D1_PATH_SEGMENT_FORCE_UNSTROKED = PathSegment.ForceUnstroked;
	public const PathSegment D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN = PathSegment.ForceRoundLineJoin;
	public const FillMode D2D1_FILL_MODE_ALTERNATE = FillMode.Alternate;
	public const FillMode D2D1_FILL_MODE_WINDING = FillMode.Winding;
	public const BorderMode D2D1_BORDER_MODE_SOFT = BorderMode.Soft;
	public const BorderMode D2D1_BORDER_MODE_HARD = BorderMode.Hard;
	public const BlendMode D2D1_BLEND_MODE_MULTIPLY = BlendMode.Multiply;
	public const BlendMode D2D1_BLEND_MODE_SCREEN = BlendMode.Screen;
	public const BlendMode D2D1_BLEND_MODE_DARKEN = BlendMode.Darken;
	public const BlendMode D2D1_BLEND_MODE_LIGHTEN = BlendMode.Lighten;
	public const BlendMode D2D1_BLEND_MODE_DISSOLVE = BlendMode.Dissolve;
	public const BlendMode D2D1_BLEND_MODE_COLOR_BURN = BlendMode.ColorBurn;
	public const BlendMode D2D1_BLEND_MODE_LINEAR_BURN = BlendMode.LinearBurn;
	public const BlendMode D2D1_BLEND_MODE_DARKER_COLOR = BlendMode.DarkerColor;
	public const BlendMode D2D1_BLEND_MODE_LIGHTER_COLOR = BlendMode.LighterColor;
	public const BlendMode D2D1_BLEND_MODE_COLOR_DODGE = BlendMode.ColorDodge;
	public const BlendMode D2D1_BLEND_MODE_LINEAR_DODGE = BlendMode.LinearDodge;
	public const BlendMode D2D1_BLEND_MODE_OVERLAY = BlendMode.Overlay;
	public const BlendMode D2D1_BLEND_MODE_SOFT_LIGHT = BlendMode.SoftLight;
	public const BlendMode D2D1_BLEND_MODE_HARD_LIGHT = BlendMode.HardLight;
	public const BlendMode D2D1_BLEND_MODE_VIVID_LIGHT = BlendMode.VividLight;
	public const BlendMode D2D1_BLEND_MODE_LINEAR_LIGHT = BlendMode.LinearLight;
	public const BlendMode D2D1_BLEND_MODE_PIN_LIGHT = BlendMode.PinLight;
	public const BlendMode D2D1_BLEND_MODE_HARD_MIX = BlendMode.HardMix;
	public const BlendMode D2D1_BLEND_MODE_DIFFERENCE = BlendMode.Difference;
	public const BlendMode D2D1_BLEND_MODE_EXCLUSION = BlendMode.Exclusion;
	public const BlendMode D2D1_BLEND_MODE_HUE = BlendMode.Hue;
	public const BlendMode D2D1_BLEND_MODE_SATURATION = BlendMode.Saturation;
	public const BlendMode D2D1_BLEND_MODE_COLOR = BlendMode.Color;
	public const BlendMode D2D1_BLEND_MODE_LUMINOSITY = BlendMode.Luminosity;
	public const BlendMode D2D1_BLEND_MODE_SUBTRACT = BlendMode.Subtract;
	public const BlendMode D2D1_BLEND_MODE_DIVISION = BlendMode.Division;
	public const ColorMatrixAlphaMode D2D1_COLORMATRIX_ALPHA_MODE_PREMULTIPLIED = ColorMatrixAlphaMode.Premultiplied;
	public const ColorMatrixAlphaMode D2D1_COLORMATRIX_ALPHA_MODE_STRAIGHT = ColorMatrixAlphaMode.Straight;
	public const AffineTransform2DInterpolationMode D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR = AffineTransform2DInterpolationMode.NearestNeighbor;
	public const AffineTransform2DInterpolationMode D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_LINEAR = AffineTransform2DInterpolationMode.Linear;
	public const AffineTransform2DInterpolationMode D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_CUBIC = AffineTransform2DInterpolationMode.Cubic;
	public const AffineTransform2DInterpolationMode D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = AffineTransform2DInterpolationMode.MultiSampleLinear;
	public const AffineTransform2DInterpolationMode D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_ANISOTROPIC = AffineTransform2DInterpolationMode.Anisotropic;
	public const AffineTransform2DInterpolationMode D2D1_2DAFFINETRANSFORM_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = AffineTransform2DInterpolationMode.HighQualityCubic;
	public const TurbulenceNoise D2D1_TURBULENCE_NOISE_FRACTAL_SUM = TurbulenceNoise.FractalSum;
	public const TurbulenceNoise D2D1_TURBULENCE_NOISE_TURBULENCE = TurbulenceNoise.Turbulence;
	public const CompositeMode D2D1_COMPOSITE_MODE_SOURCE_OVER = CompositeMode.SourceOver;
	public const CompositeMode D2D1_COMPOSITE_MODE_DESTINATION_OVER = CompositeMode.DestinationOver;
	public const CompositeMode D2D1_COMPOSITE_MODE_SOURCE_IN = CompositeMode.SourceIn;
	public const CompositeMode D2D1_COMPOSITE_MODE_DESTINATION_IN = CompositeMode.DestinationIn;
	public const CompositeMode D2D1_COMPOSITE_MODE_SOURCE_OUT = CompositeMode.SourceOut;
	public const CompositeMode D2D1_COMPOSITE_MODE_DESTINATION_OUT = CompositeMode.DestinationOut;
	public const CompositeMode D2D1_COMPOSITE_MODE_SOURCE_ATOP = CompositeMode.SourceAtop;
	public const CompositeMode D2D1_COMPOSITE_MODE_DESTINATION_ATOP = CompositeMode.DestinationAtop;
	public const CompositeMode D2D1_COMPOSITE_MODE_XOR = CompositeMode.Xor;
	public const CompositeMode D2D1_COMPOSITE_MODE_PLUS = CompositeMode.Plus;
	public const CompositeMode D2D1_COMPOSITE_MODE_SOURCE_COPY = CompositeMode.SourceCopy;
	public const CompositeMode D2D1_COMPOSITE_MODE_BOUNDED_SOURCE_COPY = CompositeMode.BoundedSourceCopy;
	public const CompositeMode D2D1_COMPOSITE_MODE_MASK_INVERT = CompositeMode.MaskInvert;
	public const WICColorContextType WICColorContextUninitialized = WICColorContextType.Uninitialized;
	public const WICColorContextType WICColorContextProfile = WICColorContextType.Profile;
	public const WICColorContextType WICColorContextExifColorSpace = WICColorContextType.ExifColorSpace;
	public const WICBitmapCreateCacheOption WICBitmapNoCache = WICBitmapCreateCacheOption.NoCache;
	public const WICBitmapCreateCacheOption WICBitmapCacheOnDemand = WICBitmapCreateCacheOption.CacheOnDemand;
	public const WICBitmapCreateCacheOption WICBitmapCacheOnLoad = WICBitmapCreateCacheOption.CacheOnLoad;
	public const WICDecodeOptions WICDecodeMetadataCacheOnDemand = WICDecodeOptions.CacheOnDemand;
	public const WICDecodeOptions WICDecodeMetadataCacheOnLoad = WICDecodeOptions.CacheOnLoad;
	public const WICBitmapEncoderCacheOption WICBitmapEncoderCacheInMemory = WICBitmapEncoderCacheOption.CacheInMemory;
	public const WICBitmapEncoderCacheOption WICBitmapEncoderCacheTempFile = WICBitmapEncoderCacheOption.CacheTempFile;
	public const WICBitmapEncoderCacheOption WICBitmapEncoderNoCache = WICBitmapEncoderCacheOption.NoCache;
	public const WICComponentType WICDecoder = WICComponentType.Decoder;
	public const WICComponentType WICEncoder = WICComponentType.Encoder;
	public const WICComponentType WICPixelFormatConverter = WICComponentType.PixelFormatConverter;
	public const WICComponentType WICMetadataReader = WICComponentType.MetadataReader;
	public const WICComponentType WICMetadataWriter = WICComponentType.MetadataWriter;
	public const WICComponentType WICPixelFormat = WICComponentType.PixelFormat;
	public const WICComponentType WICAllComponents = WICComponentType.AllComponents;
	public const WICComponentEnumerateOptions WICComponentEnumerateDefault = WICComponentEnumerateOptions.Default;
	public const WICComponentEnumerateOptions WICComponentEnumerateRefresh = WICComponentEnumerateOptions.Refresh;
	public const WICComponentEnumerateOptions WICComponentEnumerateDisabled = WICComponentEnumerateOptions.Disabled;
	public const WICComponentEnumerateOptions WICComponentEnumerateUnsigned = WICComponentEnumerateOptions.Unsigned;
	public const WICComponentEnumerateOptions WICComponentEnumerateBuiltInOnly = WICComponentEnumerateOptions.BuiltInOnly;
	public const WICBitmapInterpolationMode WICBitmapInterpolationModeNearestNeighbor = WICBitmapInterpolationMode.ModeNearestNeighbor;
	public const WICBitmapInterpolationMode WICBitmapInterpolationModeLinear = WICBitmapInterpolationMode.ModeLinear;
	public const WICBitmapInterpolationMode WICBitmapInterpolationModeCubic = WICBitmapInterpolationMode.ModeCubic;
	public const WICBitmapInterpolationMode WICBitmapInterpolationModeFant = WICBitmapInterpolationMode.ModeFant;
	public const WICBitmapInterpolationMode WICBitmapInterpolationModeHighQualityCubic = WICBitmapInterpolationMode.ModeHighQualityCubic;
	public const WICBitmapPaletteType WICBitmapPaletteTypeCustom = WICBitmapPaletteType.Custom;
	public const WICBitmapPaletteType WICBitmapPaletteTypeMedianCut = WICBitmapPaletteType.MedianCut;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedBW = WICBitmapPaletteType.FixedBW;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedHalftone8 = WICBitmapPaletteType.FixedHalftone8;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedHalftone27 = WICBitmapPaletteType.FixedHalftone27;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedHalftone64 = WICBitmapPaletteType.FixedHalftone64;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedHalftone125 = WICBitmapPaletteType.FixedHalftone125;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedHalftone216 = WICBitmapPaletteType.FixedHalftone216;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedWebPalette = WICBitmapPaletteType.FixedWebPalette;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedHalftone252 = WICBitmapPaletteType.FixedHalftone252;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedHalftone256 = WICBitmapPaletteType.FixedHalftone256;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedGray4 = WICBitmapPaletteType.FixedGray4;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedGray16 = WICBitmapPaletteType.FixedGray16;
	public const WICBitmapPaletteType WICBitmapPaletteTypeFixedGray256 = WICBitmapPaletteType.FixedGray256;
	public const WICBitmapDitherType WICBitmapDitherTypeNone = WICBitmapDitherType.None;
	public const WICBitmapDitherType WICBitmapDitherTypeSolid = WICBitmapDitherType.Solid;
	public const WICBitmapDitherType WICBitmapDitherTypeOrdered4x4 = WICBitmapDitherType.Ordered4x4;
	public const WICBitmapDitherType WICBitmapDitherTypeOrdered8x8 = WICBitmapDitherType.Ordered8x8;
	public const WICBitmapDitherType WICBitmapDitherTypeOrdered16x16 = WICBitmapDitherType.Ordered16x16;
	public const WICBitmapDitherType WICBitmapDitherTypeSpiral4x4 = WICBitmapDitherType.Spiral4x4;
	public const WICBitmapDitherType WICBitmapDitherTypeSpiral8x8 = WICBitmapDitherType.Spiral8x8;
	public const WICBitmapDitherType WICBitmapDitherTypeDualSpiral4x4 = WICBitmapDitherType.DualSpiral4x4;
	public const WICBitmapDitherType WICBitmapDitherTypeDualSpiral8x8 = WICBitmapDitherType.DualSpiral8x8;
	public const WICBitmapDitherType WICBitmapDitherTypeErrorDiffusion = WICBitmapDitherType.ErrorDiffusion;
	public const WICBitmapAlphaChannelOption WICBitmapUseAlpha = WICBitmapAlphaChannelOption.UseAlpha;
	public const WICBitmapAlphaChannelOption WICBitmapUsePremultipliedAlpha = WICBitmapAlphaChannelOption.UsePremultipliedAlpha;
	public const WICBitmapAlphaChannelOption WICBitmapIgnoreAlpha = WICBitmapAlphaChannelOption.IgnoreAlpha;
	public const WICBitmapTransformOptions WICBitmapTransformRotate0 = WICBitmapTransformOptions.Rotate0;
	public const WICBitmapTransformOptions WICBitmapTransformRotate90 = WICBitmapTransformOptions.Rotate90;
	public const WICBitmapTransformOptions WICBitmapTransformRotate180 = WICBitmapTransformOptions.Rotate180;
	public const WICBitmapTransformOptions WICBitmapTransformRotate270 = WICBitmapTransformOptions.Rotate270;
	public const WICBitmapTransformOptions WICBitmapTransformFlipHorizontal = WICBitmapTransformOptions.FlipHorizontal;
	public const WICBitmapTransformOptions WICBitmapTransformFlipVertical = WICBitmapTransformOptions.FlipVertical;
	public const WICBitmapLockFlags WICBitmapLockRead = WICBitmapLockFlags.Read;
	public const WICBitmapLockFlags WICBitmapLockWrite = WICBitmapLockFlags.Write;
	public const WICBitmapDecoderCapabilities WICBitmapDecoderCapabilitySameEncoder = WICBitmapDecoderCapabilities.SameEncoder;
	public const WICBitmapDecoderCapabilities WICBitmapDecoderCapabilityCanDecodeAllImages = WICBitmapDecoderCapabilities.CanDecodeAllImages;
	public const WICBitmapDecoderCapabilities WICBitmapDecoderCapabilityCanDecodeSomeImages = WICBitmapDecoderCapabilities.CanDecodeSomeImages;
	public const WICBitmapDecoderCapabilities WICBitmapDecoderCapabilityCanEnumerateMetadata = WICBitmapDecoderCapabilities.CanEnumerateMetadata;
	public const WICBitmapDecoderCapabilities WICBitmapDecoderCapabilityCanDecodeThumbnail = WICBitmapDecoderCapabilities.CanDecodeThumbnail;
	public const WICProgressOperation WICProgressOperationCopyPixels = WICProgressOperation.CopyPixels;
	public const WICProgressOperation WICProgressOperationWritePixels = WICProgressOperation.WritePixels;
	public const WICProgressOperation WICProgressOperationAll = WICProgressOperation.All;
	public const WICProgressNotification WICProgressNotificationBegin = WICProgressNotification.Begin;
	public const WICProgressNotification WICProgressNotificationEnd = WICProgressNotification.End;
	public const WICProgressNotification WICProgressNotificationFrequent = WICProgressNotification.Frequent;
	public const WICProgressNotification WICProgressNotificationAll = WICProgressNotification.All;
	public const WICComponentSigning WICComponentSigned = WICComponentSigning.Signed;
	public const WICComponentSigning WICComponentUnsigned = WICComponentSigning.Unsigned;
	public const WICComponentSigning WICComponentSafe = WICComponentSigning.Safe;
	public const WICComponentSigning WICComponentDisabled = WICComponentSigning.Disabled;
	public const WICGifLogicalScreenDescriptorProperties WICGifLogicalScreenSignature = WICGifLogicalScreenDescriptorProperties.WICGifLogicalScreenSignature;
	public const WICGifLogicalScreenDescriptorProperties WICGifLogicalScreenDescriptorWidth = WICGifLogicalScreenDescriptorProperties.WICGifLogicalScreenDescriptorWidth;
	public const WICGifLogicalScreenDescriptorProperties WICGifLogicalScreenDescriptorHeight = WICGifLogicalScreenDescriptorProperties.WICGifLogicalScreenDescriptorHeight;
	public const WICGifLogicalScreenDescriptorProperties WICGifLogicalScreenDescriptorGlobalColorTableFlag = WICGifLogicalScreenDescriptorProperties.WICGifLogicalScreenDescriptorGlobalColorTableFlag;
	public const WICGifLogicalScreenDescriptorProperties WICGifLogicalScreenDescriptorColorResolution = WICGifLogicalScreenDescriptorProperties.WICGifLogicalScreenDescriptorColorResolution;
	public const WICGifLogicalScreenDescriptorProperties WICGifLogicalScreenDescriptorSortFlag = WICGifLogicalScreenDescriptorProperties.WICGifLogicalScreenDescriptorSortFlag;
	public const WICGifLogicalScreenDescriptorProperties WICGifLogicalScreenDescriptorGlobalColorTableSize = WICGifLogicalScreenDescriptorProperties.WICGifLogicalScreenDescriptorGlobalColorTableSize;
	public const WICGifLogicalScreenDescriptorProperties WICGifLogicalScreenDescriptorBackgroundColorIndex = WICGifLogicalScreenDescriptorProperties.WICGifLogicalScreenDescriptorBackgroundColorIndex;
	public const WICGifLogicalScreenDescriptorProperties WICGifLogicalScreenDescriptorPixelAspectRatio = WICGifLogicalScreenDescriptorProperties.WICGifLogicalScreenDescriptorPixelAspectRatio;
	public const WICGifImageDescriptorProperties WICGifImageDescriptorLeft = WICGifImageDescriptorProperties.WICGifImageDescriptorLeft;
	public const WICGifImageDescriptorProperties WICGifImageDescriptorTop = WICGifImageDescriptorProperties.WICGifImageDescriptorTop;
	public const WICGifImageDescriptorProperties WICGifImageDescriptorWidth = WICGifImageDescriptorProperties.WICGifImageDescriptorWidth;
	public const WICGifImageDescriptorProperties WICGifImageDescriptorHeight = WICGifImageDescriptorProperties.WICGifImageDescriptorHeight;
	public const WICGifImageDescriptorProperties WICGifImageDescriptorLocalColorTableFlag = WICGifImageDescriptorProperties.WICGifImageDescriptorLocalColorTableFlag;
	public const WICGifImageDescriptorProperties WICGifImageDescriptorInterlaceFlag = WICGifImageDescriptorProperties.WICGifImageDescriptorInterlaceFlag;
	public const WICGifImageDescriptorProperties WICGifImageDescriptorSortFlag = WICGifImageDescriptorProperties.WICGifImageDescriptorSortFlag;
	public const WICGifImageDescriptorProperties WICGifImageDescriptorLocalColorTableSize = WICGifImageDescriptorProperties.WICGifImageDescriptorLocalColorTableSize;
	public const WICGifGraphicControlExtensionProperties WICGifGraphicControlExtensionDisposal = WICGifGraphicControlExtensionProperties.WICGifGraphicControlExtensionDisposal;
	public const WICGifGraphicControlExtensionProperties WICGifGraphicControlExtensionUserInputFlag = WICGifGraphicControlExtensionProperties.WICGifGraphicControlExtensionUserInputFlag;
	public const WICGifGraphicControlExtensionProperties WICGifGraphicControlExtensionTransparencyFlag = WICGifGraphicControlExtensionProperties.WICGifGraphicControlExtensionTransparencyFlag;
	public const WICGifGraphicControlExtensionProperties WICGifGraphicControlExtensionDelay = WICGifGraphicControlExtensionProperties.WICGifGraphicControlExtensionDelay;
	public const WICGifGraphicControlExtensionProperties WICGifGraphicControlExtensionTransparentColorIndex = WICGifGraphicControlExtensionProperties.WICGifGraphicControlExtensionTransparentColorIndex;
	public const WICGifApplicationExtensionProperties WICGifApplicationExtensionApplication = WICGifApplicationExtensionProperties.WICGifApplicationExtensionApplication;
	public const WICGifApplicationExtensionProperties WICGifApplicationExtensionData = WICGifApplicationExtensionProperties.WICGifApplicationExtensionData;
	public const WICGifCommentExtensionProperties WICGifCommentExtensionText = WICGifCommentExtensionProperties.WICGifCommentExtensionText;
	public const WICJpegCommentProperties WICJpegCommentText = WICJpegCommentProperties.WICJpegCommentText;
	public const WICJpegLuminanceProperties WICJpegLuminanceTable = WICJpegLuminanceProperties.WICJpegLuminanceTable;
	public const WICJpegChrominanceProperties WICJpegChrominanceTable = WICJpegChrominanceProperties.WICJpegChrominanceTable;
	public const WIC8BIMIptcProperties WIC8BIMIptcPString = WIC8BIMIptcProperties.WIC8BIMIptcPString;
	public const WIC8BIMIptcProperties WIC8BIMIptcEmbeddedIPTC = WIC8BIMIptcProperties.WIC8BIMIptcEmbeddedIPTC;
	public const WIC8BIMResolutionInfoProperties WIC8BIMResolutionInfoPString = WIC8BIMResolutionInfoProperties.WIC8BIMResolutionInfoPString;
	public const WIC8BIMResolutionInfoProperties WIC8BIMResolutionInfoHResolution = WIC8BIMResolutionInfoProperties.WIC8BIMResolutionInfoHResolution;
	public const WIC8BIMResolutionInfoProperties WIC8BIMResolutionInfoHResolutionUnit = WIC8BIMResolutionInfoProperties.WIC8BIMResolutionInfoHResolutionUnit;
	public const WIC8BIMResolutionInfoProperties WIC8BIMResolutionInfoWidthUnit = WIC8BIMResolutionInfoProperties.WIC8BIMResolutionInfoWidthUnit;
	public const WIC8BIMResolutionInfoProperties WIC8BIMResolutionInfoVResolution = WIC8BIMResolutionInfoProperties.WIC8BIMResolutionInfoVResolution;
	public const WIC8BIMResolutionInfoProperties WIC8BIMResolutionInfoVResolutionUnit = WIC8BIMResolutionInfoProperties.WIC8BIMResolutionInfoVResolutionUnit;
	public const WIC8BIMResolutionInfoProperties WIC8BIMResolutionInfoHeightUnit = WIC8BIMResolutionInfoProperties.WIC8BIMResolutionInfoHeightUnit;
	public const WIC8BIMIptcDigestProperties WIC8BIMIptcDigestPString = WIC8BIMIptcDigestProperties.WIC8BIMIptcDigestPString;
	public const WIC8BIMIptcDigestProperties WIC8BIMIptcDigestIptcDigest = WIC8BIMIptcDigestProperties.WIC8BIMIptcDigestIptcDigest;
	public const WICPngGamaProperties WICPngGamaGamma = WICPngGamaProperties.WICPngGamaGamma;
	public const WICPngBkgdProperties WICPngBkgdBackgroundColor = WICPngBkgdProperties.WICPngBkgdBackgroundColor;
	public const WICPngItxtProperties WICPngItxtKeyword = WICPngItxtProperties.WICPngItxtKeyword;
	public const WICPngItxtProperties WICPngItxtCompressionFlag = WICPngItxtProperties.WICPngItxtCompressionFlag;
	public const WICPngItxtProperties WICPngItxtLanguageTag = WICPngItxtProperties.WICPngItxtLanguageTag;
	public const WICPngItxtProperties WICPngItxtTranslatedKeyword = WICPngItxtProperties.WICPngItxtTranslatedKeyword;
	public const WICPngItxtProperties WICPngItxtText = WICPngItxtProperties.WICPngItxtText;
	public const WICPngChrmProperties WICPngChrmWhitePointX = WICPngChrmProperties.WICPngChrmWhitePointX;
	public const WICPngChrmProperties WICPngChrmWhitePointY = WICPngChrmProperties.WICPngChrmWhitePointY;
	public const WICPngChrmProperties WICPngChrmRedX = WICPngChrmProperties.WICPngChrmRedX;
	public const WICPngChrmProperties WICPngChrmRedY = WICPngChrmProperties.WICPngChrmRedY;
	public const WICPngChrmProperties WICPngChrmGreenX = WICPngChrmProperties.WICPngChrmGreenX;
	public const WICPngChrmProperties WICPngChrmGreenY = WICPngChrmProperties.WICPngChrmGreenY;
	public const WICPngChrmProperties WICPngChrmBlueX = WICPngChrmProperties.WICPngChrmBlueX;
	public const WICPngChrmProperties WICPngChrmBlueY = WICPngChrmProperties.WICPngChrmBlueY;
	public const WICPngHistProperties WICPngHistFrequencies = WICPngHistProperties.WICPngHistFrequencies;
	public const WICPngIccpProperties WICPngIccpProfileName = WICPngIccpProperties.WICPngIccpProfileName;
	public const WICPngIccpProperties WICPngIccpProfileData = WICPngIccpProperties.WICPngIccpProfileData;
	public const WICPngSrgbProperties WICPngSrgbRenderingIntent = WICPngSrgbProperties.WICPngSrgbRenderingIntent;
	public const WICPngTimeProperties WICPngTimeYear = WICPngTimeProperties.WICPngTimeYear;
	public const WICPngTimeProperties WICPngTimeMonth = WICPngTimeProperties.WICPngTimeMonth;
	public const WICPngTimeProperties WICPngTimeDay = WICPngTimeProperties.WICPngTimeDay;
	public const WICPngTimeProperties WICPngTimeHour = WICPngTimeProperties.WICPngTimeHour;
	public const WICPngTimeProperties WICPngTimeMinute = WICPngTimeProperties.WICPngTimeMinute;
	public const WICPngTimeProperties WICPngTimeSecond = WICPngTimeProperties.WICPngTimeSecond;
	public const WICHeifProperties WICHeifOrientation = WICHeifProperties.WICHeifOrientation;
	public const WICHeifHdrProperties WICHeifHdrMaximumLuminanceLevel = WICHeifHdrProperties.WICHeifHdrMaximumLuminanceLevel;
	public const WICHeifHdrProperties WICHeifHdrMaximumFrameAverageLuminanceLevel = WICHeifHdrProperties.WICHeifHdrMaximumFrameAverageLuminanceLevel;
	public const WICHeifHdrProperties WICHeifHdrMinimumMasteringDisplayLuminanceLevel = WICHeifHdrProperties.WICHeifHdrMinimumMasteringDisplayLuminanceLevel;
	public const WICHeifHdrProperties WICHeifHdrMaximumMasteringDisplayLuminanceLevel = WICHeifHdrProperties.WICHeifHdrMaximumMasteringDisplayLuminanceLevel;
	public const WICHeifHdrProperties WICHeifHdrCustomVideoPrimaries = WICHeifHdrProperties.WICHeifHdrCustomVideoPrimaries;
	public const WICWebpAnimProperties WICWebpAnimLoopCount = WICWebpAnimProperties.WICWebpAnimLoopCount;
	public const WICWebpAnmfProperties WICWebpAnmfFrameDuration = WICWebpAnmfProperties.WICWebpAnmfFrameDuration;
	public const WICSectionAccessLevel WICSectionAccessLevelRead = WICSectionAccessLevel.WICSectionAccessLevelRead;
	public const WICSectionAccessLevel WICSectionAccessLevelReadWrite = WICSectionAccessLevel.WICSectionAccessLevelReadWrite;
	public const WICPixelFormatNumericRepresentation WICPixelFormatNumericRepresentationUnspecified = WICPixelFormatNumericRepresentation.Unspecified;
	public const WICPixelFormatNumericRepresentation WICPixelFormatNumericRepresentationIndexed = WICPixelFormatNumericRepresentation.Indexed;
	public const WICPixelFormatNumericRepresentation WICPixelFormatNumericRepresentationUnsignedInteger = WICPixelFormatNumericRepresentation.UnsignedInteger;
	public const WICPixelFormatNumericRepresentation WICPixelFormatNumericRepresentationSignedInteger = WICPixelFormatNumericRepresentation.SignedInteger;
	public const WICPixelFormatNumericRepresentation WICPixelFormatNumericRepresentationFixed = WICPixelFormatNumericRepresentation.Fixed;
	public const WICPixelFormatNumericRepresentation WICPixelFormatNumericRepresentationFloat = WICPixelFormatNumericRepresentation.Float;
	public const WICPlanarOptions WICPlanarOptionsDefault = WICPlanarOptions.Default;
	public const WICPlanarOptions WICPlanarOptionsPreserveSubsampling = WICPlanarOptions.PreserveSubsampling;
	public const WICJpegIndexingOptions WICJpegIndexingOptionsGenerateOnDemand = WICJpegIndexingOptions.WICJpegIndexingOptionsGenerateOnDemand;
	public const WICJpegIndexingOptions WICJpegIndexingOptionsGenerateOnLoad = WICJpegIndexingOptions.WICJpegIndexingOptionsGenerateOnLoad;
	public const WICJpegTransferMatrix WICJpegTransferMatrixIdentity = WICJpegTransferMatrix.WICJpegTransferMatrixIdentity;
	public const WICJpegTransferMatrix WICJpegTransferMatrixBT601 = WICJpegTransferMatrix.WICJpegTransferMatrixBT601;
	public const WICJpegScanType WICJpegScanTypeInterleaved = WICJpegScanType.WICJpegScanTypeInterleaved;
	public const WICJpegScanType WICJpegScanTypePlanarComponents = WICJpegScanType.WICJpegScanTypePlanarComponents;
	public const WICJpegScanType WICJpegScanTypeProgressive = WICJpegScanType.WICJpegScanTypeProgressive;
	public const WICTiffCompressionOption WICTiffCompressionDontCare = WICTiffCompressionOption.WICTiffCompressionDontCare;
	public const WICTiffCompressionOption WICTiffCompressionNone = WICTiffCompressionOption.WICTiffCompressionNone;
	public const WICTiffCompressionOption WICTiffCompressionCCITT3 = WICTiffCompressionOption.WICTiffCompressionCCITT3;
	public const WICTiffCompressionOption WICTiffCompressionCCITT4 = WICTiffCompressionOption.WICTiffCompressionCCITT4;
	public const WICTiffCompressionOption WICTiffCompressionLZW = WICTiffCompressionOption.WICTiffCompressionLZW;
	public const WICTiffCompressionOption WICTiffCompressionRLE = WICTiffCompressionOption.WICTiffCompressionRLE;
	public const WICTiffCompressionOption WICTiffCompressionZIP = WICTiffCompressionOption.WICTiffCompressionZIP;
	public const WICTiffCompressionOption WICTiffCompressionLZWHDifferencing = WICTiffCompressionOption.WICTiffCompressionLZWHDifferencing;
	public const WICJpegYCrCbSubsamplingOption WICJpegYCrCbSubsamplingDefault = WICJpegYCrCbSubsamplingOption.WICJpegYCrCbSubsamplingDefault;
	public const WICJpegYCrCbSubsamplingOption WICJpegYCrCbSubsampling420 = WICJpegYCrCbSubsamplingOption.WICJpegYCrCbSubsampling420;
	public const WICJpegYCrCbSubsamplingOption WICJpegYCrCbSubsampling422 = WICJpegYCrCbSubsamplingOption.WICJpegYCrCbSubsampling422;
	public const WICJpegYCrCbSubsamplingOption WICJpegYCrCbSubsampling444 = WICJpegYCrCbSubsamplingOption.WICJpegYCrCbSubsampling444;
	public const WICJpegYCrCbSubsamplingOption WICJpegYCrCbSubsampling440 = WICJpegYCrCbSubsamplingOption.WICJpegYCrCbSubsampling440;
	public const WICPngFilterOption WICPngFilterUnspecified = WICPngFilterOption.WICPngFilterUnspecified;
	public const WICPngFilterOption WICPngFilterNone = WICPngFilterOption.WICPngFilterNone;
	public const WICPngFilterOption WICPngFilterSub = WICPngFilterOption.WICPngFilterSub;
	public const WICPngFilterOption WICPngFilterUp = WICPngFilterOption.WICPngFilterUp;
	public const WICPngFilterOption WICPngFilterAverage = WICPngFilterOption.WICPngFilterAverage;
	public const WICPngFilterOption WICPngFilterPaeth = WICPngFilterOption.WICPngFilterPaeth;
	public const WICPngFilterOption WICPngFilterAdaptive = WICPngFilterOption.WICPngFilterAdaptive;
	public const WICNamedWhitePoint WICWhitePointDefault = WICNamedWhitePoint.WICWhitePointDefault;
	public const WICNamedWhitePoint WICWhitePointDaylight = WICNamedWhitePoint.WICWhitePointDaylight;
	public const WICNamedWhitePoint WICWhitePointCloudy = WICNamedWhitePoint.WICWhitePointCloudy;
	public const WICNamedWhitePoint WICWhitePointShade = WICNamedWhitePoint.WICWhitePointShade;
	public const WICNamedWhitePoint WICWhitePointTungsten = WICNamedWhitePoint.WICWhitePointTungsten;
	public const WICNamedWhitePoint WICWhitePointFluorescent = WICNamedWhitePoint.WICWhitePointFluorescent;
	public const WICNamedWhitePoint WICWhitePointFlash = WICNamedWhitePoint.WICWhitePointFlash;
	public const WICNamedWhitePoint WICWhitePointUnderwater = WICNamedWhitePoint.WICWhitePointUnderwater;
	public const WICNamedWhitePoint WICWhitePointCustom = WICNamedWhitePoint.WICWhitePointCustom;
	public const WICNamedWhitePoint WICWhitePointAutoWhiteBalance = WICNamedWhitePoint.WICWhitePointAutoWhiteBalance;
	public const WICNamedWhitePoint WICWhitePointAsShot = WICNamedWhitePoint.WICWhitePointAsShot;
	public const WICRawCapabilities WICRawCapabilityNotSupported = WICRawCapabilities.WICRawCapabilityNotSupported;
	public const WICRawCapabilities WICRawCapabilityGetSupported = WICRawCapabilities.WICRawCapabilityGetSupported;
	public const WICRawCapabilities WICRawCapabilityFullySupported = WICRawCapabilities.WICRawCapabilityFullySupported;
	public const WICRawRotationCapabilities WICRawRotationCapabilityNotSupported = WICRawRotationCapabilities.WICRawRotationCapabilityNotSupported;
	public const WICRawRotationCapabilities WICRawRotationCapabilityGetSupported = WICRawRotationCapabilities.WICRawRotationCapabilityGetSupported;
	public const WICRawRotationCapabilities WICRawRotationCapabilityNinetyDegreesSupported = WICRawRotationCapabilities.WICRawRotationCapabilityNinetyDegreesSupported;
	public const WICRawRotationCapabilities WICRawRotationCapabilityFullySupported = WICRawRotationCapabilities.WICRawRotationCapabilityFullySupported;
	public const WICRawParameterSet WICAsShotParameterSet = WICRawParameterSet.WICAsShotParameterSet;
	public const WICRawParameterSet WICUserAdjustedParameterSet = WICRawParameterSet.WICUserAdjustedParameterSet;
	public const WICRawParameterSet WICAutoAdjustedParameterSet = WICRawParameterSet.WICAutoAdjustedParameterSet;
	public const WICRawRenderMode WICRawRenderModeDraft = WICRawRenderMode.WICRawRenderModeDraft;
	public const WICRawRenderMode WICRawRenderModeNormal = WICRawRenderMode.WICRawRenderModeNormal;
	public const WICRawRenderMode WICRawRenderModeBestQuality = WICRawRenderMode.WICRawRenderModeBestQuality;
	public const WICDdsDimension WICDdsTexture1D = WICDdsDimension.WICDdsTexture1D;
	public const WICDdsDimension WICDdsTexture2D = WICDdsDimension.WICDdsTexture2D;
	public const WICDdsDimension WICDdsTexture3D = WICDdsDimension.WICDdsTexture3D;
	public const WICDdsDimension WICDdsTextureCube = WICDdsDimension.WICDdsTextureCube;
	public const WICDdsAlphaMode WICDdsAlphaModeUnknown = WICDdsAlphaMode.WICDdsAlphaModeUnknown;
	public const WICDdsAlphaMode WICDdsAlphaModeStraight = WICDdsAlphaMode.WICDdsAlphaModeStraight;
	public const WICDdsAlphaMode WICDdsAlphaModePremultiplied = WICDdsAlphaMode.WICDdsAlphaModePremultiplied;
	public const WICDdsAlphaMode WICDdsAlphaModeOpaque = WICDdsAlphaMode.WICDdsAlphaModeOpaque;
	public const WICDdsAlphaMode WICDdsAlphaModeCustom = WICDdsAlphaMode.WICDdsAlphaModeCustom;
	public const WICMetadataCreationOptions WICMetadataCreationDefault = WICMetadataCreationOptions.WICMetadataCreationDefault;
	public const WICMetadataCreationOptions WICMetadataCreationAllowUnknown = WICMetadataCreationOptions.WICMetadataCreationAllowUnknown;
	public const WICMetadataCreationOptions WICMetadataCreationFailUnknown = WICMetadataCreationOptions.WICMetadataCreationFailUnknown;
	public const WICMetadataCreationOptions WICMetadataCreationMask = WICMetadataCreationOptions.WICMetadataCreationMask;
	public const WICPersistOptions WICPersistOptionDefault = WICPersistOptions.Default;
	public const WICPersistOptions WICPersistOptionLittleEndian = WICPersistOptions.LittleEndian;
	public const WICPersistOptions WICPersistOptionBigEndian = WICPersistOptions.BigEndian;
	public const WICPersistOptions WICPersistOptionStrictFormat = WICPersistOptions.StrictFormat;
	public const WICPersistOptions WICPersistOptionNoCacheStream = WICPersistOptions.NoCacheStream;
	public const WICPersistOptions WICPersistOptionPreferUTF8 = WICPersistOptions.PreferUTF8;
	public const WICPersistOptions WICPersistOptionMask = WICPersistOptions.Mask;
}