// ------------------------------------------------------------------------------
// <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>
// ------------------------------------------------------------------------------

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));
		}
	}
}

