using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Iced.Intel.BlockEncoderInternal;
using Iced.Intel.DecoderInternal;
using Iced.Intel.EncoderInternal;
using Iced.Intel.Internal;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Iced.UnitTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100d94ac07d6edc1ac1f306b60544bb88927664f05037602c5e994ea52ca5b0aadc4a242d90522f46730c11af657acc3ff5aadfe19a3030e7dbd67b481635eecd7d738950a7de6a78c92715b797dde11e87d967109da659672957fabe3524cd5f90557cd8ab4927333a0dbd32e7e7246ee18a43327806c6721283fc619acca3f2cb")]
[assembly: TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName = ".NET 8.0")]
[assembly: AssemblyCompany("iced project and contributors <https://github.com/icedland>")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (C) 2018-present iced project and contributors")]
[assembly: AssemblyDescription("x86/x64 disassembler, assembler, instruction decoder")]
[assembly: AssemblyFileVersion("1.21.0.0")]
[assembly: AssemblyInformationalVersion("1.21.0+69fdc9deb")]
[assembly: AssemblyProduct("Iced")]
[assembly: AssemblyTitle("MonoMod.Iced")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/MonoMod/MonoMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.21.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NullablePublicOnly(true)]
namespace MonoMod.SourceGen.Attributes
{
	[AttributeUsage(AttributeTargets.Class)]
	internal sealed class EmitILOverloadsAttribute : Attribute
	{
		public EmitILOverloadsAttribute(string filename, string kind)
		{
		}
	}
	internal static class ILOverloadKind
	{
		public const string Cursor = "ILCursor";

		public const string Matcher = "ILMatcher";
	}
}
namespace iced
{
	internal static class AssemblyInfo
	{
		public const string AssemblyName = "MonoMod.Iced";

		public const string AssemblyVersion = "1.21.0";
	}
}
namespace Iced.Intel
{
	public enum RelocKind
	{
		Offset64
	}
	public readonly struct RelocInfo
	{
		public readonly ulong Address;

		public readonly RelocKind Kind;

		public RelocInfo(RelocKind kind, ulong address)
		{
			Kind = kind;
			Address = address;
		}
	}
	public readonly struct InstructionBlock
	{
		public readonly CodeWriter CodeWriter;

		public readonly IList<Instruction> Instructions;

		public readonly ulong RIP;

		public InstructionBlock(CodeWriter codeWriter, IList<Instruction> instructions, ulong rip)
		{
			CodeWriter = codeWriter ?? throw new ArgumentNullException("codeWriter");
			Instructions = instructions ?? throw new ArgumentNullException("instructions");
			RIP = rip;
		}
	}
	public readonly struct BlockEncoderResult
	{
		public readonly ulong RIP;

		public readonly List<RelocInfo>? RelocInfos;

		public readonly uint[] NewInstructionOffsets;

		public readonly ConstantOffsets[] ConstantOffsets;

		internal BlockEncoderResult(ulong rip, List<RelocInfo>? relocInfos, uint[]? newInstructionOffsets, ConstantOffsets[]? constantOffsets)
		{
			RIP = rip;
			RelocInfos = relocInfos;
			NewInstructionOffsets = newInstructionOffsets ?? Array2.Empty<uint>();
			ConstantOffsets = constantOffsets ?? Array2.Empty<ConstantOffsets>();
		}
	}
	[Flags]
	public enum BlockEncoderOptions
	{
		None = 0,
		DontFixBranches = 1,
		ReturnRelocInfos = 2,
		ReturnNewInstructionOffsets = 4,
		ReturnConstantOffsets = 8
	}
	public sealed class BlockEncoder
	{
		private sealed class NullCodeWriter : CodeWriter
		{
			public static readonly NullCodeWriter Instance = new NullCodeWriter();

			private NullCodeWriter()
			{
			}

			public override void WriteByte(byte value)
			{
			}
		}

		private readonly int bitness;

		private readonly BlockEncoderOptions options;

		private readonly Block[] blocks;

		private readonly Encoder nullEncoder;

		private readonly Dictionary<ulong, Instr> toInstr;

		internal int Bitness => bitness;

		internal bool FixBranches => (options & BlockEncoderOptions.DontFixBranches) == 0;

		private bool ReturnRelocInfos => (options & BlockEncoderOptions.ReturnRelocInfos) != 0;

		private bool ReturnNewInstructionOffsets => (options & BlockEncoderOptions.ReturnNewInstructionOffsets) != 0;

		private bool ReturnConstantOffsets => (options & BlockEncoderOptions.ReturnConstantOffsets) != 0;

		private BlockEncoder(int bitness, InstructionBlock[] instrBlocks, BlockEncoderOptions options)
		{
			if (bitness != 16 && bitness != 32 && bitness != 64)
			{
				throw new ArgumentOutOfRangeException("bitness");
			}
			if (instrBlocks == null)
			{
				throw new ArgumentNullException("instrBlocks");
			}
			this.bitness = bitness;
			nullEncoder = Encoder.Create(bitness, NullCodeWriter.Instance);
			this.options = options;
			blocks = new Block[instrBlocks.Length];
			int num = 0;
			for (int i = 0; i < instrBlocks.Length; i++)
			{
				IList<Instruction> instructions = instrBlocks[i].Instructions;
				if (instructions == null)
				{
					throw new ArgumentException();
				}
				Block block = new Block(this, instrBlocks[i].CodeWriter, instrBlocks[i].RIP, ReturnRelocInfos ? new List<RelocInfo>() : null);
				blocks[i] = block;
				Instr[] array = new Instr[instructions.Count];
				ulong num2 = instrBlocks[i].RIP;
				for (int j = 0; j < array.Length; j++)
				{
					Instr instr = Instr.Create(this, block, instructions[j]);
					instr.IP = num2;
					array[j] = instr;
					num++;
					num2 += instr.Size;
				}
				block.SetInstructions(array);
			}
			Array.Sort(blocks, (Block a, Block b) => a.RIP.CompareTo(b.RIP));
			Dictionary<ulong, Instr> dictionary = (toInstr = new Dictionary<ulong, Instr>(num));
			bool flag = false;
			Block[] array2 = blocks;
			for (int num3 = 0; num3 < array2.Length; num3++)
			{
				Instr[] instructions2 = array2[num3].Instructions;
				foreach (Instr instr2 in instructions2)
				{
					ulong origIP = instr2.OrigIP;
					if (dictionary.TryGetValue(origIP, out var _))
					{
						if (origIP != 0L)
						{
							throw new ArgumentException($"Multiple instructions with the same IP: 0x{origIP:X}");
						}
						flag = true;
					}
					else
					{
						dictionary[origIP] = instr2;
					}
				}
			}
			if (flag)
			{
				dictionary.Remove(0uL);
			}
			array2 = blocks;
			foreach (Block obj in array2)
			{
				ulong num5 = obj.RIP;
				Instr[] instructions2 = obj.Instructions;
				foreach (Instr instr3 in instructions2)
				{
					instr3.IP = num5;
					if (!instr3.Done)
					{
						instr3.Initialize(this);
					}
					num5 += instr3.Size;
				}
			}
		}

		public static bool TryEncode(int bitness, InstructionBlock block, [NotNullWhen(false)] out string? errorMessage, out BlockEncoderResult result, BlockEncoderOptions options = BlockEncoderOptions.None)
		{
			if (TryEncode(bitness, new InstructionBlock[1] { block }, out errorMessage, out BlockEncoderResult[] result2, options))
			{
				result = result2[0];
				return true;
			}
			result = default(BlockEncoderResult);
			return false;
		}

		public static bool TryEncode(int bitness, InstructionBlock[] blocks, [NotNullWhen(false)] out string? errorMessage, [NotNullWhen(true)] out BlockEncoderResult[]? result, BlockEncoderOptions options = BlockEncoderOptions.None)
		{
			return new BlockEncoder(bitness, blocks, options).Encode(out errorMessage, out result);
		}

		private bool Encode([NotNullWhen(false)] out string errorMessage, [NotNullWhen(true)] out BlockEncoderResult[] result)
		{
			Block[] array;
			for (int i = 0; i < 5; i++)
			{
				bool flag = false;
				array = blocks;
				foreach (Block obj in array)
				{
					ulong num = obj.RIP;
					ulong num2 = 0uL;
					Instr[] instructions = obj.Instructions;
					foreach (Instr instr in instructions)
					{
						instr.IP = num;
						if (!instr.Done)
						{
							uint size = instr.Size;
							if (instr.Optimize(num2))
							{
								if (instr.Size > size)
								{
									errorMessage = "Internal error: new size > old size";
									result = null;
									return false;
								}
								if (instr.Size < size)
								{
									num2 += size - instr.Size;
									flag = true;
								}
							}
							else if (instr.Size != size)
							{
								errorMessage = "Internal error: new size != old size";
								result = null;
								return false;
							}
						}
						num += instr.Size;
					}
				}
				if (!flag)
				{
					break;
				}
			}
			array = blocks;
			for (int j = 0; j < array.Length; j++)
			{
				array[j].InitializeData();
			}
			BlockEncoderResult[] array2 = new BlockEncoderResult[blocks.Length];
			for (int l = 0; l < blocks.Length; l++)
			{
				Block block = blocks[l];
				Encoder encoder = Encoder.Create(bitness, block.CodeWriter);
				ulong num3 = block.RIP;
				uint[] array3 = (ReturnNewInstructionOffsets ? new uint[block.Instructions.Length] : null);
				ConstantOffsets[] array4 = (ReturnConstantOffsets ? new ConstantOffsets[block.Instructions.Length] : null);
				Instr[] instructions2 = block.Instructions;
				for (int m = 0; m < instructions2.Length; m++)
				{
					Instr instr2 = instructions2[m];
					uint bytesWritten = block.CodeWriter.BytesWritten;
					bool isOriginalInstruction;
					if (array4 != null)
					{
						errorMessage = instr2.TryEncode(encoder, out array4[m], out isOriginalInstruction);
					}
					else
					{
						errorMessage = instr2.TryEncode(encoder, out var _, out isOriginalInstruction);
					}
					if (errorMessage != null)
					{
						result = null;
						return false;
					}
					uint num4 = block.CodeWriter.BytesWritten - bytesWritten;
					if (num4 != instr2.Size)
					{
						errorMessage = "Internal error: didn't write all bytes";
						result = null;
						return false;
					}
					if (array3 != null)
					{
						if (isOriginalInstruction)
						{
							array3[m] = (uint)(num3 - block.RIP);
						}
						else
						{
							array3[m] = uint.MaxValue;
						}
					}
					num3 += num4;
				}
				array2[l] = new BlockEncoderResult(block.RIP, block.relocInfos, array3, array4);
				block.WriteData();
			}
			errorMessage = null;
			result = array2;
			return true;
		}

		internal TargetInstr GetTarget(ulong address)
		{
			if (toInstr.TryGetValue(address, out var value))
			{
				return new TargetInstr(value);
			}
			return new TargetInstr(address);
		}

		internal uint GetInstructionSize(in Instruction instruction, ulong ip)
		{
			if (!nullEncoder.TryEncode(in instruction, ip, out uint encodedLength, out string _))
			{
				return 15u;
			}
			return encodedLength;
		}
	}
	public sealed class ByteArrayCodeReader : CodeReader
	{
		private readonly byte[] data;

		private int currentPosition;

		private readonly int startPosition;

		private readonly int endPosition;

		public int Position
		{
			get
			{
				return currentPosition - startPosition;
			}
			set
			{
				if ((uint)value > (uint)Count)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException_value();
				}
				currentPosition = startPosition + value;
			}
		}

		public int Count => endPosition - startPosition;

		public bool CanReadByte => currentPosition < endPosition;

		public ByteArrayCodeReader(string hexData)
			: this(HexUtils.ToByteArray(hexData))
		{
		}

		public ByteArrayCodeReader(byte[] data)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			this.data = data;
			currentPosition = 0;
			startPosition = 0;
			endPosition = data.Length;
		}

		public ByteArrayCodeReader(byte[] data, int index, int count)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			this.data = data;
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_count();
			}
			if ((uint)(index + count) > (uint)data.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_count();
			}
			currentPosition = index;
			startPosition = index;
			endPosition = index + count;
		}

		public ByteArrayCodeReader(ArraySegment<byte> data)
		{
			if (data.Array == null)
			{
				ThrowHelper.ThrowArgumentException();
			}
			this.data = data.Array;
			endPosition = (startPosition = (currentPosition = data.Offset)) + data.Count;
		}

		public override int ReadByte()
		{
			if (currentPosition >= endPosition)
			{
				return -1;
			}
			return data[currentPosition++];
		}
	}
	public enum Code
	{
		INVALID,
		DeclareByte,
		DeclareWord,
		DeclareDword,
		DeclareQword,
		Add_rm8_r8,
		Add_rm16_r16,
		Add_rm32_r32,
		Add_rm64_r64,
		Add_r8_rm8,
		Add_r16_rm16,
		Add_r32_rm32,
		Add_r64_rm64,
		Add_AL_imm8,
		Add_AX_imm16,
		Add_EAX_imm32,
		Add_RAX_imm32,
		Pushw_ES,
		Pushd_ES,
		Popw_ES,
		Popd_ES,
		Or_rm8_r8,
		Or_rm16_r16,
		Or_rm32_r32,
		Or_rm64_r64,
		Or_r8_rm8,
		Or_r16_rm16,
		Or_r32_rm32,
		Or_r64_rm64,
		Or_AL_imm8,
		Or_AX_imm16,
		Or_EAX_imm32,
		Or_RAX_imm32,
		Pushw_CS,
		Pushd_CS,
		Popw_CS,
		Adc_rm8_r8,
		Adc_rm16_r16,
		Adc_rm32_r32,
		Adc_rm64_r64,
		Adc_r8_rm8,
		Adc_r16_rm16,
		Adc_r32_rm32,
		Adc_r64_rm64,
		Adc_AL_imm8,
		Adc_AX_imm16,
		Adc_EAX_imm32,
		Adc_RAX_imm32,
		Pushw_SS,
		Pushd_SS,
		Popw_SS,
		Popd_SS,
		Sbb_rm8_r8,
		Sbb_rm16_r16,
		Sbb_rm32_r32,
		Sbb_rm64_r64,
		Sbb_r8_rm8,
		Sbb_r16_rm16,
		Sbb_r32_rm32,
		Sbb_r64_rm64,
		Sbb_AL_imm8,
		Sbb_AX_imm16,
		Sbb_EAX_imm32,
		Sbb_RAX_imm32,
		Pushw_DS,
		Pushd_DS,
		Popw_DS,
		Popd_DS,
		And_rm8_r8,
		And_rm16_r16,
		And_rm32_r32,
		And_rm64_r64,
		And_r8_rm8,
		And_r16_rm16,
		And_r32_rm32,
		And_r64_rm64,
		And_AL_imm8,
		And_AX_imm16,
		And_EAX_imm32,
		And_RAX_imm32,
		Daa,
		Sub_rm8_r8,
		Sub_rm16_r16,
		Sub_rm32_r32,
		Sub_rm64_r64,
		Sub_r8_rm8,
		Sub_r16_rm16,
		Sub_r32_rm32,
		Sub_r64_rm64,
		Sub_AL_imm8,
		Sub_AX_imm16,
		Sub_EAX_imm32,
		Sub_RAX_imm32,
		Das,
		Xor_rm8_r8,
		Xor_rm16_r16,
		Xor_rm32_r32,
		Xor_rm64_r64,
		Xor_r8_rm8,
		Xor_r16_rm16,
		Xor_r32_rm32,
		Xor_r64_rm64,
		Xor_AL_imm8,
		Xor_AX_imm16,
		Xor_EAX_imm32,
		Xor_RAX_imm32,
		Aaa,
		Cmp_rm8_r8,
		Cmp_rm16_r16,
		Cmp_rm32_r32,
		Cmp_rm64_r64,
		Cmp_r8_rm8,
		Cmp_r16_rm16,
		Cmp_r32_rm32,
		Cmp_r64_rm64,
		Cmp_AL_imm8,
		Cmp_AX_imm16,
		Cmp_EAX_imm32,
		Cmp_RAX_imm32,
		Aas,
		Inc_r16,
		Inc_r32,
		Dec_r16,
		Dec_r32,
		Push_r16,
		Push_r32,
		Push_r64,
		Pop_r16,
		Pop_r32,
		Pop_r64,
		Pushaw,
		Pushad,
		Popaw,
		Popad,
		Bound_r16_m1616,
		Bound_r32_m3232,
		Arpl_rm16_r16,
		Arpl_r32m16_r32,
		Movsxd_r16_rm16,
		Movsxd_r32_rm32,
		Movsxd_r64_rm32,
		Push_imm16,
		Pushd_imm32,
		Pushq_imm32,
		Imul_r16_rm16_imm16,
		Imul_r32_rm32_imm32,
		Imul_r64_rm64_imm32,
		Pushw_imm8,
		Pushd_imm8,
		Pushq_imm8,
		Imul_r16_rm16_imm8,
		Imul_r32_rm32_imm8,
		Imul_r64_rm64_imm8,
		Insb_m8_DX,
		Insw_m16_DX,
		Insd_m32_DX,
		Outsb_DX_m8,
		Outsw_DX_m16,
		Outsd_DX_m32,
		Jo_rel8_16,
		Jo_rel8_32,
		Jo_rel8_64,
		Jno_rel8_16,
		Jno_rel8_32,
		Jno_rel8_64,
		Jb_rel8_16,
		Jb_rel8_32,
		Jb_rel8_64,
		Jae_rel8_16,
		Jae_rel8_32,
		Jae_rel8_64,
		Je_rel8_16,
		Je_rel8_32,
		Je_rel8_64,
		Jne_rel8_16,
		Jne_rel8_32,
		Jne_rel8_64,
		Jbe_rel8_16,
		Jbe_rel8_32,
		Jbe_rel8_64,
		Ja_rel8_16,
		Ja_rel8_32,
		Ja_rel8_64,
		Js_rel8_16,
		Js_rel8_32,
		Js_rel8_64,
		Jns_rel8_16,
		Jns_rel8_32,
		Jns_rel8_64,
		Jp_rel8_16,
		Jp_rel8_32,
		Jp_rel8_64,
		Jnp_rel8_16,
		Jnp_rel8_32,
		Jnp_rel8_64,
		Jl_rel8_16,
		Jl_rel8_32,
		Jl_rel8_64,
		Jge_rel8_16,
		Jge_rel8_32,
		Jge_rel8_64,
		Jle_rel8_16,
		Jle_rel8_32,
		Jle_rel8_64,
		Jg_rel8_16,
		Jg_rel8_32,
		Jg_rel8_64,
		Add_rm8_imm8,
		Or_rm8_imm8,
		Adc_rm8_imm8,
		Sbb_rm8_imm8,
		And_rm8_imm8,
		Sub_rm8_imm8,
		Xor_rm8_imm8,
		Cmp_rm8_imm8,
		Add_rm16_imm16,
		Add_rm32_imm32,
		Add_rm64_imm32,
		Or_rm16_imm16,
		Or_rm32_imm32,
		Or_rm64_imm32,
		Adc_rm16_imm16,
		Adc_rm32_imm32,
		Adc_rm64_imm32,
		Sbb_rm16_imm16,
		Sbb_rm32_imm32,
		Sbb_rm64_imm32,
		And_rm16_imm16,
		And_rm32_imm32,
		And_rm64_imm32,
		Sub_rm16_imm16,
		Sub_rm32_imm32,
		Sub_rm64_imm32,
		Xor_rm16_imm16,
		Xor_rm32_imm32,
		Xor_rm64_imm32,
		Cmp_rm16_imm16,
		Cmp_rm32_imm32,
		Cmp_rm64_imm32,
		Add_rm8_imm8_82,
		Or_rm8_imm8_82,
		Adc_rm8_imm8_82,
		Sbb_rm8_imm8_82,
		And_rm8_imm8_82,
		Sub_rm8_imm8_82,
		Xor_rm8_imm8_82,
		Cmp_rm8_imm8_82,
		Add_rm16_imm8,
		Add_rm32_imm8,
		Add_rm64_imm8,
		Or_rm16_imm8,
		Or_rm32_imm8,
		Or_rm64_imm8,
		Adc_rm16_imm8,
		Adc_rm32_imm8,
		Adc_rm64_imm8,
		Sbb_rm16_imm8,
		Sbb_rm32_imm8,
		Sbb_rm64_imm8,
		And_rm16_imm8,
		And_rm32_imm8,
		And_rm64_imm8,
		Sub_rm16_imm8,
		Sub_rm32_imm8,
		Sub_rm64_imm8,
		Xor_rm16_imm8,
		Xor_rm32_imm8,
		Xor_rm64_imm8,
		Cmp_rm16_imm8,
		Cmp_rm32_imm8,
		Cmp_rm64_imm8,
		Test_rm8_r8,
		Test_rm16_r16,
		Test_rm32_r32,
		Test_rm64_r64,
		Xchg_rm8_r8,
		Xchg_rm16_r16,
		Xchg_rm32_r32,
		Xchg_rm64_r64,
		Mov_rm8_r8,
		Mov_rm16_r16,
		Mov_rm32_r32,
		Mov_rm64_r64,
		Mov_r8_rm8,
		Mov_r16_rm16,
		Mov_r32_rm32,
		Mov_r64_rm64,
		Mov_rm16_Sreg,
		Mov_r32m16_Sreg,
		Mov_r64m16_Sreg,
		Lea_r16_m,
		Lea_r32_m,
		Lea_r64_m,
		Mov_Sreg_rm16,
		Mov_Sreg_r32m16,
		Mov_Sreg_r64m16,
		Pop_rm16,
		Pop_rm32,
		Pop_rm64,
		Nopw,
		Nopd,
		Nopq,
		Xchg_r16_AX,
		Xchg_r32_EAX,
		Xchg_r64_RAX,
		Pause,
		Cbw,
		Cwde,
		Cdqe,
		Cwd,
		Cdq,
		Cqo,
		Call_ptr1616,
		Call_ptr1632,
		Wait,
		Pushfw,
		Pushfd,
		Pushfq,
		Popfw,
		Popfd,
		Popfq,
		Sahf,
		Lahf,
		Mov_AL_moffs8,
		Mov_AX_moffs16,
		Mov_EAX_moffs32,
		Mov_RAX_moffs64,
		Mov_moffs8_AL,
		Mov_moffs16_AX,
		Mov_moffs32_EAX,
		Mov_moffs64_RAX,
		Movsb_m8_m8,
		Movsw_m16_m16,
		Movsd_m32_m32,
		Movsq_m64_m64,
		Cmpsb_m8_m8,
		Cmpsw_m16_m16,
		Cmpsd_m32_m32,
		Cmpsq_m64_m64,
		Test_AL_imm8,
		Test_AX_imm16,
		Test_EAX_imm32,
		Test_RAX_imm32,
		Stosb_m8_AL,
		Stosw_m16_AX,
		Stosd_m32_EAX,
		Stosq_m64_RAX,
		Lodsb_AL_m8,
		Lodsw_AX_m16,
		Lodsd_EAX_m32,
		Lodsq_RAX_m64,
		Scasb_AL_m8,
		Scasw_AX_m16,
		Scasd_EAX_m32,
		Scasq_RAX_m64,
		Mov_r8_imm8,
		Mov_r16_imm16,
		Mov_r32_imm32,
		Mov_r64_imm64,
		Rol_rm8_imm8,
		Ror_rm8_imm8,
		Rcl_rm8_imm8,
		Rcr_rm8_imm8,
		Shl_rm8_imm8,
		Shr_rm8_imm8,
		Sal_rm8_imm8,
		Sar_rm8_imm8,
		Rol_rm16_imm8,
		Rol_rm32_imm8,
		Rol_rm64_imm8,
		Ror_rm16_imm8,
		Ror_rm32_imm8,
		Ror_rm64_imm8,
		Rcl_rm16_imm8,
		Rcl_rm32_imm8,
		Rcl_rm64_imm8,
		Rcr_rm16_imm8,
		Rcr_rm32_imm8,
		Rcr_rm64_imm8,
		Shl_rm16_imm8,
		Shl_rm32_imm8,
		Shl_rm64_imm8,
		Shr_rm16_imm8,
		Shr_rm32_imm8,
		Shr_rm64_imm8,
		Sal_rm16_imm8,
		Sal_rm32_imm8,
		Sal_rm64_imm8,
		Sar_rm16_imm8,
		Sar_rm32_imm8,
		Sar_rm64_imm8,
		Retnw_imm16,
		Retnd_imm16,
		Retnq_imm16,
		Retnw,
		Retnd,
		Retnq,
		Les_r16_m1616,
		Les_r32_m1632,
		Lds_r16_m1616,
		Lds_r32_m1632,
		Mov_rm8_imm8,
		Xabort_imm8,
		Mov_rm16_imm16,
		Mov_rm32_imm32,
		Mov_rm64_imm32,
		Xbegin_rel16,
		Xbegin_rel32,
		Enterw_imm16_imm8,
		Enterd_imm16_imm8,
		Enterq_imm16_imm8,
		Leavew,
		Leaved,
		Leaveq,
		Retfw_imm16,
		Retfd_imm16,
		Retfq_imm16,
		Retfw,
		Retfd,
		Retfq,
		Int3,
		Int_imm8,
		Into,
		Iretw,
		Iretd,
		Iretq,
		Rol_rm8_1,
		Ror_rm8_1,
		Rcl_rm8_1,
		Rcr_rm8_1,
		Shl_rm8_1,
		Shr_rm8_1,
		Sal_rm8_1,
		Sar_rm8_1,
		Rol_rm16_1,
		Rol_rm32_1,
		Rol_rm64_1,
		Ror_rm16_1,
		Ror_rm32_1,
		Ror_rm64_1,
		Rcl_rm16_1,
		Rcl_rm32_1,
		Rcl_rm64_1,
		Rcr_rm16_1,
		Rcr_rm32_1,
		Rcr_rm64_1,
		Shl_rm16_1,
		Shl_rm32_1,
		Shl_rm64_1,
		Shr_rm16_1,
		Shr_rm32_1,
		Shr_rm64_1,
		Sal_rm16_1,
		Sal_rm32_1,
		Sal_rm64_1,
		Sar_rm16_1,
		Sar_rm32_1,
		Sar_rm64_1,
		Rol_rm8_CL,
		Ror_rm8_CL,
		Rcl_rm8_CL,
		Rcr_rm8_CL,
		Shl_rm8_CL,
		Shr_rm8_CL,
		Sal_rm8_CL,
		Sar_rm8_CL,
		Rol_rm16_CL,
		Rol_rm32_CL,
		Rol_rm64_CL,
		Ror_rm16_CL,
		Ror_rm32_CL,
		Ror_rm64_CL,
		Rcl_rm16_CL,
		Rcl_rm32_CL,
		Rcl_rm64_CL,
		Rcr_rm16_CL,
		Rcr_rm32_CL,
		Rcr_rm64_CL,
		Shl_rm16_CL,
		Shl_rm32_CL,
		Shl_rm64_CL,
		Shr_rm16_CL,
		Shr_rm32_CL,
		Shr_rm64_CL,
		Sal_rm16_CL,
		Sal_rm32_CL,
		Sal_rm64_CL,
		Sar_rm16_CL,
		Sar_rm32_CL,
		Sar_rm64_CL,
		Aam_imm8,
		Aad_imm8,
		Salc,
		Xlat_m8,
		Fadd_m32fp,
		Fmul_m32fp,
		Fcom_m32fp,
		Fcomp_m32fp,
		Fsub_m32fp,
		Fsubr_m32fp,
		Fdiv_m32fp,
		Fdivr_m32fp,
		Fadd_st0_sti,
		Fmul_st0_sti,
		Fcom_st0_sti,
		Fcomp_st0_sti,
		Fsub_st0_sti,
		Fsubr_st0_sti,
		Fdiv_st0_sti,
		Fdivr_st0_sti,
		Fld_m32fp,
		Fst_m32fp,
		Fstp_m32fp,
		Fldenv_m14byte,
		Fldenv_m28byte,
		Fldcw_m2byte,
		Fnstenv_m14byte,
		Fstenv_m14byte,
		Fnstenv_m28byte,
		Fstenv_m28byte,
		Fnstcw_m2byte,
		Fstcw_m2byte,
		Fld_sti,
		Fxch_st0_sti,
		Fnop,
		Fstpnce_sti,
		Fchs,
		Fabs,
		Ftst,
		Fxam,
		Fld1,
		Fldl2t,
		Fldl2e,
		Fldpi,
		Fldlg2,
		Fldln2,
		Fldz,
		F2xm1,
		Fyl2x,
		Fptan,
		Fpatan,
		Fxtract,
		Fprem1,
		Fdecstp,
		Fincstp,
		Fprem,
		Fyl2xp1,
		Fsqrt,
		Fsincos,
		Frndint,
		Fscale,
		Fsin,
		Fcos,
		Fiadd_m32int,
		Fimul_m32int,
		Ficom_m32int,
		Ficomp_m32int,
		Fisub_m32int,
		Fisubr_m32int,
		Fidiv_m32int,
		Fidivr_m32int,
		Fcmovb_st0_sti,
		Fcmove_st0_sti,
		Fcmovbe_st0_sti,
		Fcmovu_st0_sti,
		Fucompp,
		Fild_m32int,
		Fisttp_m32int,
		Fist_m32int,
		Fistp_m32int,
		Fld_m80fp,
		Fstp_m80fp,
		Fcmovnb_st0_sti,
		Fcmovne_st0_sti,
		Fcmovnbe_st0_sti,
		Fcmovnu_st0_sti,
		Fneni,
		Feni,
		Fndisi,
		Fdisi,
		Fnclex,
		Fclex,
		Fninit,
		Finit,
		Fnsetpm,
		Fsetpm,
		Frstpm,
		Fucomi_st0_sti,
		Fcomi_st0_sti,
		Fadd_m64fp,
		Fmul_m64fp,
		Fcom_m64fp,
		Fcomp_m64fp,
		Fsub_m64fp,
		Fsubr_m64fp,
		Fdiv_m64fp,
		Fdivr_m64fp,
		Fadd_sti_st0,
		Fmul_sti_st0,
		Fcom_st0_sti_DCD0,
		Fcomp_st0_sti_DCD8,
		Fsubr_sti_st0,
		Fsub_sti_st0,
		Fdivr_sti_st0,
		Fdiv_sti_st0,
		Fld_m64fp,
		Fisttp_m64int,
		Fst_m64fp,
		Fstp_m64fp,
		Frstor_m94byte,
		Frstor_m108byte,
		Fnsave_m94byte,
		Fsave_m94byte,
		Fnsave_m108byte,
		Fsave_m108byte,
		Fnstsw_m2byte,
		Fstsw_m2byte,
		Ffree_sti,
		Fxch_st0_sti_DDC8,
		Fst_sti,
		Fstp_sti,
		Fucom_st0_sti,
		Fucomp_st0_sti,
		Fiadd_m16int,
		Fimul_m16int,
		Ficom_m16int,
		Ficomp_m16int,
		Fisub_m16int,
		Fisubr_m16int,
		Fidiv_m16int,
		Fidivr_m16int,
		Faddp_sti_st0,
		Fmulp_sti_st0,
		Fcomp_st0_sti_DED0,
		Fcompp,
		Fsubrp_sti_st0,
		Fsubp_sti_st0,
		Fdivrp_sti_st0,
		Fdivp_sti_st0,
		Fild_m16int,
		Fisttp_m16int,
		Fist_m16int,
		Fistp_m16int,
		Fbld_m80bcd,
		Fild_m64int,
		Fbstp_m80bcd,
		Fistp_m64int,
		Ffreep_sti,
		Fxch_st0_sti_DFC8,
		Fstp_sti_DFD0,
		Fstp_sti_DFD8,
		Fnstsw_AX,
		Fstsw_AX,
		Fstdw_AX,
		Fstsg_AX,
		Fucomip_st0_sti,
		Fcomip_st0_sti,
		Loopne_rel8_16_CX,
		Loopne_rel8_32_CX,
		Loopne_rel8_16_ECX,
		Loopne_rel8_32_ECX,
		Loopne_rel8_64_ECX,
		Loopne_rel8_16_RCX,
		Loopne_rel8_64_RCX,
		Loope_rel8_16_CX,
		Loope_rel8_32_CX,
		Loope_rel8_16_ECX,
		Loope_rel8_32_ECX,
		Loope_rel8_64_ECX,
		Loope_rel8_16_RCX,
		Loope_rel8_64_RCX,
		Loop_rel8_16_CX,
		Loop_rel8_32_CX,
		Loop_rel8_16_ECX,
		Loop_rel8_32_ECX,
		Loop_rel8_64_ECX,
		Loop_rel8_16_RCX,
		Loop_rel8_64_RCX,
		Jcxz_rel8_16,
		Jcxz_rel8_32,
		Jecxz_rel8_16,
		Jecxz_rel8_32,
		Jecxz_rel8_64,
		Jrcxz_rel8_16,
		Jrcxz_rel8_64,
		In_AL_imm8,
		In_AX_imm8,
		In_EAX_imm8,
		Out_imm8_AL,
		Out_imm8_AX,
		Out_imm8_EAX,
		Call_rel16,
		Call_rel32_32,
		Call_rel32_64,
		Jmp_rel16,
		Jmp_rel32_32,
		Jmp_rel32_64,
		Jmp_ptr1616,
		Jmp_ptr1632,
		Jmp_rel8_16,
		Jmp_rel8_32,
		Jmp_rel8_64,
		In_AL_DX,
		In_AX_DX,
		In_EAX_DX,
		Out_DX_AL,
		Out_DX_AX,
		Out_DX_EAX,
		Int1,
		Hlt,
		Cmc,
		Test_rm8_imm8,
		Test_rm8_imm8_F6r1,
		Not_rm8,
		Neg_rm8,
		Mul_rm8,
		Imul_rm8,
		Div_rm8,
		Idiv_rm8,
		Test_rm16_imm16,
		Test_rm32_imm32,
		Test_rm64_imm32,
		Test_rm16_imm16_F7r1,
		Test_rm32_imm32_F7r1,
		Test_rm64_imm32_F7r1,
		Not_rm16,
		Not_rm32,
		Not_rm64,
		Neg_rm16,
		Neg_rm32,
		Neg_rm64,
		Mul_rm16,
		Mul_rm32,
		Mul_rm64,
		Imul_rm16,
		Imul_rm32,
		Imul_rm64,
		Div_rm16,
		Div_rm32,
		Div_rm64,
		Idiv_rm16,
		Idiv_rm32,
		Idiv_rm64,
		Clc,
		Stc,
		Cli,
		Sti,
		Cld,
		Std,
		Inc_rm8,
		Dec_rm8,
		Inc_rm16,
		Inc_rm32,
		Inc_rm64,
		Dec_rm16,
		Dec_rm32,
		Dec_rm64,
		Call_rm16,
		Call_rm32,
		Call_rm64,
		Call_m1616,
		Call_m1632,
		Call_m1664,
		Jmp_rm16,
		Jmp_rm32,
		Jmp_rm64,
		Jmp_m1616,
		Jmp_m1632,
		Jmp_m1664,
		Push_rm16,
		Push_rm32,
		Push_rm64,
		Sldt_rm16,
		Sldt_r32m16,
		Sldt_r64m16,
		Str_rm16,
		Str_r32m16,
		Str_r64m16,
		Lldt_rm16,
		Lldt_r32m16,
		Lldt_r64m16,
		Ltr_rm16,
		Ltr_r32m16,
		Ltr_r64m16,
		Verr_rm16,
		Verr_r32m16,
		Verr_r64m16,
		Verw_rm16,
		Verw_r32m16,
		Verw_r64m16,
		Jmpe_rm16,
		Jmpe_rm32,
		Sgdt_m1632_16,
		Sgdt_m1632,
		Sgdt_m1664,
		Sidt_m1632_16,
		Sidt_m1632,
		Sidt_m1664,
		Lgdt_m1632_16,
		Lgdt_m1632,
		Lgdt_m1664,
		Lidt_m1632_16,
		Lidt_m1632,
		Lidt_m1664,
		Smsw_rm16,
		Smsw_r32m16,
		Smsw_r64m16,
		Rstorssp_m64,
		Lmsw_rm16,
		Lmsw_r32m16,
		Lmsw_r64m16,
		Invlpg_m,
		Enclv,
		Vmcall,
		Vmlaunch,
		Vmresume,
		Vmxoff,
		Pconfig,
		Monitorw,
		Monitord,
		Monitorq,
		Mwait,
		Clac,
		Stac,
		Encls,
		Xgetbv,
		Xsetbv,
		Vmfunc,
		Xend,
		Xtest,
		Enclu,
		Vmrunw,
		Vmrund,
		Vmrunq,
		Vmmcall,
		Vmloadw,
		Vmloadd,
		Vmloadq,
		Vmsavew,
		Vmsaved,
		Vmsaveq,
		Stgi,
		Clgi,
		Skinit,
		Invlpgaw,
		Invlpgad,
		Invlpgaq,
		Setssbsy,
		Saveprevssp,
		Rdpkru,
		Wrpkru,
		Swapgs,
		Rdtscp,
		Monitorxw,
		Monitorxd,
		Monitorxq,
		Mcommit,
		Mwaitx,
		Clzerow,
		Clzerod,
		Clzeroq,
		Rdpru,
		Lar_r16_rm16,
		Lar_r32_r32m16,
		Lar_r64_r64m16,
		Lsl_r16_rm16,
		Lsl_r32_r32m16,
		Lsl_r64_r64m16,
		Storeall,
		Loadall286,
		Syscall,
		Clts,
		Loadall386,
		Sysretd,
		Sysretq,
		Invd,
		Wbinvd,
		Wbnoinvd,
		Cl1invmb,
		Ud2,
		Reservednop_rm16_r16_0F0D,
		Reservednop_rm32_r32_0F0D,
		Reservednop_rm64_r64_0F0D,
		Prefetch_m8,
		Prefetchw_m8,
		Prefetchwt1_m8,
		Femms,
		Umov_rm8_r8,
		Umov_rm16_r16,
		Umov_rm32_r32,
		Umov_r8_rm8,
		Umov_r16_rm16,
		Umov_r32_rm32,
		Movups_xmm_xmmm128,
		VEX_Vmovups_xmm_xmmm128,
		VEX_Vmovups_ymm_ymmm256,
		EVEX_Vmovups_xmm_k1z_xmmm128,
		EVEX_Vmovups_ymm_k1z_ymmm256,
		EVEX_Vmovups_zmm_k1z_zmmm512,
		Movupd_xmm_xmmm128,
		VEX_Vmovupd_xmm_xmmm128,
		VEX_Vmovupd_ymm_ymmm256,
		EVEX_Vmovupd_xmm_k1z_xmmm128,
		EVEX_Vmovupd_ymm_k1z_ymmm256,
		EVEX_Vmovupd_zmm_k1z_zmmm512,
		Movss_xmm_xmmm32,
		VEX_Vmovss_xmm_xmm_xmm,
		VEX_Vmovss_xmm_m32,
		EVEX_Vmovss_xmm_k1z_xmm_xmm,
		EVEX_Vmovss_xmm_k1z_m32,
		Movsd_xmm_xmmm64,
		VEX_Vmovsd_xmm_xmm_xmm,
		VEX_Vmovsd_xmm_m64,
		EVEX_Vmovsd_xmm_k1z_xmm_xmm,
		EVEX_Vmovsd_xmm_k1z_m64,
		Movups_xmmm128_xmm,
		VEX_Vmovups_xmmm128_xmm,
		VEX_Vmovups_ymmm256_ymm,
		EVEX_Vmovups_xmmm128_k1z_xmm,
		EVEX_Vmovups_ymmm256_k1z_ymm,
		EVEX_Vmovups_zmmm512_k1z_zmm,
		Movupd_xmmm128_xmm,
		VEX_Vmovupd_xmmm128_xmm,
		VEX_Vmovupd_ymmm256_ymm,
		EVEX_Vmovupd_xmmm128_k1z_xmm,
		EVEX_Vmovupd_ymmm256_k1z_ymm,
		EVEX_Vmovupd_zmmm512_k1z_zmm,
		Movss_xmmm32_xmm,
		VEX_Vmovss_xmm_xmm_xmm_0F11,
		VEX_Vmovss_m32_xmm,
		EVEX_Vmovss_xmm_k1z_xmm_xmm_0F11,
		EVEX_Vmovss_m32_k1_xmm,
		Movsd_xmmm64_xmm,
		VEX_Vmovsd_xmm_xmm_xmm_0F11,
		VEX_Vmovsd_m64_xmm,
		EVEX_Vmovsd_xmm_k1z_xmm_xmm_0F11,
		EVEX_Vmovsd_m64_k1_xmm,
		Movhlps_xmm_xmm,
		Movlps_xmm_m64,
		VEX_Vmovhlps_xmm_xmm_xmm,
		VEX_Vmovlps_xmm_xmm_m64,
		EVEX_Vmovhlps_xmm_xmm_xmm,
		EVEX_Vmovlps_xmm_xmm_m64,
		Movlpd_xmm_m64,
		VEX_Vmovlpd_xmm_xmm_m64,
		EVEX_Vmovlpd_xmm_xmm_m64,
		Movsldup_xmm_xmmm128,
		VEX_Vmovsldup_xmm_xmmm128,
		VEX_Vmovsldup_ymm_ymmm256,
		EVEX_Vmovsldup_xmm_k1z_xmmm128,
		EVEX_Vmovsldup_ymm_k1z_ymmm256,
		EVEX_Vmovsldup_zmm_k1z_zmmm512,
		Movddup_xmm_xmmm64,
		VEX_Vmovddup_xmm_xmmm64,
		VEX_Vmovddup_ymm_ymmm256,
		EVEX_Vmovddup_xmm_k1z_xmmm64,
		EVEX_Vmovddup_ymm_k1z_ymmm256,
		EVEX_Vmovddup_zmm_k1z_zmmm512,
		Movlps_m64_xmm,
		VEX_Vmovlps_m64_xmm,
		EVEX_Vmovlps_m64_xmm,
		Movlpd_m64_xmm,
		VEX_Vmovlpd_m64_xmm,
		EVEX_Vmovlpd_m64_xmm,
		Unpcklps_xmm_xmmm128,
		VEX_Vunpcklps_xmm_xmm_xmmm128,
		VEX_Vunpcklps_ymm_ymm_ymmm256,
		EVEX_Vunpcklps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vunpcklps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vunpcklps_zmm_k1z_zmm_zmmm512b32,
		Unpcklpd_xmm_xmmm128,
		VEX_Vunpcklpd_xmm_xmm_xmmm128,
		VEX_Vunpcklpd_ymm_ymm_ymmm256,
		EVEX_Vunpcklpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vunpcklpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vunpcklpd_zmm_k1z_zmm_zmmm512b64,
		Unpckhps_xmm_xmmm128,
		VEX_Vunpckhps_xmm_xmm_xmmm128,
		VEX_Vunpckhps_ymm_ymm_ymmm256,
		EVEX_Vunpckhps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vunpckhps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vunpckhps_zmm_k1z_zmm_zmmm512b32,
		Unpckhpd_xmm_xmmm128,
		VEX_Vunpckhpd_xmm_xmm_xmmm128,
		VEX_Vunpckhpd_ymm_ymm_ymmm256,
		EVEX_Vunpckhpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vunpckhpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vunpckhpd_zmm_k1z_zmm_zmmm512b64,
		Movlhps_xmm_xmm,
		VEX_Vmovlhps_xmm_xmm_xmm,
		EVEX_Vmovlhps_xmm_xmm_xmm,
		Movhps_xmm_m64,
		VEX_Vmovhps_xmm_xmm_m64,
		EVEX_Vmovhps_xmm_xmm_m64,
		Movhpd_xmm_m64,
		VEX_Vmovhpd_xmm_xmm_m64,
		EVEX_Vmovhpd_xmm_xmm_m64,
		Movshdup_xmm_xmmm128,
		VEX_Vmovshdup_xmm_xmmm128,
		VEX_Vmovshdup_ymm_ymmm256,
		EVEX_Vmovshdup_xmm_k1z_xmmm128,
		EVEX_Vmovshdup_ymm_k1z_ymmm256,
		EVEX_Vmovshdup_zmm_k1z_zmmm512,
		Movhps_m64_xmm,
		VEX_Vmovhps_m64_xmm,
		EVEX_Vmovhps_m64_xmm,
		Movhpd_m64_xmm,
		VEX_Vmovhpd_m64_xmm,
		EVEX_Vmovhpd_m64_xmm,
		Reservednop_rm16_r16_0F18,
		Reservednop_rm32_r32_0F18,
		Reservednop_rm64_r64_0F18,
		Reservednop_rm16_r16_0F19,
		Reservednop_rm32_r32_0F19,
		Reservednop_rm64_r64_0F19,
		Reservednop_rm16_r16_0F1A,
		Reservednop_rm32_r32_0F1A,
		Reservednop_rm64_r64_0F1A,
		Reservednop_rm16_r16_0F1B,
		Reservednop_rm32_r32_0F1B,
		Reservednop_rm64_r64_0F1B,
		Reservednop_rm16_r16_0F1C,
		Reservednop_rm32_r32_0F1C,
		Reservednop_rm64_r64_0F1C,
		Reservednop_rm16_r16_0F1D,
		Reservednop_rm32_r32_0F1D,
		Reservednop_rm64_r64_0F1D,
		Reservednop_rm16_r16_0F1E,
		Reservednop_rm32_r32_0F1E,
		Reservednop_rm64_r64_0F1E,
		Reservednop_rm16_r16_0F1F,
		Reservednop_rm32_r32_0F1F,
		Reservednop_rm64_r64_0F1F,
		Prefetchnta_m8,
		Prefetcht0_m8,
		Prefetcht1_m8,
		Prefetcht2_m8,
		Bndldx_bnd_mib,
		Bndmov_bnd_bndm64,
		Bndmov_bnd_bndm128,
		Bndcl_bnd_rm32,
		Bndcl_bnd_rm64,
		Bndcu_bnd_rm32,
		Bndcu_bnd_rm64,
		Bndstx_mib_bnd,
		Bndmov_bndm64_bnd,
		Bndmov_bndm128_bnd,
		Bndmk_bnd_m32,
		Bndmk_bnd_m64,
		Bndcn_bnd_rm32,
		Bndcn_bnd_rm64,
		Cldemote_m8,
		Rdsspd_r32,
		Rdsspq_r64,
		Endbr64,
		Endbr32,
		Nop_rm16,
		Nop_rm32,
		Nop_rm64,
		Mov_r32_cr,
		Mov_r64_cr,
		Mov_r32_dr,
		Mov_r64_dr,
		Mov_cr_r32,
		Mov_cr_r64,
		Mov_dr_r32,
		Mov_dr_r64,
		Mov_r32_tr,
		Mov_tr_r32,
		Movaps_xmm_xmmm128,
		VEX_Vmovaps_xmm_xmmm128,
		VEX_Vmovaps_ymm_ymmm256,
		EVEX_Vmovaps_xmm_k1z_xmmm128,
		EVEX_Vmovaps_ymm_k1z_ymmm256,
		EVEX_Vmovaps_zmm_k1z_zmmm512,
		Movapd_xmm_xmmm128,
		VEX_Vmovapd_xmm_xmmm128,
		VEX_Vmovapd_ymm_ymmm256,
		EVEX_Vmovapd_xmm_k1z_xmmm128,
		EVEX_Vmovapd_ymm_k1z_ymmm256,
		EVEX_Vmovapd_zmm_k1z_zmmm512,
		Movaps_xmmm128_xmm,
		VEX_Vmovaps_xmmm128_xmm,
		VEX_Vmovaps_ymmm256_ymm,
		EVEX_Vmovaps_xmmm128_k1z_xmm,
		EVEX_Vmovaps_ymmm256_k1z_ymm,
		EVEX_Vmovaps_zmmm512_k1z_zmm,
		Movapd_xmmm128_xmm,
		VEX_Vmovapd_xmmm128_xmm,
		VEX_Vmovapd_ymmm256_ymm,
		EVEX_Vmovapd_xmmm128_k1z_xmm,
		EVEX_Vmovapd_ymmm256_k1z_ymm,
		EVEX_Vmovapd_zmmm512_k1z_zmm,
		Cvtpi2ps_xmm_mmm64,
		Cvtpi2pd_xmm_mmm64,
		Cvtsi2ss_xmm_rm32,
		Cvtsi2ss_xmm_rm64,
		VEX_Vcvtsi2ss_xmm_xmm_rm32,
		VEX_Vcvtsi2ss_xmm_xmm_rm64,
		EVEX_Vcvtsi2ss_xmm_xmm_rm32_er,
		EVEX_Vcvtsi2ss_xmm_xmm_rm64_er,
		Cvtsi2sd_xmm_rm32,
		Cvtsi2sd_xmm_rm64,
		VEX_Vcvtsi2sd_xmm_xmm_rm32,
		VEX_Vcvtsi2sd_xmm_xmm_rm64,
		EVEX_Vcvtsi2sd_xmm_xmm_rm32_er,
		EVEX_Vcvtsi2sd_xmm_xmm_rm64_er,
		Movntps_m128_xmm,
		VEX_Vmovntps_m128_xmm,
		VEX_Vmovntps_m256_ymm,
		EVEX_Vmovntps_m128_xmm,
		EVEX_Vmovntps_m256_ymm,
		EVEX_Vmovntps_m512_zmm,
		Movntpd_m128_xmm,
		VEX_Vmovntpd_m128_xmm,
		VEX_Vmovntpd_m256_ymm,
		EVEX_Vmovntpd_m128_xmm,
		EVEX_Vmovntpd_m256_ymm,
		EVEX_Vmovntpd_m512_zmm,
		Movntss_m32_xmm,
		Movntsd_m64_xmm,
		Cvttps2pi_mm_xmmm64,
		Cvttpd2pi_mm_xmmm128,
		Cvttss2si_r32_xmmm32,
		Cvttss2si_r64_xmmm32,
		VEX_Vcvttss2si_r32_xmmm32,
		VEX_Vcvttss2si_r64_xmmm32,
		EVEX_Vcvttss2si_r32_xmmm32_sae,
		EVEX_Vcvttss2si_r64_xmmm32_sae,
		Cvttsd2si_r32_xmmm64,
		Cvttsd2si_r64_xmmm64,
		VEX_Vcvttsd2si_r32_xmmm64,
		VEX_Vcvttsd2si_r64_xmmm64,
		EVEX_Vcvttsd2si_r32_xmmm64_sae,
		EVEX_Vcvttsd2si_r64_xmmm64_sae,
		Cvtps2pi_mm_xmmm64,
		Cvtpd2pi_mm_xmmm128,
		Cvtss2si_r32_xmmm32,
		Cvtss2si_r64_xmmm32,
		VEX_Vcvtss2si_r32_xmmm32,
		VEX_Vcvtss2si_r64_xmmm32,
		EVEX_Vcvtss2si_r32_xmmm32_er,
		EVEX_Vcvtss2si_r64_xmmm32_er,
		Cvtsd2si_r32_xmmm64,
		Cvtsd2si_r64_xmmm64,
		VEX_Vcvtsd2si_r32_xmmm64,
		VEX_Vcvtsd2si_r64_xmmm64,
		EVEX_Vcvtsd2si_r32_xmmm64_er,
		EVEX_Vcvtsd2si_r64_xmmm64_er,
		Ucomiss_xmm_xmmm32,
		VEX_Vucomiss_xmm_xmmm32,
		EVEX_Vucomiss_xmm_xmmm32_sae,
		Ucomisd_xmm_xmmm64,
		VEX_Vucomisd_xmm_xmmm64,
		EVEX_Vucomisd_xmm_xmmm64_sae,
		Comiss_xmm_xmmm32,
		Comisd_xmm_xmmm64,
		VEX_Vcomiss_xmm_xmmm32,
		VEX_Vcomisd_xmm_xmmm64,
		EVEX_Vcomiss_xmm_xmmm32_sae,
		EVEX_Vcomisd_xmm_xmmm64_sae,
		Wrmsr,
		Rdtsc,
		Rdmsr,
		Rdpmc,
		Sysenter,
		Sysexitd,
		Sysexitq,
		Getsecd,
		Cmovo_r16_rm16,
		Cmovo_r32_rm32,
		Cmovo_r64_rm64,
		Cmovno_r16_rm16,
		Cmovno_r32_rm32,
		Cmovno_r64_rm64,
		Cmovb_r16_rm16,
		Cmovb_r32_rm32,
		Cmovb_r64_rm64,
		Cmovae_r16_rm16,
		Cmovae_r32_rm32,
		Cmovae_r64_rm64,
		Cmove_r16_rm16,
		Cmove_r32_rm32,
		Cmove_r64_rm64,
		Cmovne_r16_rm16,
		Cmovne_r32_rm32,
		Cmovne_r64_rm64,
		Cmovbe_r16_rm16,
		Cmovbe_r32_rm32,
		Cmovbe_r64_rm64,
		Cmova_r16_rm16,
		Cmova_r32_rm32,
		Cmova_r64_rm64,
		Cmovs_r16_rm16,
		Cmovs_r32_rm32,
		Cmovs_r64_rm64,
		Cmovns_r16_rm16,
		Cmovns_r32_rm32,
		Cmovns_r64_rm64,
		Cmovp_r16_rm16,
		Cmovp_r32_rm32,
		Cmovp_r64_rm64,
		Cmovnp_r16_rm16,
		Cmovnp_r32_rm32,
		Cmovnp_r64_rm64,
		Cmovl_r16_rm16,
		Cmovl_r32_rm32,
		Cmovl_r64_rm64,
		Cmovge_r16_rm16,
		Cmovge_r32_rm32,
		Cmovge_r64_rm64,
		Cmovle_r16_rm16,
		Cmovle_r32_rm32,
		Cmovle_r64_rm64,
		Cmovg_r16_rm16,
		Cmovg_r32_rm32,
		Cmovg_r64_rm64,
		VEX_Kandw_kr_kr_kr,
		VEX_Kandq_kr_kr_kr,
		VEX_Kandb_kr_kr_kr,
		VEX_Kandd_kr_kr_kr,
		VEX_Kandnw_kr_kr_kr,
		VEX_Kandnq_kr_kr_kr,
		VEX_Kandnb_kr_kr_kr,
		VEX_Kandnd_kr_kr_kr,
		VEX_Knotw_kr_kr,
		VEX_Knotq_kr_kr,
		VEX_Knotb_kr_kr,
		VEX_Knotd_kr_kr,
		VEX_Korw_kr_kr_kr,
		VEX_Korq_kr_kr_kr,
		VEX_Korb_kr_kr_kr,
		VEX_Kord_kr_kr_kr,
		VEX_Kxnorw_kr_kr_kr,
		VEX_Kxnorq_kr_kr_kr,
		VEX_Kxnorb_kr_kr_kr,
		VEX_Kxnord_kr_kr_kr,
		VEX_Kxorw_kr_kr_kr,
		VEX_Kxorq_kr_kr_kr,
		VEX_Kxorb_kr_kr_kr,
		VEX_Kxord_kr_kr_kr,
		VEX_Kaddw_kr_kr_kr,
		VEX_Kaddq_kr_kr_kr,
		VEX_Kaddb_kr_kr_kr,
		VEX_Kaddd_kr_kr_kr,
		VEX_Kunpckwd_kr_kr_kr,
		VEX_Kunpckdq_kr_kr_kr,
		VEX_Kunpckbw_kr_kr_kr,
		Movmskps_r32_xmm,
		Movmskps_r64_xmm,
		VEX_Vmovmskps_r32_xmm,
		VEX_Vmovmskps_r64_xmm,
		VEX_Vmovmskps_r32_ymm,
		VEX_Vmovmskps_r64_ymm,
		Movmskpd_r32_xmm,
		Movmskpd_r64_xmm,
		VEX_Vmovmskpd_r32_xmm,
		VEX_Vmovmskpd_r64_xmm,
		VEX_Vmovmskpd_r32_ymm,
		VEX_Vmovmskpd_r64_ymm,
		Sqrtps_xmm_xmmm128,
		VEX_Vsqrtps_xmm_xmmm128,
		VEX_Vsqrtps_ymm_ymmm256,
		EVEX_Vsqrtps_xmm_k1z_xmmm128b32,
		EVEX_Vsqrtps_ymm_k1z_ymmm256b32,
		EVEX_Vsqrtps_zmm_k1z_zmmm512b32_er,
		Sqrtpd_xmm_xmmm128,
		VEX_Vsqrtpd_xmm_xmmm128,
		VEX_Vsqrtpd_ymm_ymmm256,
		EVEX_Vsqrtpd_xmm_k1z_xmmm128b64,
		EVEX_Vsqrtpd_ymm_k1z_ymmm256b64,
		EVEX_Vsqrtpd_zmm_k1z_zmmm512b64_er,
		Sqrtss_xmm_xmmm32,
		VEX_Vsqrtss_xmm_xmm_xmmm32,
		EVEX_Vsqrtss_xmm_k1z_xmm_xmmm32_er,
		Sqrtsd_xmm_xmmm64,
		VEX_Vsqrtsd_xmm_xmm_xmmm64,
		EVEX_Vsqrtsd_xmm_k1z_xmm_xmmm64_er,
		Rsqrtps_xmm_xmmm128,
		VEX_Vrsqrtps_xmm_xmmm128,
		VEX_Vrsqrtps_ymm_ymmm256,
		Rsqrtss_xmm_xmmm32,
		VEX_Vrsqrtss_xmm_xmm_xmmm32,
		Rcpps_xmm_xmmm128,
		VEX_Vrcpps_xmm_xmmm128,
		VEX_Vrcpps_ymm_ymmm256,
		Rcpss_xmm_xmmm32,
		VEX_Vrcpss_xmm_xmm_xmmm32,
		Andps_xmm_xmmm128,
		VEX_Vandps_xmm_xmm_xmmm128,
		VEX_Vandps_ymm_ymm_ymmm256,
		EVEX_Vandps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vandps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vandps_zmm_k1z_zmm_zmmm512b32,
		Andpd_xmm_xmmm128,
		VEX_Vandpd_xmm_xmm_xmmm128,
		VEX_Vandpd_ymm_ymm_ymmm256,
		EVEX_Vandpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vandpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vandpd_zmm_k1z_zmm_zmmm512b64,
		Andnps_xmm_xmmm128,
		VEX_Vandnps_xmm_xmm_xmmm128,
		VEX_Vandnps_ymm_ymm_ymmm256,
		EVEX_Vandnps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vandnps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vandnps_zmm_k1z_zmm_zmmm512b32,
		Andnpd_xmm_xmmm128,
		VEX_Vandnpd_xmm_xmm_xmmm128,
		VEX_Vandnpd_ymm_ymm_ymmm256,
		EVEX_Vandnpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vandnpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vandnpd_zmm_k1z_zmm_zmmm512b64,
		Orps_xmm_xmmm128,
		VEX_Vorps_xmm_xmm_xmmm128,
		VEX_Vorps_ymm_ymm_ymmm256,
		EVEX_Vorps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vorps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vorps_zmm_k1z_zmm_zmmm512b32,
		Orpd_xmm_xmmm128,
		VEX_Vorpd_xmm_xmm_xmmm128,
		VEX_Vorpd_ymm_ymm_ymmm256,
		EVEX_Vorpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vorpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vorpd_zmm_k1z_zmm_zmmm512b64,
		Xorps_xmm_xmmm128,
		VEX_Vxorps_xmm_xmm_xmmm128,
		VEX_Vxorps_ymm_ymm_ymmm256,
		EVEX_Vxorps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vxorps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vxorps_zmm_k1z_zmm_zmmm512b32,
		Xorpd_xmm_xmmm128,
		VEX_Vxorpd_xmm_xmm_xmmm128,
		VEX_Vxorpd_ymm_ymm_ymmm256,
		EVEX_Vxorpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vxorpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vxorpd_zmm_k1z_zmm_zmmm512b64,
		Addps_xmm_xmmm128,
		VEX_Vaddps_xmm_xmm_xmmm128,
		VEX_Vaddps_ymm_ymm_ymmm256,
		EVEX_Vaddps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vaddps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vaddps_zmm_k1z_zmm_zmmm512b32_er,
		Addpd_xmm_xmmm128,
		VEX_Vaddpd_xmm_xmm_xmmm128,
		VEX_Vaddpd_ymm_ymm_ymmm256,
		EVEX_Vaddpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vaddpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vaddpd_zmm_k1z_zmm_zmmm512b64_er,
		Addss_xmm_xmmm32,
		VEX_Vaddss_xmm_xmm_xmmm32,
		EVEX_Vaddss_xmm_k1z_xmm_xmmm32_er,
		Addsd_xmm_xmmm64,
		VEX_Vaddsd_xmm_xmm_xmmm64,
		EVEX_Vaddsd_xmm_k1z_xmm_xmmm64_er,
		Mulps_xmm_xmmm128,
		VEX_Vmulps_xmm_xmm_xmmm128,
		VEX_Vmulps_ymm_ymm_ymmm256,
		EVEX_Vmulps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vmulps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vmulps_zmm_k1z_zmm_zmmm512b32_er,
		Mulpd_xmm_xmmm128,
		VEX_Vmulpd_xmm_xmm_xmmm128,
		VEX_Vmulpd_ymm_ymm_ymmm256,
		EVEX_Vmulpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vmulpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vmulpd_zmm_k1z_zmm_zmmm512b64_er,
		Mulss_xmm_xmmm32,
		VEX_Vmulss_xmm_xmm_xmmm32,
		EVEX_Vmulss_xmm_k1z_xmm_xmmm32_er,
		Mulsd_xmm_xmmm64,
		VEX_Vmulsd_xmm_xmm_xmmm64,
		EVEX_Vmulsd_xmm_k1z_xmm_xmmm64_er,
		Cvtps2pd_xmm_xmmm64,
		VEX_Vcvtps2pd_xmm_xmmm64,
		VEX_Vcvtps2pd_ymm_xmmm128,
		EVEX_Vcvtps2pd_xmm_k1z_xmmm64b32,
		EVEX_Vcvtps2pd_ymm_k1z_xmmm128b32,
		EVEX_Vcvtps2pd_zmm_k1z_ymmm256b32_sae,
		Cvtpd2ps_xmm_xmmm128,
		VEX_Vcvtpd2ps_xmm_xmmm128,
		VEX_Vcvtpd2ps_xmm_ymmm256,
		EVEX_Vcvtpd2ps_xmm_k1z_xmmm128b64,
		EVEX_Vcvtpd2ps_xmm_k1z_ymmm256b64,
		EVEX_Vcvtpd2ps_ymm_k1z_zmmm512b64_er,
		Cvtss2sd_xmm_xmmm32,
		VEX_Vcvtss2sd_xmm_xmm_xmmm32,
		EVEX_Vcvtss2sd_xmm_k1z_xmm_xmmm32_sae,
		Cvtsd2ss_xmm_xmmm64,
		VEX_Vcvtsd2ss_xmm_xmm_xmmm64,
		EVEX_Vcvtsd2ss_xmm_k1z_xmm_xmmm64_er,
		Cvtdq2ps_xmm_xmmm128,
		VEX_Vcvtdq2ps_xmm_xmmm128,
		VEX_Vcvtdq2ps_ymm_ymmm256,
		EVEX_Vcvtdq2ps_xmm_k1z_xmmm128b32,
		EVEX_Vcvtdq2ps_ymm_k1z_ymmm256b32,
		EVEX_Vcvtdq2ps_zmm_k1z_zmmm512b32_er,
		EVEX_Vcvtqq2ps_xmm_k1z_xmmm128b64,
		EVEX_Vcvtqq2ps_xmm_k1z_ymmm256b64,
		EVEX_Vcvtqq2ps_ymm_k1z_zmmm512b64_er,
		Cvtps2dq_xmm_xmmm128,
		VEX_Vcvtps2dq_xmm_xmmm128,
		VEX_Vcvtps2dq_ymm_ymmm256,
		EVEX_Vcvtps2dq_xmm_k1z_xmmm128b32,
		EVEX_Vcvtps2dq_ymm_k1z_ymmm256b32,
		EVEX_Vcvtps2dq_zmm_k1z_zmmm512b32_er,
		Cvttps2dq_xmm_xmmm128,
		VEX_Vcvttps2dq_xmm_xmmm128,
		VEX_Vcvttps2dq_ymm_ymmm256,
		EVEX_Vcvttps2dq_xmm_k1z_xmmm128b32,
		EVEX_Vcvttps2dq_ymm_k1z_ymmm256b32,
		EVEX_Vcvttps2dq_zmm_k1z_zmmm512b32_sae,
		Subps_xmm_xmmm128,
		VEX_Vsubps_xmm_xmm_xmmm128,
		VEX_Vsubps_ymm_ymm_ymmm256,
		EVEX_Vsubps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vsubps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vsubps_zmm_k1z_zmm_zmmm512b32_er,
		Subpd_xmm_xmmm128,
		VEX_Vsubpd_xmm_xmm_xmmm128,
		VEX_Vsubpd_ymm_ymm_ymmm256,
		EVEX_Vsubpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vsubpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vsubpd_zmm_k1z_zmm_zmmm512b64_er,
		Subss_xmm_xmmm32,
		VEX_Vsubss_xmm_xmm_xmmm32,
		EVEX_Vsubss_xmm_k1z_xmm_xmmm32_er,
		Subsd_xmm_xmmm64,
		VEX_Vsubsd_xmm_xmm_xmmm64,
		EVEX_Vsubsd_xmm_k1z_xmm_xmmm64_er,
		Minps_xmm_xmmm128,
		VEX_Vminps_xmm_xmm_xmmm128,
		VEX_Vminps_ymm_ymm_ymmm256,
		EVEX_Vminps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vminps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vminps_zmm_k1z_zmm_zmmm512b32_sae,
		Minpd_xmm_xmmm128,
		VEX_Vminpd_xmm_xmm_xmmm128,
		VEX_Vminpd_ymm_ymm_ymmm256,
		EVEX_Vminpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vminpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vminpd_zmm_k1z_zmm_zmmm512b64_sae,
		Minss_xmm_xmmm32,
		VEX_Vminss_xmm_xmm_xmmm32,
		EVEX_Vminss_xmm_k1z_xmm_xmmm32_sae,
		Minsd_xmm_xmmm64,
		VEX_Vminsd_xmm_xmm_xmmm64,
		EVEX_Vminsd_xmm_k1z_xmm_xmmm64_sae,
		Divps_xmm_xmmm128,
		VEX_Vdivps_xmm_xmm_xmmm128,
		VEX_Vdivps_ymm_ymm_ymmm256,
		EVEX_Vdivps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vdivps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vdivps_zmm_k1z_zmm_zmmm512b32_er,
		Divpd_xmm_xmmm128,
		VEX_Vdivpd_xmm_xmm_xmmm128,
		VEX_Vdivpd_ymm_ymm_ymmm256,
		EVEX_Vdivpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vdivpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vdivpd_zmm_k1z_zmm_zmmm512b64_er,
		Divss_xmm_xmmm32,
		VEX_Vdivss_xmm_xmm_xmmm32,
		EVEX_Vdivss_xmm_k1z_xmm_xmmm32_er,
		Divsd_xmm_xmmm64,
		VEX_Vdivsd_xmm_xmm_xmmm64,
		EVEX_Vdivsd_xmm_k1z_xmm_xmmm64_er,
		Maxps_xmm_xmmm128,
		VEX_Vmaxps_xmm_xmm_xmmm128,
		VEX_Vmaxps_ymm_ymm_ymmm256,
		EVEX_Vmaxps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vmaxps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vmaxps_zmm_k1z_zmm_zmmm512b32_sae,
		Maxpd_xmm_xmmm128,
		VEX_Vmaxpd_xmm_xmm_xmmm128,
		VEX_Vmaxpd_ymm_ymm_ymmm256,
		EVEX_Vmaxpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vmaxpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vmaxpd_zmm_k1z_zmm_zmmm512b64_sae,
		Maxss_xmm_xmmm32,
		VEX_Vmaxss_xmm_xmm_xmmm32,
		EVEX_Vmaxss_xmm_k1z_xmm_xmmm32_sae,
		Maxsd_xmm_xmmm64,
		VEX_Vmaxsd_xmm_xmm_xmmm64,
		EVEX_Vmaxsd_xmm_k1z_xmm_xmmm64_sae,
		Punpcklbw_mm_mmm32,
		Punpcklbw_xmm_xmmm128,
		VEX_Vpunpcklbw_xmm_xmm_xmmm128,
		VEX_Vpunpcklbw_ymm_ymm_ymmm256,
		EVEX_Vpunpcklbw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpunpcklbw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpunpcklbw_zmm_k1z_zmm_zmmm512,
		Punpcklwd_mm_mmm32,
		Punpcklwd_xmm_xmmm128,
		VEX_Vpunpcklwd_xmm_xmm_xmmm128,
		VEX_Vpunpcklwd_ymm_ymm_ymmm256,
		EVEX_Vpunpcklwd_xmm_k1z_xmm_xmmm128,
		EVEX_Vpunpcklwd_ymm_k1z_ymm_ymmm256,
		EVEX_Vpunpcklwd_zmm_k1z_zmm_zmmm512,
		Punpckldq_mm_mmm32,
		Punpckldq_xmm_xmmm128,
		VEX_Vpunpckldq_xmm_xmm_xmmm128,
		VEX_Vpunpckldq_ymm_ymm_ymmm256,
		EVEX_Vpunpckldq_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpunpckldq_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpunpckldq_zmm_k1z_zmm_zmmm512b32,
		Packsswb_mm_mmm64,
		Packsswb_xmm_xmmm128,
		VEX_Vpacksswb_xmm_xmm_xmmm128,
		VEX_Vpacksswb_ymm_ymm_ymmm256,
		EVEX_Vpacksswb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpacksswb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpacksswb_zmm_k1z_zmm_zmmm512,
		Pcmpgtb_mm_mmm64,
		Pcmpgtb_xmm_xmmm128,
		VEX_Vpcmpgtb_xmm_xmm_xmmm128,
		VEX_Vpcmpgtb_ymm_ymm_ymmm256,
		EVEX_Vpcmpgtb_kr_k1_xmm_xmmm128,
		EVEX_Vpcmpgtb_kr_k1_ymm_ymmm256,
		EVEX_Vpcmpgtb_kr_k1_zmm_zmmm512,
		Pcmpgtw_mm_mmm64,
		Pcmpgtw_xmm_xmmm128,
		VEX_Vpcmpgtw_xmm_xmm_xmmm128,
		VEX_Vpcmpgtw_ymm_ymm_ymmm256,
		EVEX_Vpcmpgtw_kr_k1_xmm_xmmm128,
		EVEX_Vpcmpgtw_kr_k1_ymm_ymmm256,
		EVEX_Vpcmpgtw_kr_k1_zmm_zmmm512,
		Pcmpgtd_mm_mmm64,
		Pcmpgtd_xmm_xmmm128,
		VEX_Vpcmpgtd_xmm_xmm_xmmm128,
		VEX_Vpcmpgtd_ymm_ymm_ymmm256,
		EVEX_Vpcmpgtd_kr_k1_xmm_xmmm128b32,
		EVEX_Vpcmpgtd_kr_k1_ymm_ymmm256b32,
		EVEX_Vpcmpgtd_kr_k1_zmm_zmmm512b32,
		Packuswb_mm_mmm64,
		Packuswb_xmm_xmmm128,
		VEX_Vpackuswb_xmm_xmm_xmmm128,
		VEX_Vpackuswb_ymm_ymm_ymmm256,
		EVEX_Vpackuswb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpackuswb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpackuswb_zmm_k1z_zmm_zmmm512,
		Punpckhbw_mm_mmm64,
		Punpckhbw_xmm_xmmm128,
		VEX_Vpunpckhbw_xmm_xmm_xmmm128,
		VEX_Vpunpckhbw_ymm_ymm_ymmm256,
		EVEX_Vpunpckhbw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpunpckhbw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpunpckhbw_zmm_k1z_zmm_zmmm512,
		Punpckhwd_mm_mmm64,
		Punpckhwd_xmm_xmmm128,
		VEX_Vpunpckhwd_xmm_xmm_xmmm128,
		VEX_Vpunpckhwd_ymm_ymm_ymmm256,
		EVEX_Vpunpckhwd_xmm_k1z_xmm_xmmm128,
		EVEX_Vpunpckhwd_ymm_k1z_ymm_ymmm256,
		EVEX_Vpunpckhwd_zmm_k1z_zmm_zmmm512,
		Punpckhdq_mm_mmm64,
		Punpckhdq_xmm_xmmm128,
		VEX_Vpunpckhdq_xmm_xmm_xmmm128,
		VEX_Vpunpckhdq_ymm_ymm_ymmm256,
		EVEX_Vpunpckhdq_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpunpckhdq_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpunpckhdq_zmm_k1z_zmm_zmmm512b32,
		Packssdw_mm_mmm64,
		Packssdw_xmm_xmmm128,
		VEX_Vpackssdw_xmm_xmm_xmmm128,
		VEX_Vpackssdw_ymm_ymm_ymmm256,
		EVEX_Vpackssdw_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpackssdw_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpackssdw_zmm_k1z_zmm_zmmm512b32,
		Punpcklqdq_xmm_xmmm128,
		VEX_Vpunpcklqdq_xmm_xmm_xmmm128,
		VEX_Vpunpcklqdq_ymm_ymm_ymmm256,
		EVEX_Vpunpcklqdq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpunpcklqdq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpunpcklqdq_zmm_k1z_zmm_zmmm512b64,
		Punpckhqdq_xmm_xmmm128,
		VEX_Vpunpckhqdq_xmm_xmm_xmmm128,
		VEX_Vpunpckhqdq_ymm_ymm_ymmm256,
		EVEX_Vpunpckhqdq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpunpckhqdq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpunpckhqdq_zmm_k1z_zmm_zmmm512b64,
		Movd_mm_rm32,
		Movq_mm_rm64,
		Movd_xmm_rm32,
		Movq_xmm_rm64,
		VEX_Vmovd_xmm_rm32,
		VEX_Vmovq_xmm_rm64,
		EVEX_Vmovd_xmm_rm32,
		EVEX_Vmovq_xmm_rm64,
		Movq_mm_mmm64,
		Movdqa_xmm_xmmm128,
		VEX_Vmovdqa_xmm_xmmm128,
		VEX_Vmovdqa_ymm_ymmm256,
		EVEX_Vmovdqa32_xmm_k1z_xmmm128,
		EVEX_Vmovdqa32_ymm_k1z_ymmm256,
		EVEX_Vmovdqa32_zmm_k1z_zmmm512,
		EVEX_Vmovdqa64_xmm_k1z_xmmm128,
		EVEX_Vmovdqa64_ymm_k1z_ymmm256,
		EVEX_Vmovdqa64_zmm_k1z_zmmm512,
		Movdqu_xmm_xmmm128,
		VEX_Vmovdqu_xmm_xmmm128,
		VEX_Vmovdqu_ymm_ymmm256,
		EVEX_Vmovdqu32_xmm_k1z_xmmm128,
		EVEX_Vmovdqu32_ymm_k1z_ymmm256,
		EVEX_Vmovdqu32_zmm_k1z_zmmm512,
		EVEX_Vmovdqu64_xmm_k1z_xmmm128,
		EVEX_Vmovdqu64_ymm_k1z_ymmm256,
		EVEX_Vmovdqu64_zmm_k1z_zmmm512,
		EVEX_Vmovdqu8_xmm_k1z_xmmm128,
		EVEX_Vmovdqu8_ymm_k1z_ymmm256,
		EVEX_Vmovdqu8_zmm_k1z_zmmm512,
		EVEX_Vmovdqu16_xmm_k1z_xmmm128,
		EVEX_Vmovdqu16_ymm_k1z_ymmm256,
		EVEX_Vmovdqu16_zmm_k1z_zmmm512,
		Pshufw_mm_mmm64_imm8,
		Pshufd_xmm_xmmm128_imm8,
		VEX_Vpshufd_xmm_xmmm128_imm8,
		VEX_Vpshufd_ymm_ymmm256_imm8,
		EVEX_Vpshufd_xmm_k1z_xmmm128b32_imm8,
		EVEX_Vpshufd_ymm_k1z_ymmm256b32_imm8,
		EVEX_Vpshufd_zmm_k1z_zmmm512b32_imm8,
		Pshufhw_xmm_xmmm128_imm8,
		VEX_Vpshufhw_xmm_xmmm128_imm8,
		VEX_Vpshufhw_ymm_ymmm256_imm8,
		EVEX_Vpshufhw_xmm_k1z_xmmm128_imm8,
		EVEX_Vpshufhw_ymm_k1z_ymmm256_imm8,
		EVEX_Vpshufhw_zmm_k1z_zmmm512_imm8,
		Pshuflw_xmm_xmmm128_imm8,
		VEX_Vpshuflw_xmm_xmmm128_imm8,
		VEX_Vpshuflw_ymm_ymmm256_imm8,
		EVEX_Vpshuflw_xmm_k1z_xmmm128_imm8,
		EVEX_Vpshuflw_ymm_k1z_ymmm256_imm8,
		EVEX_Vpshuflw_zmm_k1z_zmmm512_imm8,
		Psrlw_mm_imm8,
		Psrlw_xmm_imm8,
		VEX_Vpsrlw_xmm_xmm_imm8,
		VEX_Vpsrlw_ymm_ymm_imm8,
		EVEX_Vpsrlw_xmm_k1z_xmmm128_imm8,
		EVEX_Vpsrlw_ymm_k1z_ymmm256_imm8,
		EVEX_Vpsrlw_zmm_k1z_zmmm512_imm8,
		Psraw_mm_imm8,
		Psraw_xmm_imm8,
		VEX_Vpsraw_xmm_xmm_imm8,
		VEX_Vpsraw_ymm_ymm_imm8,
		EVEX_Vpsraw_xmm_k1z_xmmm128_imm8,
		EVEX_Vpsraw_ymm_k1z_ymmm256_imm8,
		EVEX_Vpsraw_zmm_k1z_zmmm512_imm8,
		Psllw_mm_imm8,
		Psllw_xmm_imm8,
		VEX_Vpsllw_xmm_xmm_imm8,
		VEX_Vpsllw_ymm_ymm_imm8,
		EVEX_Vpsllw_xmm_k1z_xmmm128_imm8,
		EVEX_Vpsllw_ymm_k1z_ymmm256_imm8,
		EVEX_Vpsllw_zmm_k1z_zmmm512_imm8,
		EVEX_Vprord_xmm_k1z_xmmm128b32_imm8,
		EVEX_Vprord_ymm_k1z_ymmm256b32_imm8,
		EVEX_Vprord_zmm_k1z_zmmm512b32_imm8,
		EVEX_Vprorq_xmm_k1z_xmmm128b64_imm8,
		EVEX_Vprorq_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vprorq_zmm_k1z_zmmm512b64_imm8,
		EVEX_Vprold_xmm_k1z_xmmm128b32_imm8,
		EVEX_Vprold_ymm_k1z_ymmm256b32_imm8,
		EVEX_Vprold_zmm_k1z_zmmm512b32_imm8,
		EVEX_Vprolq_xmm_k1z_xmmm128b64_imm8,
		EVEX_Vprolq_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vprolq_zmm_k1z_zmmm512b64_imm8,
		Psrld_mm_imm8,
		Psrld_xmm_imm8,
		VEX_Vpsrld_xmm_xmm_imm8,
		VEX_Vpsrld_ymm_ymm_imm8,
		EVEX_Vpsrld_xmm_k1z_xmmm128b32_imm8,
		EVEX_Vpsrld_ymm_k1z_ymmm256b32_imm8,
		EVEX_Vpsrld_zmm_k1z_zmmm512b32_imm8,
		Psrad_mm_imm8,
		Psrad_xmm_imm8,
		VEX_Vpsrad_xmm_xmm_imm8,
		VEX_Vpsrad_ymm_ymm_imm8,
		EVEX_Vpsrad_xmm_k1z_xmmm128b32_imm8,
		EVEX_Vpsrad_ymm_k1z_ymmm256b32_imm8,
		EVEX_Vpsrad_zmm_k1z_zmmm512b32_imm8,
		EVEX_Vpsraq_xmm_k1z_xmmm128b64_imm8,
		EVEX_Vpsraq_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vpsraq_zmm_k1z_zmmm512b64_imm8,
		Pslld_mm_imm8,
		Pslld_xmm_imm8,
		VEX_Vpslld_xmm_xmm_imm8,
		VEX_Vpslld_ymm_ymm_imm8,
		EVEX_Vpslld_xmm_k1z_xmmm128b32_imm8,
		EVEX_Vpslld_ymm_k1z_ymmm256b32_imm8,
		EVEX_Vpslld_zmm_k1z_zmmm512b32_imm8,
		Psrlq_mm_imm8,
		Psrlq_xmm_imm8,
		VEX_Vpsrlq_xmm_xmm_imm8,
		VEX_Vpsrlq_ymm_ymm_imm8,
		EVEX_Vpsrlq_xmm_k1z_xmmm128b64_imm8,
		EVEX_Vpsrlq_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vpsrlq_zmm_k1z_zmmm512b64_imm8,
		Psrldq_xmm_imm8,
		VEX_Vpsrldq_xmm_xmm_imm8,
		VEX_Vpsrldq_ymm_ymm_imm8,
		EVEX_Vpsrldq_xmm_xmmm128_imm8,
		EVEX_Vpsrldq_ymm_ymmm256_imm8,
		EVEX_Vpsrldq_zmm_zmmm512_imm8,
		Psllq_mm_imm8,
		Psllq_xmm_imm8,
		VEX_Vpsllq_xmm_xmm_imm8,
		VEX_Vpsllq_ymm_ymm_imm8,
		EVEX_Vpsllq_xmm_k1z_xmmm128b64_imm8,
		EVEX_Vpsllq_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vpsllq_zmm_k1z_zmmm512b64_imm8,
		Pslldq_xmm_imm8,
		VEX_Vpslldq_xmm_xmm_imm8,
		VEX_Vpslldq_ymm_ymm_imm8,
		EVEX_Vpslldq_xmm_xmmm128_imm8,
		EVEX_Vpslldq_ymm_ymmm256_imm8,
		EVEX_Vpslldq_zmm_zmmm512_imm8,
		Pcmpeqb_mm_mmm64,
		Pcmpeqb_xmm_xmmm128,
		VEX_Vpcmpeqb_xmm_xmm_xmmm128,
		VEX_Vpcmpeqb_ymm_ymm_ymmm256,
		EVEX_Vpcmpeqb_kr_k1_xmm_xmmm128,
		EVEX_Vpcmpeqb_kr_k1_ymm_ymmm256,
		EVEX_Vpcmpeqb_kr_k1_zmm_zmmm512,
		Pcmpeqw_mm_mmm64,
		Pcmpeqw_xmm_xmmm128,
		VEX_Vpcmpeqw_xmm_xmm_xmmm128,
		VEX_Vpcmpeqw_ymm_ymm_ymmm256,
		EVEX_Vpcmpeqw_kr_k1_xmm_xmmm128,
		EVEX_Vpcmpeqw_kr_k1_ymm_ymmm256,
		EVEX_Vpcmpeqw_kr_k1_zmm_zmmm512,
		Pcmpeqd_mm_mmm64,
		Pcmpeqd_xmm_xmmm128,
		VEX_Vpcmpeqd_xmm_xmm_xmmm128,
		VEX_Vpcmpeqd_ymm_ymm_ymmm256,
		EVEX_Vpcmpeqd_kr_k1_xmm_xmmm128b32,
		EVEX_Vpcmpeqd_kr_k1_ymm_ymmm256b32,
		EVEX_Vpcmpeqd_kr_k1_zmm_zmmm512b32,
		Emms,
		VEX_Vzeroupper,
		VEX_Vzeroall,
		Vmread_rm32_r32,
		Vmread_rm64_r64,
		EVEX_Vcvttps2udq_xmm_k1z_xmmm128b32,
		EVEX_Vcvttps2udq_ymm_k1z_ymmm256b32,
		EVEX_Vcvttps2udq_zmm_k1z_zmmm512b32_sae,
		EVEX_Vcvttpd2udq_xmm_k1z_xmmm128b64,
		EVEX_Vcvttpd2udq_xmm_k1z_ymmm256b64,
		EVEX_Vcvttpd2udq_ymm_k1z_zmmm512b64_sae,
		Extrq_xmm_imm8_imm8,
		EVEX_Vcvttps2uqq_xmm_k1z_xmmm64b32,
		EVEX_Vcvttps2uqq_ymm_k1z_xmmm128b32,
		EVEX_Vcvttps2uqq_zmm_k1z_ymmm256b32_sae,
		EVEX_Vcvttpd2uqq_xmm_k1z_xmmm128b64,
		EVEX_Vcvttpd2uqq_ymm_k1z_ymmm256b64,
		EVEX_Vcvttpd2uqq_zmm_k1z_zmmm512b64_sae,
		EVEX_Vcvttss2usi_r32_xmmm32_sae,
		EVEX_Vcvttss2usi_r64_xmmm32_sae,
		Insertq_xmm_xmm_imm8_imm8,
		EVEX_Vcvttsd2usi_r32_xmmm64_sae,
		EVEX_Vcvttsd2usi_r64_xmmm64_sae,
		Vmwrite_r32_rm32,
		Vmwrite_r64_rm64,
		EVEX_Vcvtps2udq_xmm_k1z_xmmm128b32,
		EVEX_Vcvtps2udq_ymm_k1z_ymmm256b32,
		EVEX_Vcvtps2udq_zmm_k1z_zmmm512b32_er,
		EVEX_Vcvtpd2udq_xmm_k1z_xmmm128b64,
		EVEX_Vcvtpd2udq_xmm_k1z_ymmm256b64,
		EVEX_Vcvtpd2udq_ymm_k1z_zmmm512b64_er,
		Extrq_xmm_xmm,
		EVEX_Vcvtps2uqq_xmm_k1z_xmmm64b32,
		EVEX_Vcvtps2uqq_ymm_k1z_xmmm128b32,
		EVEX_Vcvtps2uqq_zmm_k1z_ymmm256b32_er,
		EVEX_Vcvtpd2uqq_xmm_k1z_xmmm128b64,
		EVEX_Vcvtpd2uqq_ymm_k1z_ymmm256b64,
		EVEX_Vcvtpd2uqq_zmm_k1z_zmmm512b64_er,
		EVEX_Vcvtss2usi_r32_xmmm32_er,
		EVEX_Vcvtss2usi_r64_xmmm32_er,
		Insertq_xmm_xmm,
		EVEX_Vcvtsd2usi_r32_xmmm64_er,
		EVEX_Vcvtsd2usi_r64_xmmm64_er,
		EVEX_Vcvttps2qq_xmm_k1z_xmmm64b32,
		EVEX_Vcvttps2qq_ymm_k1z_xmmm128b32,
		EVEX_Vcvttps2qq_zmm_k1z_ymmm256b32_sae,
		EVEX_Vcvttpd2qq_xmm_k1z_xmmm128b64,
		EVEX_Vcvttpd2qq_ymm_k1z_ymmm256b64,
		EVEX_Vcvttpd2qq_zmm_k1z_zmmm512b64_sae,
		EVEX_Vcvtudq2pd_xmm_k1z_xmmm64b32,
		EVEX_Vcvtudq2pd_ymm_k1z_xmmm128b32,
		EVEX_Vcvtudq2pd_zmm_k1z_ymmm256b32_er,
		EVEX_Vcvtuqq2pd_xmm_k1z_xmmm128b64,
		EVEX_Vcvtuqq2pd_ymm_k1z_ymmm256b64,
		EVEX_Vcvtuqq2pd_zmm_k1z_zmmm512b64_er,
		EVEX_Vcvtudq2ps_xmm_k1z_xmmm128b32,
		EVEX_Vcvtudq2ps_ymm_k1z_ymmm256b32,
		EVEX_Vcvtudq2ps_zmm_k1z_zmmm512b32_er,
		EVEX_Vcvtuqq2ps_xmm_k1z_xmmm128b64,
		EVEX_Vcvtuqq2ps_xmm_k1z_ymmm256b64,
		EVEX_Vcvtuqq2ps_ymm_k1z_zmmm512b64_er,
		EVEX_Vcvtps2qq_xmm_k1z_xmmm64b32,
		EVEX_Vcvtps2qq_ymm_k1z_xmmm128b32,
		EVEX_Vcvtps2qq_zmm_k1z_ymmm256b32_er,
		EVEX_Vcvtpd2qq_xmm_k1z_xmmm128b64,
		EVEX_Vcvtpd2qq_ymm_k1z_ymmm256b64,
		EVEX_Vcvtpd2qq_zmm_k1z_zmmm512b64_er,
		EVEX_Vcvtusi2ss_xmm_xmm_rm32_er,
		EVEX_Vcvtusi2ss_xmm_xmm_rm64_er,
		EVEX_Vcvtusi2sd_xmm_xmm_rm32_er,
		EVEX_Vcvtusi2sd_xmm_xmm_rm64_er,
		Haddpd_xmm_xmmm128,
		VEX_Vhaddpd_xmm_xmm_xmmm128,
		VEX_Vhaddpd_ymm_ymm_ymmm256,
		Haddps_xmm_xmmm128,
		VEX_Vhaddps_xmm_xmm_xmmm128,
		VEX_Vhaddps_ymm_ymm_ymmm256,
		Hsubpd_xmm_xmmm128,
		VEX_Vhsubpd_xmm_xmm_xmmm128,
		VEX_Vhsubpd_ymm_ymm_ymmm256,
		Hsubps_xmm_xmmm128,
		VEX_Vhsubps_xmm_xmm_xmmm128,
		VEX_Vhsubps_ymm_ymm_ymmm256,
		Movd_rm32_mm,
		Movq_rm64_mm,
		Movd_rm32_xmm,
		Movq_rm64_xmm,
		VEX_Vmovd_rm32_xmm,
		VEX_Vmovq_rm64_xmm,
		EVEX_Vmovd_rm32_xmm,
		EVEX_Vmovq_rm64_xmm,
		Movq_xmm_xmmm64,
		VEX_Vmovq_xmm_xmmm64,
		EVEX_Vmovq_xmm_xmmm64,
		Movq_mmm64_mm,
		Movdqa_xmmm128_xmm,
		VEX_Vmovdqa_xmmm128_xmm,
		VEX_Vmovdqa_ymmm256_ymm,
		EVEX_Vmovdqa32_xmmm128_k1z_xmm,
		EVEX_Vmovdqa32_ymmm256_k1z_ymm,
		EVEX_Vmovdqa32_zmmm512_k1z_zmm,
		EVEX_Vmovdqa64_xmmm128_k1z_xmm,
		EVEX_Vmovdqa64_ymmm256_k1z_ymm,
		EVEX_Vmovdqa64_zmmm512_k1z_zmm,
		Movdqu_xmmm128_xmm,
		VEX_Vmovdqu_xmmm128_xmm,
		VEX_Vmovdqu_ymmm256_ymm,
		EVEX_Vmovdqu32_xmmm128_k1z_xmm,
		EVEX_Vmovdqu32_ymmm256_k1z_ymm,
		EVEX_Vmovdqu32_zmmm512_k1z_zmm,
		EVEX_Vmovdqu64_xmmm128_k1z_xmm,
		EVEX_Vmovdqu64_ymmm256_k1z_ymm,
		EVEX_Vmovdqu64_zmmm512_k1z_zmm,
		EVEX_Vmovdqu8_xmmm128_k1z_xmm,
		EVEX_Vmovdqu8_ymmm256_k1z_ymm,
		EVEX_Vmovdqu8_zmmm512_k1z_zmm,
		EVEX_Vmovdqu16_xmmm128_k1z_xmm,
		EVEX_Vmovdqu16_ymmm256_k1z_ymm,
		EVEX_Vmovdqu16_zmmm512_k1z_zmm,
		Jo_rel16,
		Jo_rel32_32,
		Jo_rel32_64,
		Jno_rel16,
		Jno_rel32_32,
		Jno_rel32_64,
		Jb_rel16,
		Jb_rel32_32,
		Jb_rel32_64,
		Jae_rel16,
		Jae_rel32_32,
		Jae_rel32_64,
		Je_rel16,
		Je_rel32_32,
		Je_rel32_64,
		Jne_rel16,
		Jne_rel32_32,
		Jne_rel32_64,
		Jbe_rel16,
		Jbe_rel32_32,
		Jbe_rel32_64,
		Ja_rel16,
		Ja_rel32_32,
		Ja_rel32_64,
		Js_rel16,
		Js_rel32_32,
		Js_rel32_64,
		Jns_rel16,
		Jns_rel32_32,
		Jns_rel32_64,
		Jp_rel16,
		Jp_rel32_32,
		Jp_rel32_64,
		Jnp_rel16,
		Jnp_rel32_32,
		Jnp_rel32_64,
		Jl_rel16,
		Jl_rel32_32,
		Jl_rel32_64,
		Jge_rel16,
		Jge_rel32_32,
		Jge_rel32_64,
		Jle_rel16,
		Jle_rel32_32,
		Jle_rel32_64,
		Jg_rel16,
		Jg_rel32_32,
		Jg_rel32_64,
		Seto_rm8,
		Setno_rm8,
		Setb_rm8,
		Setae_rm8,
		Sete_rm8,
		Setne_rm8,
		Setbe_rm8,
		Seta_rm8,
		Sets_rm8,
		Setns_rm8,
		Setp_rm8,
		Setnp_rm8,
		Setl_rm8,
		Setge_rm8,
		Setle_rm8,
		Setg_rm8,
		VEX_Kmovw_kr_km16,
		VEX_Kmovq_kr_km64,
		VEX_Kmovb_kr_km8,
		VEX_Kmovd_kr_km32,
		VEX_Kmovw_m16_kr,
		VEX_Kmovq_m64_kr,
		VEX_Kmovb_m8_kr,
		VEX_Kmovd_m32_kr,
		VEX_Kmovw_kr_r32,
		VEX_Kmovb_kr_r32,
		VEX_Kmovd_kr_r32,
		VEX_Kmovq_kr_r64,
		VEX_Kmovw_r32_kr,
		VEX_Kmovb_r32_kr,
		VEX_Kmovd_r32_kr,
		VEX_Kmovq_r64_kr,
		VEX_Kortestw_kr_kr,
		VEX_Kortestq_kr_kr,
		VEX_Kortestb_kr_kr,
		VEX_Kortestd_kr_kr,
		VEX_Ktestw_kr_kr,
		VEX_Ktestq_kr_kr,
		VEX_Ktestb_kr_kr,
		VEX_Ktestd_kr_kr,
		Pushw_FS,
		Pushd_FS,
		Pushq_FS,
		Popw_FS,
		Popd_FS,
		Popq_FS,
		Cpuid,
		Bt_rm16_r16,
		Bt_rm32_r32,
		Bt_rm64_r64,
		Shld_rm16_r16_imm8,
		Shld_rm32_r32_imm8,
		Shld_rm64_r64_imm8,
		Shld_rm16_r16_CL,
		Shld_rm32_r32_CL,
		Shld_rm64_r64_CL,
		Montmul_16,
		Montmul_32,
		Montmul_64,
		Xsha1_16,
		Xsha1_32,
		Xsha1_64,
		Xsha256_16,
		Xsha256_32,
		Xsha256_64,
		Xbts_r16_rm16,
		Xbts_r32_rm32,
		Xstore_16,
		Xstore_32,
		Xstore_64,
		Xcryptecb_16,
		Xcryptecb_32,
		Xcryptecb_64,
		Xcryptcbc_16,
		Xcryptcbc_32,
		Xcryptcbc_64,
		Xcryptctr_16,
		Xcryptctr_32,
		Xcryptctr_64,
		Xcryptcfb_16,
		Xcryptcfb_32,
		Xcryptcfb_64,
		Xcryptofb_16,
		Xcryptofb_32,
		Xcryptofb_64,
		Ibts_rm16_r16,
		Ibts_rm32_r32,
		Cmpxchg486_rm8_r8,
		Cmpxchg486_rm16_r16,
		Cmpxchg486_rm32_r32,
		Pushw_GS,
		Pushd_GS,
		Pushq_GS,
		Popw_GS,
		Popd_GS,
		Popq_GS,
		Rsm,
		Bts_rm16_r16,
		Bts_rm32_r32,
		Bts_rm64_r64,
		Shrd_rm16_r16_imm8,
		Shrd_rm32_r32_imm8,
		Shrd_rm64_r64_imm8,
		Shrd_rm16_r16_CL,
		Shrd_rm32_r32_CL,
		Shrd_rm64_r64_CL,
		Fxsave_m512byte,
		Fxsave64_m512byte,
		Rdfsbase_r32,
		Rdfsbase_r64,
		Fxrstor_m512byte,
		Fxrstor64_m512byte,
		Rdgsbase_r32,
		Rdgsbase_r64,
		Ldmxcsr_m32,
		Wrfsbase_r32,
		Wrfsbase_r64,
		VEX_Vldmxcsr_m32,
		Stmxcsr_m32,
		Wrgsbase_r32,
		Wrgsbase_r64,
		VEX_Vstmxcsr_m32,
		Xsave_mem,
		Xsave64_mem,
		Ptwrite_rm32,
		Ptwrite_rm64,
		Xrstor_mem,
		Xrstor64_mem,
		Incsspd_r32,
		Incsspq_r64,
		Xsaveopt_mem,
		Xsaveopt64_mem,
		Clwb_m8,
		Tpause_r32,
		Tpause_r64,
		Clrssbsy_m64,
		Umonitor_r16,
		Umonitor_r32,
		Umonitor_r64,
		Umwait_r32,
		Umwait_r64,
		Clflush_m8,
		Clflushopt_m8,
		Lfence,
		Lfence_E9,
		Lfence_EA,
		Lfence_EB,
		Lfence_EC,
		Lfence_ED,
		Lfence_EE,
		Lfence_EF,
		Mfence,
		Mfence_F1,
		Mfence_F2,
		Mfence_F3,
		Mfence_F4,
		Mfence_F5,
		Mfence_F6,
		Mfence_F7,
		Sfence,
		Sfence_F9,
		Sfence_FA,
		Sfence_FB,
		Sfence_FC,
		Sfence_FD,
		Sfence_FE,
		Sfence_FF,
		Pcommit,
		Imul_r16_rm16,
		Imul_r32_rm32,
		Imul_r64_rm64,
		Cmpxchg_rm8_r8,
		Cmpxchg_rm16_r16,
		Cmpxchg_rm32_r32,
		Cmpxchg_rm64_r64,
		Lss_r16_m1616,
		Lss_r32_m1632,
		Lss_r64_m1664,
		Btr_rm16_r16,
		Btr_rm32_r32,
		Btr_rm64_r64,
		Lfs_r16_m1616,
		Lfs_r32_m1632,
		Lfs_r64_m1664,
		Lgs_r16_m1616,
		Lgs_r32_m1632,
		Lgs_r64_m1664,
		Movzx_r16_rm8,
		Movzx_r32_rm8,
		Movzx_r64_rm8,
		Movzx_r16_rm16,
		Movzx_r32_rm16,
		Movzx_r64_rm16,
		Jmpe_disp16,
		Jmpe_disp32,
		Popcnt_r16_rm16,
		Popcnt_r32_rm32,
		Popcnt_r64_rm64,
		Ud1_r16_rm16,
		Ud1_r32_rm32,
		Ud1_r64_rm64,
		Bt_rm16_imm8,
		Bt_rm32_imm8,
		Bt_rm64_imm8,
		Bts_rm16_imm8,
		Bts_rm32_imm8,
		Bts_rm64_imm8,
		Btr_rm16_imm8,
		Btr_rm32_imm8,
		Btr_rm64_imm8,
		Btc_rm16_imm8,
		Btc_rm32_imm8,
		Btc_rm64_imm8,
		Btc_rm16_r16,
		Btc_rm32_r32,
		Btc_rm64_r64,
		Bsf_r16_rm16,
		Bsf_r32_rm32,
		Bsf_r64_rm64,
		Tzcnt_r16_rm16,
		Tzcnt_r32_rm32,
		Tzcnt_r64_rm64,
		Bsr_r16_rm16,
		Bsr_r32_rm32,
		Bsr_r64_rm64,
		Lzcnt_r16_rm16,
		Lzcnt_r32_rm32,
		Lzcnt_r64_rm64,
		Movsx_r16_rm8,
		Movsx_r32_rm8,
		Movsx_r64_rm8,
		Movsx_r16_rm16,
		Movsx_r32_rm16,
		Movsx_r64_rm16,
		Xadd_rm8_r8,
		Xadd_rm16_r16,
		Xadd_rm32_r32,
		Xadd_rm64_r64,
		Cmpps_xmm_xmmm128_imm8,
		VEX_Vcmpps_xmm_xmm_xmmm128_imm8,
		VEX_Vcmpps_ymm_ymm_ymmm256_imm8,
		EVEX_Vcmpps_kr_k1_xmm_xmmm128b32_imm8,
		EVEX_Vcmpps_kr_k1_ymm_ymmm256b32_imm8,
		EVEX_Vcmpps_kr_k1_zmm_zmmm512b32_imm8_sae,
		Cmppd_xmm_xmmm128_imm8,
		VEX_Vcmppd_xmm_xmm_xmmm128_imm8,
		VEX_Vcmppd_ymm_ymm_ymmm256_imm8,
		EVEX_Vcmppd_kr_k1_xmm_xmmm128b64_imm8,
		EVEX_Vcmppd_kr_k1_ymm_ymmm256b64_imm8,
		EVEX_Vcmppd_kr_k1_zmm_zmmm512b64_imm8_sae,
		Cmpss_xmm_xmmm32_imm8,
		VEX_Vcmpss_xmm_xmm_xmmm32_imm8,
		EVEX_Vcmpss_kr_k1_xmm_xmmm32_imm8_sae,
		Cmpsd_xmm_xmmm64_imm8,
		VEX_Vcmpsd_xmm_xmm_xmmm64_imm8,
		EVEX_Vcmpsd_kr_k1_xmm_xmmm64_imm8_sae,
		Movnti_m32_r32,
		Movnti_m64_r64,
		Pinsrw_mm_r32m16_imm8,
		Pinsrw_mm_r64m16_imm8,
		Pinsrw_xmm_r32m16_imm8,
		Pinsrw_xmm_r64m16_imm8,
		VEX_Vpinsrw_xmm_xmm_r32m16_imm8,
		VEX_Vpinsrw_xmm_xmm_r64m16_imm8,
		EVEX_Vpinsrw_xmm_xmm_r32m16_imm8,
		EVEX_Vpinsrw_xmm_xmm_r64m16_imm8,
		Pextrw_r32_mm_imm8,
		Pextrw_r64_mm_imm8,
		Pextrw_r32_xmm_imm8,
		Pextrw_r64_xmm_imm8,
		VEX_Vpextrw_r32_xmm_imm8,
		VEX_Vpextrw_r64_xmm_imm8,
		EVEX_Vpextrw_r32_xmm_imm8,
		EVEX_Vpextrw_r64_xmm_imm8,
		Shufps_xmm_xmmm128_imm8,
		VEX_Vshufps_xmm_xmm_xmmm128_imm8,
		VEX_Vshufps_ymm_ymm_ymmm256_imm8,
		EVEX_Vshufps_xmm_k1z_xmm_xmmm128b32_imm8,
		EVEX_Vshufps_ymm_k1z_ymm_ymmm256b32_imm8,
		EVEX_Vshufps_zmm_k1z_zmm_zmmm512b32_imm8,
		Shufpd_xmm_xmmm128_imm8,
		VEX_Vshufpd_xmm_xmm_xmmm128_imm8,
		VEX_Vshufpd_ymm_ymm_ymmm256_imm8,
		EVEX_Vshufpd_xmm_k1z_xmm_xmmm128b64_imm8,
		EVEX_Vshufpd_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Vshufpd_zmm_k1z_zmm_zmmm512b64_imm8,
		Cmpxchg8b_m64,
		Cmpxchg16b_m128,
		Xrstors_mem,
		Xrstors64_mem,
		Xsavec_mem,
		Xsavec64_mem,
		Xsaves_mem,
		Xsaves64_mem,
		Vmptrld_m64,
		Vmclear_m64,
		Vmxon_m64,
		Rdrand_r16,
		Rdrand_r32,
		Rdrand_r64,
		Vmptrst_m64,
		Rdseed_r16,
		Rdseed_r32,
		Rdseed_r64,
		Rdpid_r32,
		Rdpid_r64,
		Bswap_r16,
		Bswap_r32,
		Bswap_r64,
		Addsubpd_xmm_xmmm128,
		VEX_Vaddsubpd_xmm_xmm_xmmm128,
		VEX_Vaddsubpd_ymm_ymm_ymmm256,
		Addsubps_xmm_xmmm128,
		VEX_Vaddsubps_xmm_xmm_xmmm128,
		VEX_Vaddsubps_ymm_ymm_ymmm256,
		Psrlw_mm_mmm64,
		Psrlw_xmm_xmmm128,
		VEX_Vpsrlw_xmm_xmm_xmmm128,
		VEX_Vpsrlw_ymm_ymm_xmmm128,
		EVEX_Vpsrlw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsrlw_ymm_k1z_ymm_xmmm128,
		EVEX_Vpsrlw_zmm_k1z_zmm_xmmm128,
		Psrld_mm_mmm64,
		Psrld_xmm_xmmm128,
		VEX_Vpsrld_xmm_xmm_xmmm128,
		VEX_Vpsrld_ymm_ymm_xmmm128,
		EVEX_Vpsrld_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsrld_ymm_k1z_ymm_xmmm128,
		EVEX_Vpsrld_zmm_k1z_zmm_xmmm128,
		Psrlq_mm_mmm64,
		Psrlq_xmm_xmmm128,
		VEX_Vpsrlq_xmm_xmm_xmmm128,
		VEX_Vpsrlq_ymm_ymm_xmmm128,
		EVEX_Vpsrlq_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsrlq_ymm_k1z_ymm_xmmm128,
		EVEX_Vpsrlq_zmm_k1z_zmm_xmmm128,
		Paddq_mm_mmm64,
		Paddq_xmm_xmmm128,
		VEX_Vpaddq_xmm_xmm_xmmm128,
		VEX_Vpaddq_ymm_ymm_ymmm256,
		EVEX_Vpaddq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpaddq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpaddq_zmm_k1z_zmm_zmmm512b64,
		Pmullw_mm_mmm64,
		Pmullw_xmm_xmmm128,
		VEX_Vpmullw_xmm_xmm_xmmm128,
		VEX_Vpmullw_ymm_ymm_ymmm256,
		EVEX_Vpmullw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpmullw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpmullw_zmm_k1z_zmm_zmmm512,
		Movq_xmmm64_xmm,
		VEX_Vmovq_xmmm64_xmm,
		EVEX_Vmovq_xmmm64_xmm,
		Movq2dq_xmm_mm,
		Movdq2q_mm_xmm,
		Pmovmskb_r32_mm,
		Pmovmskb_r64_mm,
		Pmovmskb_r32_xmm,
		Pmovmskb_r64_xmm,
		VEX_Vpmovmskb_r32_xmm,
		VEX_Vpmovmskb_r64_xmm,
		VEX_Vpmovmskb_r32_ymm,
		VEX_Vpmovmskb_r64_ymm,
		Psubusb_mm_mmm64,
		Psubusb_xmm_xmmm128,
		VEX_Vpsubusb_xmm_xmm_xmmm128,
		VEX_Vpsubusb_ymm_ymm_ymmm256,
		EVEX_Vpsubusb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsubusb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpsubusb_zmm_k1z_zmm_zmmm512,
		Psubusw_mm_mmm64,
		Psubusw_xmm_xmmm128,
		VEX_Vpsubusw_xmm_xmm_xmmm128,
		VEX_Vpsubusw_ymm_ymm_ymmm256,
		EVEX_Vpsubusw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsubusw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpsubusw_zmm_k1z_zmm_zmmm512,
		Pminub_mm_mmm64,
		Pminub_xmm_xmmm128,
		VEX_Vpminub_xmm_xmm_xmmm128,
		VEX_Vpminub_ymm_ymm_ymmm256,
		EVEX_Vpminub_xmm_k1z_xmm_xmmm128,
		EVEX_Vpminub_ymm_k1z_ymm_ymmm256,
		EVEX_Vpminub_zmm_k1z_zmm_zmmm512,
		Pand_mm_mmm64,
		Pand_xmm_xmmm128,
		VEX_Vpand_xmm_xmm_xmmm128,
		VEX_Vpand_ymm_ymm_ymmm256,
		EVEX_Vpandd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpandd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpandd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpandq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpandq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpandq_zmm_k1z_zmm_zmmm512b64,
		Paddusb_mm_mmm64,
		Paddusb_xmm_xmmm128,
		VEX_Vpaddusb_xmm_xmm_xmmm128,
		VEX_Vpaddusb_ymm_ymm_ymmm256,
		EVEX_Vpaddusb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpaddusb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpaddusb_zmm_k1z_zmm_zmmm512,
		Paddusw_mm_mmm64,
		Paddusw_xmm_xmmm128,
		VEX_Vpaddusw_xmm_xmm_xmmm128,
		VEX_Vpaddusw_ymm_ymm_ymmm256,
		EVEX_Vpaddusw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpaddusw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpaddusw_zmm_k1z_zmm_zmmm512,
		Pmaxub_mm_mmm64,
		Pmaxub_xmm_xmmm128,
		VEX_Vpmaxub_xmm_xmm_xmmm128,
		VEX_Vpmaxub_ymm_ymm_ymmm256,
		EVEX_Vpmaxub_xmm_k1z_xmm_xmmm128,
		EVEX_Vpmaxub_ymm_k1z_ymm_ymmm256,
		EVEX_Vpmaxub_zmm_k1z_zmm_zmmm512,
		Pandn_mm_mmm64,
		Pandn_xmm_xmmm128,
		VEX_Vpandn_xmm_xmm_xmmm128,
		VEX_Vpandn_ymm_ymm_ymmm256,
		EVEX_Vpandnd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpandnd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpandnd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpandnq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpandnq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpandnq_zmm_k1z_zmm_zmmm512b64,
		Pavgb_mm_mmm64,
		Pavgb_xmm_xmmm128,
		VEX_Vpavgb_xmm_xmm_xmmm128,
		VEX_Vpavgb_ymm_ymm_ymmm256,
		EVEX_Vpavgb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpavgb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpavgb_zmm_k1z_zmm_zmmm512,
		Psraw_mm_mmm64,
		Psraw_xmm_xmmm128,
		VEX_Vpsraw_xmm_xmm_xmmm128,
		VEX_Vpsraw_ymm_ymm_xmmm128,
		EVEX_Vpsraw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsraw_ymm_k1z_ymm_xmmm128,
		EVEX_Vpsraw_zmm_k1z_zmm_xmmm128,
		Psrad_mm_mmm64,
		Psrad_xmm_xmmm128,
		VEX_Vpsrad_xmm_xmm_xmmm128,
		VEX_Vpsrad_ymm_ymm_xmmm128,
		EVEX_Vpsrad_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsrad_ymm_k1z_ymm_xmmm128,
		EVEX_Vpsrad_zmm_k1z_zmm_xmmm128,
		EVEX_Vpsraq_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsraq_ymm_k1z_ymm_xmmm128,
		EVEX_Vpsraq_zmm_k1z_zmm_xmmm128,
		Pavgw_mm_mmm64,
		Pavgw_xmm_xmmm128,
		VEX_Vpavgw_xmm_xmm_xmmm128,
		VEX_Vpavgw_ymm_ymm_ymmm256,
		EVEX_Vpavgw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpavgw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpavgw_zmm_k1z_zmm_zmmm512,
		Pmulhuw_mm_mmm64,
		Pmulhuw_xmm_xmmm128,
		VEX_Vpmulhuw_xmm_xmm_xmmm128,
		VEX_Vpmulhuw_ymm_ymm_ymmm256,
		EVEX_Vpmulhuw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpmulhuw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpmulhuw_zmm_k1z_zmm_zmmm512,
		Pmulhw_mm_mmm64,
		Pmulhw_xmm_xmmm128,
		VEX_Vpmulhw_xmm_xmm_xmmm128,
		VEX_Vpmulhw_ymm_ymm_ymmm256,
		EVEX_Vpmulhw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpmulhw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpmulhw_zmm_k1z_zmm_zmmm512,
		Cvttpd2dq_xmm_xmmm128,
		VEX_Vcvttpd2dq_xmm_xmmm128,
		VEX_Vcvttpd2dq_xmm_ymmm256,
		EVEX_Vcvttpd2dq_xmm_k1z_xmmm128b64,
		EVEX_Vcvttpd2dq_xmm_k1z_ymmm256b64,
		EVEX_Vcvttpd2dq_ymm_k1z_zmmm512b64_sae,
		Cvtdq2pd_xmm_xmmm64,
		VEX_Vcvtdq2pd_xmm_xmmm64,
		VEX_Vcvtdq2pd_ymm_xmmm128,
		EVEX_Vcvtdq2pd_xmm_k1z_xmmm64b32,
		EVEX_Vcvtdq2pd_ymm_k1z_xmmm128b32,
		EVEX_Vcvtdq2pd_zmm_k1z_ymmm256b32_er,
		EVEX_Vcvtqq2pd_xmm_k1z_xmmm128b64,
		EVEX_Vcvtqq2pd_ymm_k1z_ymmm256b64,
		EVEX_Vcvtqq2pd_zmm_k1z_zmmm512b64_er,
		Cvtpd2dq_xmm_xmmm128,
		VEX_Vcvtpd2dq_xmm_xmmm128,
		VEX_Vcvtpd2dq_xmm_ymmm256,
		EVEX_Vcvtpd2dq_xmm_k1z_xmmm128b64,
		EVEX_Vcvtpd2dq_xmm_k1z_ymmm256b64,
		EVEX_Vcvtpd2dq_ymm_k1z_zmmm512b64_er,
		Movntq_m64_mm,
		Movntdq_m128_xmm,
		VEX_Vmovntdq_m128_xmm,
		VEX_Vmovntdq_m256_ymm,
		EVEX_Vmovntdq_m128_xmm,
		EVEX_Vmovntdq_m256_ymm,
		EVEX_Vmovntdq_m512_zmm,
		Psubsb_mm_mmm64,
		Psubsb_xmm_xmmm128,
		VEX_Vpsubsb_xmm_xmm_xmmm128,
		VEX_Vpsubsb_ymm_ymm_ymmm256,
		EVEX_Vpsubsb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsubsb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpsubsb_zmm_k1z_zmm_zmmm512,
		Psubsw_mm_mmm64,
		Psubsw_xmm_xmmm128,
		VEX_Vpsubsw_xmm_xmm_xmmm128,
		VEX_Vpsubsw_ymm_ymm_ymmm256,
		EVEX_Vpsubsw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsubsw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpsubsw_zmm_k1z_zmm_zmmm512,
		Pminsw_mm_mmm64,
		Pminsw_xmm_xmmm128,
		VEX_Vpminsw_xmm_xmm_xmmm128,
		VEX_Vpminsw_ymm_ymm_ymmm256,
		EVEX_Vpminsw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpminsw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpminsw_zmm_k1z_zmm_zmmm512,
		Por_mm_mmm64,
		Por_xmm_xmmm128,
		VEX_Vpor_xmm_xmm_xmmm128,
		VEX_Vpor_ymm_ymm_ymmm256,
		EVEX_Vpord_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpord_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpord_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vporq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vporq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vporq_zmm_k1z_zmm_zmmm512b64,
		Paddsb_mm_mmm64,
		Paddsb_xmm_xmmm128,
		VEX_Vpaddsb_xmm_xmm_xmmm128,
		VEX_Vpaddsb_ymm_ymm_ymmm256,
		EVEX_Vpaddsb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpaddsb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpaddsb_zmm_k1z_zmm_zmmm512,
		Paddsw_mm_mmm64,
		Paddsw_xmm_xmmm128,
		VEX_Vpaddsw_xmm_xmm_xmmm128,
		VEX_Vpaddsw_ymm_ymm_ymmm256,
		EVEX_Vpaddsw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpaddsw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpaddsw_zmm_k1z_zmm_zmmm512,
		Pmaxsw_mm_mmm64,
		Pmaxsw_xmm_xmmm128,
		VEX_Vpmaxsw_xmm_xmm_xmmm128,
		VEX_Vpmaxsw_ymm_ymm_ymmm256,
		EVEX_Vpmaxsw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpmaxsw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpmaxsw_zmm_k1z_zmm_zmmm512,
		Pxor_mm_mmm64,
		Pxor_xmm_xmmm128,
		VEX_Vpxor_xmm_xmm_xmmm128,
		VEX_Vpxor_ymm_ymm_ymmm256,
		EVEX_Vpxord_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpxord_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpxord_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpxorq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpxorq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpxorq_zmm_k1z_zmm_zmmm512b64,
		Lddqu_xmm_m128,
		VEX_Vlddqu_xmm_m128,
		VEX_Vlddqu_ymm_m256,
		Psllw_mm_mmm64,
		Psllw_xmm_xmmm128,
		VEX_Vpsllw_xmm_xmm_xmmm128,
		VEX_Vpsllw_ymm_ymm_xmmm128,
		EVEX_Vpsllw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsllw_ymm_k1z_ymm_xmmm128,
		EVEX_Vpsllw_zmm_k1z_zmm_xmmm128,
		Pslld_mm_mmm64,
		Pslld_xmm_xmmm128,
		VEX_Vpslld_xmm_xmm_xmmm128,
		VEX_Vpslld_ymm_ymm_xmmm128,
		EVEX_Vpslld_xmm_k1z_xmm_xmmm128,
		EVEX_Vpslld_ymm_k1z_ymm_xmmm128,
		EVEX_Vpslld_zmm_k1z_zmm_xmmm128,
		Psllq_mm_mmm64,
		Psllq_xmm_xmmm128,
		VEX_Vpsllq_xmm_xmm_xmmm128,
		VEX_Vpsllq_ymm_ymm_xmmm128,
		EVEX_Vpsllq_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsllq_ymm_k1z_ymm_xmmm128,
		EVEX_Vpsllq_zmm_k1z_zmm_xmmm128,
		Pmuludq_mm_mmm64,
		Pmuludq_xmm_xmmm128,
		VEX_Vpmuludq_xmm_xmm_xmmm128,
		VEX_Vpmuludq_ymm_ymm_ymmm256,
		EVEX_Vpmuludq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpmuludq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpmuludq_zmm_k1z_zmm_zmmm512b64,
		Pmaddwd_mm_mmm64,
		Pmaddwd_xmm_xmmm128,
		VEX_Vpmaddwd_xmm_xmm_xmmm128,
		VEX_Vpmaddwd_ymm_ymm_ymmm256,
		EVEX_Vpmaddwd_xmm_k1z_xmm_xmmm128,
		EVEX_Vpmaddwd_ymm_k1z_ymm_ymmm256,
		EVEX_Vpmaddwd_zmm_k1z_zmm_zmmm512,
		Psadbw_mm_mmm64,
		Psadbw_xmm_xmmm128,
		VEX_Vpsadbw_xmm_xmm_xmmm128,
		VEX_Vpsadbw_ymm_ymm_ymmm256,
		EVEX_Vpsadbw_xmm_xmm_xmmm128,
		EVEX_Vpsadbw_ymm_ymm_ymmm256,
		EVEX_Vpsadbw_zmm_zmm_zmmm512,
		Maskmovq_rDI_mm_mm,
		Maskmovdqu_rDI_xmm_xmm,
		VEX_Vmaskmovdqu_rDI_xmm_xmm,
		Psubb_mm_mmm64,
		Psubb_xmm_xmmm128,
		VEX_Vpsubb_xmm_xmm_xmmm128,
		VEX_Vpsubb_ymm_ymm_ymmm256,
		EVEX_Vpsubb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsubb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpsubb_zmm_k1z_zmm_zmmm512,
		Psubw_mm_mmm64,
		Psubw_xmm_xmmm128,
		VEX_Vpsubw_xmm_xmm_xmmm128,
		VEX_Vpsubw_ymm_ymm_ymmm256,
		EVEX_Vpsubw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsubw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpsubw_zmm_k1z_zmm_zmmm512,
		Psubd_mm_mmm64,
		Psubd_xmm_xmmm128,
		VEX_Vpsubd_xmm_xmm_xmmm128,
		VEX_Vpsubd_ymm_ymm_ymmm256,
		EVEX_Vpsubd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpsubd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpsubd_zmm_k1z_zmm_zmmm512b32,
		Psubq_mm_mmm64,
		Psubq_xmm_xmmm128,
		VEX_Vpsubq_xmm_xmm_xmmm128,
		VEX_Vpsubq_ymm_ymm_ymmm256,
		EVEX_Vpsubq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpsubq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpsubq_zmm_k1z_zmm_zmmm512b64,
		Paddb_mm_mmm64,
		Paddb_xmm_xmmm128,
		VEX_Vpaddb_xmm_xmm_xmmm128,
		VEX_Vpaddb_ymm_ymm_ymmm256,
		EVEX_Vpaddb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpaddb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpaddb_zmm_k1z_zmm_zmmm512,
		Paddw_mm_mmm64,
		Paddw_xmm_xmmm128,
		VEX_Vpaddw_xmm_xmm_xmmm128,
		VEX_Vpaddw_ymm_ymm_ymmm256,
		EVEX_Vpaddw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpaddw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpaddw_zmm_k1z_zmm_zmmm512,
		Paddd_mm_mmm64,
		Paddd_xmm_xmmm128,
		VEX_Vpaddd_xmm_xmm_xmmm128,
		VEX_Vpaddd_ymm_ymm_ymmm256,
		EVEX_Vpaddd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpaddd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpaddd_zmm_k1z_zmm_zmmm512b32,
		Ud0_r16_rm16,
		Ud0_r32_rm32,
		Ud0_r64_rm64,
		Pshufb_mm_mmm64,
		Pshufb_xmm_xmmm128,
		VEX_Vpshufb_xmm_xmm_xmmm128,
		VEX_Vpshufb_ymm_ymm_ymmm256,
		EVEX_Vpshufb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpshufb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpshufb_zmm_k1z_zmm_zmmm512,
		Phaddw_mm_mmm64,
		Phaddw_xmm_xmmm128,
		VEX_Vphaddw_xmm_xmm_xmmm128,
		VEX_Vphaddw_ymm_ymm_ymmm256,
		Phaddd_mm_mmm64,
		Phaddd_xmm_xmmm128,
		VEX_Vphaddd_xmm_xmm_xmmm128,
		VEX_Vphaddd_ymm_ymm_ymmm256,
		Phaddsw_mm_mmm64,
		Phaddsw_xmm_xmmm128,
		VEX_Vphaddsw_xmm_xmm_xmmm128,
		VEX_Vphaddsw_ymm_ymm_ymmm256,
		Pmaddubsw_mm_mmm64,
		Pmaddubsw_xmm_xmmm128,
		VEX_Vpmaddubsw_xmm_xmm_xmmm128,
		VEX_Vpmaddubsw_ymm_ymm_ymmm256,
		EVEX_Vpmaddubsw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpmaddubsw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpmaddubsw_zmm_k1z_zmm_zmmm512,
		Phsubw_mm_mmm64,
		Phsubw_xmm_xmmm128,
		VEX_Vphsubw_xmm_xmm_xmmm128,
		VEX_Vphsubw_ymm_ymm_ymmm256,
		Phsubd_mm_mmm64,
		Phsubd_xmm_xmmm128,
		VEX_Vphsubd_xmm_xmm_xmmm128,
		VEX_Vphsubd_ymm_ymm_ymmm256,
		Phsubsw_mm_mmm64,
		Phsubsw_xmm_xmmm128,
		VEX_Vphsubsw_xmm_xmm_xmmm128,
		VEX_Vphsubsw_ymm_ymm_ymmm256,
		Psignb_mm_mmm64,
		Psignb_xmm_xmmm128,
		VEX_Vpsignb_xmm_xmm_xmmm128,
		VEX_Vpsignb_ymm_ymm_ymmm256,
		Psignw_mm_mmm64,
		Psignw_xmm_xmmm128,
		VEX_Vpsignw_xmm_xmm_xmmm128,
		VEX_Vpsignw_ymm_ymm_ymmm256,
		Psignd_mm_mmm64,
		Psignd_xmm_xmmm128,
		VEX_Vpsignd_xmm_xmm_xmmm128,
		VEX_Vpsignd_ymm_ymm_ymmm256,
		Pmulhrsw_mm_mmm64,
		Pmulhrsw_xmm_xmmm128,
		VEX_Vpmulhrsw_xmm_xmm_xmmm128,
		VEX_Vpmulhrsw_ymm_ymm_ymmm256,
		EVEX_Vpmulhrsw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpmulhrsw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpmulhrsw_zmm_k1z_zmm_zmmm512,
		VEX_Vpermilps_xmm_xmm_xmmm128,
		VEX_Vpermilps_ymm_ymm_ymmm256,
		EVEX_Vpermilps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpermilps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpermilps_zmm_k1z_zmm_zmmm512b32,
		VEX_Vpermilpd_xmm_xmm_xmmm128,
		VEX_Vpermilpd_ymm_ymm_ymmm256,
		EVEX_Vpermilpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpermilpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpermilpd_zmm_k1z_zmm_zmmm512b64,
		VEX_Vtestps_xmm_xmmm128,
		VEX_Vtestps_ymm_ymmm256,
		VEX_Vtestpd_xmm_xmmm128,
		VEX_Vtestpd_ymm_ymmm256,
		Pblendvb_xmm_xmmm128,
		EVEX_Vpsrlvw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsrlvw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpsrlvw_zmm_k1z_zmm_zmmm512,
		EVEX_Vpmovuswb_xmmm64_k1z_xmm,
		EVEX_Vpmovuswb_xmmm128_k1z_ymm,
		EVEX_Vpmovuswb_ymmm256_k1z_zmm,
		EVEX_Vpsravw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsravw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpsravw_zmm_k1z_zmm_zmmm512,
		EVEX_Vpmovusdb_xmmm32_k1z_xmm,
		EVEX_Vpmovusdb_xmmm64_k1z_ymm,
		EVEX_Vpmovusdb_xmmm128_k1z_zmm,
		EVEX_Vpsllvw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpsllvw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpsllvw_zmm_k1z_zmm_zmmm512,
		EVEX_Vpmovusqb_xmmm16_k1z_xmm,
		EVEX_Vpmovusqb_xmmm32_k1z_ymm,
		EVEX_Vpmovusqb_xmmm64_k1z_zmm,
		VEX_Vcvtph2ps_xmm_xmmm64,
		VEX_Vcvtph2ps_ymm_xmmm128,
		EVEX_Vcvtph2ps_xmm_k1z_xmmm64,
		EVEX_Vcvtph2ps_ymm_k1z_xmmm128,
		EVEX_Vcvtph2ps_zmm_k1z_ymmm256_sae,
		EVEX_Vpmovusdw_xmmm64_k1z_xmm,
		EVEX_Vpmovusdw_xmmm128_k1z_ymm,
		EVEX_Vpmovusdw_ymmm256_k1z_zmm,
		Blendvps_xmm_xmmm128,
		EVEX_Vprorvd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vprorvd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vprorvd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vprorvq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vprorvq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vprorvq_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vpmovusqw_xmmm32_k1z_xmm,
		EVEX_Vpmovusqw_xmmm64_k1z_ymm,
		EVEX_Vpmovusqw_xmmm128_k1z_zmm,
		Blendvpd_xmm_xmmm128,
		EVEX_Vprolvd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vprolvd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vprolvd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vprolvq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vprolvq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vprolvq_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vpmovusqd_xmmm64_k1z_xmm,
		EVEX_Vpmovusqd_xmmm128_k1z_ymm,
		EVEX_Vpmovusqd_ymmm256_k1z_zmm,
		VEX_Vpermps_ymm_ymm_ymmm256,
		EVEX_Vpermps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpermps_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpermpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpermpd_zmm_k1z_zmm_zmmm512b64,
		Ptest_xmm_xmmm128,
		VEX_Vptest_xmm_xmmm128,
		VEX_Vptest_ymm_ymmm256,
		VEX_Vbroadcastss_xmm_m32,
		VEX_Vbroadcastss_ymm_m32,
		EVEX_Vbroadcastss_xmm_k1z_xmmm32,
		EVEX_Vbroadcastss_ymm_k1z_xmmm32,
		EVEX_Vbroadcastss_zmm_k1z_xmmm32,
		VEX_Vbroadcastsd_ymm_m64,
		EVEX_Vbroadcastf32x2_ymm_k1z_xmmm64,
		EVEX_Vbroadcastf32x2_zmm_k1z_xmmm64,
		EVEX_Vbroadcastsd_ymm_k1z_xmmm64,
		EVEX_Vbroadcastsd_zmm_k1z_xmmm64,
		VEX_Vbroadcastf128_ymm_m128,
		EVEX_Vbroadcastf32x4_ymm_k1z_m128,
		EVEX_Vbroadcastf32x4_zmm_k1z_m128,
		EVEX_Vbroadcastf64x2_ymm_k1z_m128,
		EVEX_Vbroadcastf64x2_zmm_k1z_m128,
		EVEX_Vbroadcastf32x8_zmm_k1z_m256,
		EVEX_Vbroadcastf64x4_zmm_k1z_m256,
		Pabsb_mm_mmm64,
		Pabsb_xmm_xmmm128,
		VEX_Vpabsb_xmm_xmmm128,
		VEX_Vpabsb_ymm_ymmm256,
		EVEX_Vpabsb_xmm_k1z_xmmm128,
		EVEX_Vpabsb_ymm_k1z_ymmm256,
		EVEX_Vpabsb_zmm_k1z_zmmm512,
		Pabsw_mm_mmm64,
		Pabsw_xmm_xmmm128,
		VEX_Vpabsw_xmm_xmmm128,
		VEX_Vpabsw_ymm_ymmm256,
		EVEX_Vpabsw_xmm_k1z_xmmm128,
		EVEX_Vpabsw_ymm_k1z_ymmm256,
		EVEX_Vpabsw_zmm_k1z_zmmm512,
		Pabsd_mm_mmm64,
		Pabsd_xmm_xmmm128,
		VEX_Vpabsd_xmm_xmmm128,
		VEX_Vpabsd_ymm_ymmm256,
		EVEX_Vpabsd_xmm_k1z_xmmm128b32,
		EVEX_Vpabsd_ymm_k1z_ymmm256b32,
		EVEX_Vpabsd_zmm_k1z_zmmm512b32,
		EVEX_Vpabsq_xmm_k1z_xmmm128b64,
		EVEX_Vpabsq_ymm_k1z_ymmm256b64,
		EVEX_Vpabsq_zmm_k1z_zmmm512b64,
		Pmovsxbw_xmm_xmmm64,
		VEX_Vpmovsxbw_xmm_xmmm64,
		VEX_Vpmovsxbw_ymm_xmmm128,
		EVEX_Vpmovsxbw_xmm_k1z_xmmm64,
		EVEX_Vpmovsxbw_ymm_k1z_xmmm128,
		EVEX_Vpmovsxbw_zmm_k1z_ymmm256,
		EVEX_Vpmovswb_xmmm64_k1z_xmm,
		EVEX_Vpmovswb_xmmm128_k1z_ymm,
		EVEX_Vpmovswb_ymmm256_k1z_zmm,
		Pmovsxbd_xmm_xmmm32,
		VEX_Vpmovsxbd_xmm_xmmm32,
		VEX_Vpmovsxbd_ymm_xmmm64,
		EVEX_Vpmovsxbd_xmm_k1z_xmmm32,
		EVEX_Vpmovsxbd_ymm_k1z_xmmm64,
		EVEX_Vpmovsxbd_zmm_k1z_xmmm128,
		EVEX_Vpmovsdb_xmmm32_k1z_xmm,
		EVEX_Vpmovsdb_xmmm64_k1z_ymm,
		EVEX_Vpmovsdb_xmmm128_k1z_zmm,
		Pmovsxbq_xmm_xmmm16,
		VEX_Vpmovsxbq_xmm_xmmm16,
		VEX_Vpmovsxbq_ymm_xmmm32,
		EVEX_Vpmovsxbq_xmm_k1z_xmmm16,
		EVEX_Vpmovsxbq_ymm_k1z_xmmm32,
		EVEX_Vpmovsxbq_zmm_k1z_xmmm64,
		EVEX_Vpmovsqb_xmmm16_k1z_xmm,
		EVEX_Vpmovsqb_xmmm32_k1z_ymm,
		EVEX_Vpmovsqb_xmmm64_k1z_zmm,
		Pmovsxwd_xmm_xmmm64,
		VEX_Vpmovsxwd_xmm_xmmm64,
		VEX_Vpmovsxwd_ymm_xmmm128,
		EVEX_Vpmovsxwd_xmm_k1z_xmmm64,
		EVEX_Vpmovsxwd_ymm_k1z_xmmm128,
		EVEX_Vpmovsxwd_zmm_k1z_ymmm256,
		EVEX_Vpmovsdw_xmmm64_k1z_xmm,
		EVEX_Vpmovsdw_xmmm128_k1z_ymm,
		EVEX_Vpmovsdw_ymmm256_k1z_zmm,
		Pmovsxwq_xmm_xmmm32,
		VEX_Vpmovsxwq_xmm_xmmm32,
		VEX_Vpmovsxwq_ymm_xmmm64,
		EVEX_Vpmovsxwq_xmm_k1z_xmmm32,
		EVEX_Vpmovsxwq_ymm_k1z_xmmm64,
		EVEX_Vpmovsxwq_zmm_k1z_xmmm128,
		EVEX_Vpmovsqw_xmmm32_k1z_xmm,
		EVEX_Vpmovsqw_xmmm64_k1z_ymm,
		EVEX_Vpmovsqw_xmmm128_k1z_zmm,
		Pmovsxdq_xmm_xmmm64,
		VEX_Vpmovsxdq_xmm_xmmm64,
		VEX_Vpmovsxdq_ymm_xmmm128,
		EVEX_Vpmovsxdq_xmm_k1z_xmmm64,
		EVEX_Vpmovsxdq_ymm_k1z_xmmm128,
		EVEX_Vpmovsxdq_zmm_k1z_ymmm256,
		EVEX_Vpmovsqd_xmmm64_k1z_xmm,
		EVEX_Vpmovsqd_xmmm128_k1z_ymm,
		EVEX_Vpmovsqd_ymmm256_k1z_zmm,
		EVEX_Vptestmb_kr_k1_xmm_xmmm128,
		EVEX_Vptestmb_kr_k1_ymm_ymmm256,
		EVEX_Vptestmb_kr_k1_zmm_zmmm512,
		EVEX_Vptestmw_kr_k1_xmm_xmmm128,
		EVEX_Vptestmw_kr_k1_ymm_ymmm256,
		EVEX_Vptestmw_kr_k1_zmm_zmmm512,
		EVEX_Vptestnmb_kr_k1_xmm_xmmm128,
		EVEX_Vptestnmb_kr_k1_ymm_ymmm256,
		EVEX_Vptestnmb_kr_k1_zmm_zmmm512,
		EVEX_Vptestnmw_kr_k1_xmm_xmmm128,
		EVEX_Vptestnmw_kr_k1_ymm_ymmm256,
		EVEX_Vptestnmw_kr_k1_zmm_zmmm512,
		EVEX_Vptestmd_kr_k1_xmm_xmmm128b32,
		EVEX_Vptestmd_kr_k1_ymm_ymmm256b32,
		EVEX_Vptestmd_kr_k1_zmm_zmmm512b32,
		EVEX_Vptestmq_kr_k1_xmm_xmmm128b64,
		EVEX_Vptestmq_kr_k1_ymm_ymmm256b64,
		EVEX_Vptestmq_kr_k1_zmm_zmmm512b64,
		EVEX_Vptestnmd_kr_k1_xmm_xmmm128b32,
		EVEX_Vptestnmd_kr_k1_ymm_ymmm256b32,
		EVEX_Vptestnmd_kr_k1_zmm_zmmm512b32,
		EVEX_Vptestnmq_kr_k1_xmm_xmmm128b64,
		EVEX_Vptestnmq_kr_k1_ymm_ymmm256b64,
		EVEX_Vptestnmq_kr_k1_zmm_zmmm512b64,
		Pmuldq_xmm_xmmm128,
		VEX_Vpmuldq_xmm_xmm_xmmm128,
		VEX_Vpmuldq_ymm_ymm_ymmm256,
		EVEX_Vpmuldq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpmuldq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpmuldq_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vpmovm2b_xmm_kr,
		EVEX_Vpmovm2b_ymm_kr,
		EVEX_Vpmovm2b_zmm_kr,
		EVEX_Vpmovm2w_xmm_kr,
		EVEX_Vpmovm2w_ymm_kr,
		EVEX_Vpmovm2w_zmm_kr,
		Pcmpeqq_xmm_xmmm128,
		VEX_Vpcmpeqq_xmm_xmm_xmmm128,
		VEX_Vpcmpeqq_ymm_ymm_ymmm256,
		EVEX_Vpcmpeqq_kr_k1_xmm_xmmm128b64,
		EVEX_Vpcmpeqq_kr_k1_ymm_ymmm256b64,
		EVEX_Vpcmpeqq_kr_k1_zmm_zmmm512b64,
		EVEX_Vpmovb2m_kr_xmm,
		EVEX_Vpmovb2m_kr_ymm,
		EVEX_Vpmovb2m_kr_zmm,
		EVEX_Vpmovw2m_kr_xmm,
		EVEX_Vpmovw2m_kr_ymm,
		EVEX_Vpmovw2m_kr_zmm,
		Movntdqa_xmm_m128,
		VEX_Vmovntdqa_xmm_m128,
		VEX_Vmovntdqa_ymm_m256,
		EVEX_Vmovntdqa_xmm_m128,
		EVEX_Vmovntdqa_ymm_m256,
		EVEX_Vmovntdqa_zmm_m512,
		EVEX_Vpbroadcastmb2q_xmm_kr,
		EVEX_Vpbroadcastmb2q_ymm_kr,
		EVEX_Vpbroadcastmb2q_zmm_kr,
		Packusdw_xmm_xmmm128,
		VEX_Vpackusdw_xmm_xmm_xmmm128,
		VEX_Vpackusdw_ymm_ymm_ymmm256,
		EVEX_Vpackusdw_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpackusdw_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpackusdw_zmm_k1z_zmm_zmmm512b32,
		VEX_Vmaskmovps_xmm_xmm_m128,
		VEX_Vmaskmovps_ymm_ymm_m256,
		EVEX_Vscalefps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vscalefps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vscalefps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vscalefpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vscalefpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vscalefpd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vmaskmovpd_xmm_xmm_m128,
		VEX_Vmaskmovpd_ymm_ymm_m256,
		EVEX_Vscalefss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vscalefsd_xmm_k1z_xmm_xmmm64_er,
		VEX_Vmaskmovps_m128_xmm_xmm,
		VEX_Vmaskmovps_m256_ymm_ymm,
		VEX_Vmaskmovpd_m128_xmm_xmm,
		VEX_Vmaskmovpd_m256_ymm_ymm,
		Pmovzxbw_xmm_xmmm64,
		VEX_Vpmovzxbw_xmm_xmmm64,
		VEX_Vpmovzxbw_ymm_xmmm128,
		EVEX_Vpmovzxbw_xmm_k1z_xmmm64,
		EVEX_Vpmovzxbw_ymm_k1z_xmmm128,
		EVEX_Vpmovzxbw_zmm_k1z_ymmm256,
		EVEX_Vpmovwb_xmmm64_k1z_xmm,
		EVEX_Vpmovwb_xmmm128_k1z_ymm,
		EVEX_Vpmovwb_ymmm256_k1z_zmm,
		Pmovzxbd_xmm_xmmm32,
		VEX_Vpmovzxbd_xmm_xmmm32,
		VEX_Vpmovzxbd_ymm_xmmm64,
		EVEX_Vpmovzxbd_xmm_k1z_xmmm32,
		EVEX_Vpmovzxbd_ymm_k1z_xmmm64,
		EVEX_Vpmovzxbd_zmm_k1z_xmmm128,
		EVEX_Vpmovdb_xmmm32_k1z_xmm,
		EVEX_Vpmovdb_xmmm64_k1z_ymm,
		EVEX_Vpmovdb_xmmm128_k1z_zmm,
		Pmovzxbq_xmm_xmmm16,
		VEX_Vpmovzxbq_xmm_xmmm16,
		VEX_Vpmovzxbq_ymm_xmmm32,
		EVEX_Vpmovzxbq_xmm_k1z_xmmm16,
		EVEX_Vpmovzxbq_ymm_k1z_xmmm32,
		EVEX_Vpmovzxbq_zmm_k1z_xmmm64,
		EVEX_Vpmovqb_xmmm16_k1z_xmm,
		EVEX_Vpmovqb_xmmm32_k1z_ymm,
		EVEX_Vpmovqb_xmmm64_k1z_zmm,
		Pmovzxwd_xmm_xmmm64,
		VEX_Vpmovzxwd_xmm_xmmm64,
		VEX_Vpmovzxwd_ymm_xmmm128,
		EVEX_Vpmovzxwd_xmm_k1z_xmmm64,
		EVEX_Vpmovzxwd_ymm_k1z_xmmm128,
		EVEX_Vpmovzxwd_zmm_k1z_ymmm256,
		EVEX_Vpmovdw_xmmm64_k1z_xmm,
		EVEX_Vpmovdw_xmmm128_k1z_ymm,
		EVEX_Vpmovdw_ymmm256_k1z_zmm,
		Pmovzxwq_xmm_xmmm32,
		VEX_Vpmovzxwq_xmm_xmmm32,
		VEX_Vpmovzxwq_ymm_xmmm64,
		EVEX_Vpmovzxwq_xmm_k1z_xmmm32,
		EVEX_Vpmovzxwq_ymm_k1z_xmmm64,
		EVEX_Vpmovzxwq_zmm_k1z_xmmm128,
		EVEX_Vpmovqw_xmmm32_k1z_xmm,
		EVEX_Vpmovqw_xmmm64_k1z_ymm,
		EVEX_Vpmovqw_xmmm128_k1z_zmm,
		Pmovzxdq_xmm_xmmm64,
		VEX_Vpmovzxdq_xmm_xmmm64,
		VEX_Vpmovzxdq_ymm_xmmm128,
		EVEX_Vpmovzxdq_xmm_k1z_xmmm64,
		EVEX_Vpmovzxdq_ymm_k1z_xmmm128,
		EVEX_Vpmovzxdq_zmm_k1z_ymmm256,
		EVEX_Vpmovqd_xmmm64_k1z_xmm,
		EVEX_Vpmovqd_xmmm128_k1z_ymm,
		EVEX_Vpmovqd_ymmm256_k1z_zmm,
		VEX_Vpermd_ymm_ymm_ymmm256,
		EVEX_Vpermd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpermd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpermq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpermq_zmm_k1z_zmm_zmmm512b64,
		Pcmpgtq_xmm_xmmm128,
		VEX_Vpcmpgtq_xmm_xmm_xmmm128,
		VEX_Vpcmpgtq_ymm_ymm_ymmm256,
		EVEX_Vpcmpgtq_kr_k1_xmm_xmmm128b64,
		EVEX_Vpcmpgtq_kr_k1_ymm_ymmm256b64,
		EVEX_Vpcmpgtq_kr_k1_zmm_zmmm512b64,
		Pminsb_xmm_xmmm128,
		VEX_Vpminsb_xmm_xmm_xmmm128,
		VEX_Vpminsb_ymm_ymm_ymmm256,
		EVEX_Vpminsb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpminsb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpminsb_zmm_k1z_zmm_zmmm512,
		EVEX_Vpmovm2d_xmm_kr,
		EVEX_Vpmovm2d_ymm_kr,
		EVEX_Vpmovm2d_zmm_kr,
		EVEX_Vpmovm2q_xmm_kr,
		EVEX_Vpmovm2q_ymm_kr,
		EVEX_Vpmovm2q_zmm_kr,
		Pminsd_xmm_xmmm128,
		VEX_Vpminsd_xmm_xmm_xmmm128,
		VEX_Vpminsd_ymm_ymm_ymmm256,
		EVEX_Vpminsd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpminsd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpminsd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpminsq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpminsq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpminsq_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vpmovd2m_kr_xmm,
		EVEX_Vpmovd2m_kr_ymm,
		EVEX_Vpmovd2m_kr_zmm,
		EVEX_Vpmovq2m_kr_xmm,
		EVEX_Vpmovq2m_kr_ymm,
		EVEX_Vpmovq2m_kr_zmm,
		Pminuw_xmm_xmmm128,
		VEX_Vpminuw_xmm_xmm_xmmm128,
		VEX_Vpminuw_ymm_ymm_ymmm256,
		EVEX_Vpminuw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpminuw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpminuw_zmm_k1z_zmm_zmmm512,
		EVEX_Vpbroadcastmw2d_xmm_kr,
		EVEX_Vpbroadcastmw2d_ymm_kr,
		EVEX_Vpbroadcastmw2d_zmm_kr,
		Pminud_xmm_xmmm128,
		VEX_Vpminud_xmm_xmm_xmmm128,
		VEX_Vpminud_ymm_ymm_ymmm256,
		EVEX_Vpminud_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpminud_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpminud_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpminuq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpminuq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpminuq_zmm_k1z_zmm_zmmm512b64,
		Pmaxsb_xmm_xmmm128,
		VEX_Vpmaxsb_xmm_xmm_xmmm128,
		VEX_Vpmaxsb_ymm_ymm_ymmm256,
		EVEX_Vpmaxsb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpmaxsb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpmaxsb_zmm_k1z_zmm_zmmm512,
		Pmaxsd_xmm_xmmm128,
		VEX_Vpmaxsd_xmm_xmm_xmmm128,
		VEX_Vpmaxsd_ymm_ymm_ymmm256,
		EVEX_Vpmaxsd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpmaxsd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpmaxsd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpmaxsq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpmaxsq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpmaxsq_zmm_k1z_zmm_zmmm512b64,
		Pmaxuw_xmm_xmmm128,
		VEX_Vpmaxuw_xmm_xmm_xmmm128,
		VEX_Vpmaxuw_ymm_ymm_ymmm256,
		EVEX_Vpmaxuw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpmaxuw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpmaxuw_zmm_k1z_zmm_zmmm512,
		Pmaxud_xmm_xmmm128,
		VEX_Vpmaxud_xmm_xmm_xmmm128,
		VEX_Vpmaxud_ymm_ymm_ymmm256,
		EVEX_Vpmaxud_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpmaxud_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpmaxud_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpmaxuq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpmaxuq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpmaxuq_zmm_k1z_zmm_zmmm512b64,
		Pmulld_xmm_xmmm128,
		VEX_Vpmulld_xmm_xmm_xmmm128,
		VEX_Vpmulld_ymm_ymm_ymmm256,
		EVEX_Vpmulld_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpmulld_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpmulld_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpmullq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpmullq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpmullq_zmm_k1z_zmm_zmmm512b64,
		Phminposuw_xmm_xmmm128,
		VEX_Vphminposuw_xmm_xmmm128,
		EVEX_Vgetexpps_xmm_k1z_xmmm128b32,
		EVEX_Vgetexpps_ymm_k1z_ymmm256b32,
		EVEX_Vgetexpps_zmm_k1z_zmmm512b32_sae,
		EVEX_Vgetexppd_xmm_k1z_xmmm128b64,
		EVEX_Vgetexppd_ymm_k1z_ymmm256b64,
		EVEX_Vgetexppd_zmm_k1z_zmmm512b64_sae,
		EVEX_Vgetexpss_xmm_k1z_xmm_xmmm32_sae,
		EVEX_Vgetexpsd_xmm_k1z_xmm_xmmm64_sae,
		EVEX_Vplzcntd_xmm_k1z_xmmm128b32,
		EVEX_Vplzcntd_ymm_k1z_ymmm256b32,
		EVEX_Vplzcntd_zmm_k1z_zmmm512b32,
		EVEX_Vplzcntq_xmm_k1z_xmmm128b64,
		EVEX_Vplzcntq_ymm_k1z_ymmm256b64,
		EVEX_Vplzcntq_zmm_k1z_zmmm512b64,
		VEX_Vpsrlvd_xmm_xmm_xmmm128,
		VEX_Vpsrlvd_ymm_ymm_ymmm256,
		VEX_Vpsrlvq_xmm_xmm_xmmm128,
		VEX_Vpsrlvq_ymm_ymm_ymmm256,
		EVEX_Vpsrlvd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpsrlvd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpsrlvd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpsrlvq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpsrlvq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpsrlvq_zmm_k1z_zmm_zmmm512b64,
		VEX_Vpsravd_xmm_xmm_xmmm128,
		VEX_Vpsravd_ymm_ymm_ymmm256,
		EVEX_Vpsravd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpsravd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpsravd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpsravq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpsravq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpsravq_zmm_k1z_zmm_zmmm512b64,
		VEX_Vpsllvd_xmm_xmm_xmmm128,
		VEX_Vpsllvd_ymm_ymm_ymmm256,
		VEX_Vpsllvq_xmm_xmm_xmmm128,
		VEX_Vpsllvq_ymm_ymm_ymmm256,
		EVEX_Vpsllvd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpsllvd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpsllvd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpsllvq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpsllvq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpsllvq_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vrcp14ps_xmm_k1z_xmmm128b32,
		EVEX_Vrcp14ps_ymm_k1z_ymmm256b32,
		EVEX_Vrcp14ps_zmm_k1z_zmmm512b32,
		EVEX_Vrcp14pd_xmm_k1z_xmmm128b64,
		EVEX_Vrcp14pd_ymm_k1z_ymmm256b64,
		EVEX_Vrcp14pd_zmm_k1z_zmmm512b64,
		EVEX_Vrcp14ss_xmm_k1z_xmm_xmmm32,
		EVEX_Vrcp14sd_xmm_k1z_xmm_xmmm64,
		EVEX_Vrsqrt14ps_xmm_k1z_xmmm128b32,
		EVEX_Vrsqrt14ps_ymm_k1z_ymmm256b32,
		EVEX_Vrsqrt14ps_zmm_k1z_zmmm512b32,
		EVEX_Vrsqrt14pd_xmm_k1z_xmmm128b64,
		EVEX_Vrsqrt14pd_ymm_k1z_ymmm256b64,
		EVEX_Vrsqrt14pd_zmm_k1z_zmmm512b64,
		EVEX_Vrsqrt14ss_xmm_k1z_xmm_xmmm32,
		EVEX_Vrsqrt14sd_xmm_k1z_xmm_xmmm64,
		EVEX_Vpdpbusd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpdpbusd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpdpbusd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpdpbusds_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpdpbusds_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpdpbusds_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpdpwssd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpdpwssd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpdpwssd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vdpbf16ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vdpbf16ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vdpbf16ps_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vp4dpwssd_zmm_k1z_zmmp3_m128,
		EVEX_Vpdpwssds_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpdpwssds_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpdpwssds_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vp4dpwssds_zmm_k1z_zmmp3_m128,
		EVEX_Vpopcntb_xmm_k1z_xmmm128,
		EVEX_Vpopcntb_ymm_k1z_ymmm256,
		EVEX_Vpopcntb_zmm_k1z_zmmm512,
		EVEX_Vpopcntw_xmm_k1z_xmmm128,
		EVEX_Vpopcntw_ymm_k1z_ymmm256,
		EVEX_Vpopcntw_zmm_k1z_zmmm512,
		EVEX_Vpopcntd_xmm_k1z_xmmm128b32,
		EVEX_Vpopcntd_ymm_k1z_ymmm256b32,
		EVEX_Vpopcntd_zmm_k1z_zmmm512b32,
		EVEX_Vpopcntq_xmm_k1z_xmmm128b64,
		EVEX_Vpopcntq_ymm_k1z_ymmm256b64,
		EVEX_Vpopcntq_zmm_k1z_zmmm512b64,
		VEX_Vpbroadcastd_xmm_xmmm32,
		VEX_Vpbroadcastd_ymm_xmmm32,
		EVEX_Vpbroadcastd_xmm_k1z_xmmm32,
		EVEX_Vpbroadcastd_ymm_k1z_xmmm32,
		EVEX_Vpbroadcastd_zmm_k1z_xmmm32,
		VEX_Vpbroadcastq_xmm_xmmm64,
		VEX_Vpbroadcastq_ymm_xmmm64,
		EVEX_Vbroadcasti32x2_xmm_k1z_xmmm64,
		EVEX_Vbroadcasti32x2_ymm_k1z_xmmm64,
		EVEX_Vbroadcasti32x2_zmm_k1z_xmmm64,
		EVEX_Vpbroadcastq_xmm_k1z_xmmm64,
		EVEX_Vpbroadcastq_ymm_k1z_xmmm64,
		EVEX_Vpbroadcastq_zmm_k1z_xmmm64,
		VEX_Vbroadcasti128_ymm_m128,
		EVEX_Vbroadcasti32x4_ymm_k1z_m128,
		EVEX_Vbroadcasti32x4_zmm_k1z_m128,
		EVEX_Vbroadcasti64x2_ymm_k1z_m128,
		EVEX_Vbroadcasti64x2_zmm_k1z_m128,
		EVEX_Vbroadcasti32x8_zmm_k1z_m256,
		EVEX_Vbroadcasti64x4_zmm_k1z_m256,
		EVEX_Vpexpandb_xmm_k1z_xmmm128,
		EVEX_Vpexpandb_ymm_k1z_ymmm256,
		EVEX_Vpexpandb_zmm_k1z_zmmm512,
		EVEX_Vpexpandw_xmm_k1z_xmmm128,
		EVEX_Vpexpandw_ymm_k1z_ymmm256,
		EVEX_Vpexpandw_zmm_k1z_zmmm512,
		EVEX_Vpcompressb_xmmm128_k1z_xmm,
		EVEX_Vpcompressb_ymmm256_k1z_ymm,
		EVEX_Vpcompressb_zmmm512_k1z_zmm,
		EVEX_Vpcompressw_xmmm128_k1z_xmm,
		EVEX_Vpcompressw_ymmm256_k1z_ymm,
		EVEX_Vpcompressw_zmmm512_k1z_zmm,
		EVEX_Vpblendmd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpblendmd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpblendmd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpblendmq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpblendmq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpblendmq_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vblendmps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vblendmps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vblendmps_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vblendmpd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vblendmpd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vblendmpd_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vpblendmb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpblendmb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpblendmb_zmm_k1z_zmm_zmmm512,
		EVEX_Vpblendmw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpblendmw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpblendmw_zmm_k1z_zmm_zmmm512,
		EVEX_Vp2intersectd_kp1_xmm_xmmm128b32,
		EVEX_Vp2intersectd_kp1_ymm_ymmm256b32,
		EVEX_Vp2intersectd_kp1_zmm_zmmm512b32,
		EVEX_Vp2intersectq_kp1_xmm_xmmm128b64,
		EVEX_Vp2intersectq_kp1_ymm_ymmm256b64,
		EVEX_Vp2intersectq_kp1_zmm_zmmm512b64,
		EVEX_Vpshldvw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpshldvw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpshldvw_zmm_k1z_zmm_zmmm512,
		EVEX_Vpshldvd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpshldvd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpshldvd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpshldvq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpshldvq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpshldvq_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vpshrdvw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpshrdvw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpshrdvw_zmm_k1z_zmm_zmmm512,
		EVEX_Vcvtneps2bf16_xmm_k1z_xmmm128b32,
		EVEX_Vcvtneps2bf16_xmm_k1z_ymmm256b32,
		EVEX_Vcvtneps2bf16_ymm_k1z_zmmm512b32,
		EVEX_Vcvtne2ps2bf16_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vcvtne2ps2bf16_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vcvtne2ps2bf16_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpshrdvd_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpshrdvd_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpshrdvd_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpshrdvq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpshrdvq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpshrdvq_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vpermi2b_xmm_k1z_xmm_xmmm128,
		EVEX_Vpermi2b_ymm_k1z_ymm_ymmm256,
		EVEX_Vpermi2b_zmm_k1z_zmm_zmmm512,
		EVEX_Vpermi2w_xmm_k1z_xmm_xmmm128,
		EVEX_Vpermi2w_ymm_k1z_ymm_ymmm256,
		EVEX_Vpermi2w_zmm_k1z_zmm_zmmm512,
		EVEX_Vpermi2d_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpermi2d_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpermi2d_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpermi2q_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpermi2q_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpermi2q_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vpermi2ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpermi2ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpermi2ps_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpermi2pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpermi2pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpermi2pd_zmm_k1z_zmm_zmmm512b64,
		VEX_Vpbroadcastb_xmm_xmmm8,
		VEX_Vpbroadcastb_ymm_xmmm8,
		EVEX_Vpbroadcastb_xmm_k1z_xmmm8,
		EVEX_Vpbroadcastb_ymm_k1z_xmmm8,
		EVEX_Vpbroadcastb_zmm_k1z_xmmm8,
		VEX_Vpbroadcastw_xmm_xmmm16,
		VEX_Vpbroadcastw_ymm_xmmm16,
		EVEX_Vpbroadcastw_xmm_k1z_xmmm16,
		EVEX_Vpbroadcastw_ymm_k1z_xmmm16,
		EVEX_Vpbroadcastw_zmm_k1z_xmmm16,
		EVEX_Vpbroadcastb_xmm_k1z_r32,
		EVEX_Vpbroadcastb_ymm_k1z_r32,
		EVEX_Vpbroadcastb_zmm_k1z_r32,
		EVEX_Vpbroadcastw_xmm_k1z_r32,
		EVEX_Vpbroadcastw_ymm_k1z_r32,
		EVEX_Vpbroadcastw_zmm_k1z_r32,
		EVEX_Vpbroadcastd_xmm_k1z_r32,
		EVEX_Vpbroadcastd_ymm_k1z_r32,
		EVEX_Vpbroadcastd_zmm_k1z_r32,
		EVEX_Vpbroadcastq_xmm_k1z_r64,
		EVEX_Vpbroadcastq_ymm_k1z_r64,
		EVEX_Vpbroadcastq_zmm_k1z_r64,
		EVEX_Vpermt2b_xmm_k1z_xmm_xmmm128,
		EVEX_Vpermt2b_ymm_k1z_ymm_ymmm256,
		EVEX_Vpermt2b_zmm_k1z_zmm_zmmm512,
		EVEX_Vpermt2w_xmm_k1z_xmm_xmmm128,
		EVEX_Vpermt2w_ymm_k1z_ymm_ymmm256,
		EVEX_Vpermt2w_zmm_k1z_zmm_zmmm512,
		EVEX_Vpermt2d_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpermt2d_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpermt2d_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpermt2q_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpermt2q_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpermt2q_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vpermt2ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vpermt2ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vpermt2ps_zmm_k1z_zmm_zmmm512b32,
		EVEX_Vpermt2pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpermt2pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpermt2pd_zmm_k1z_zmm_zmmm512b64,
		Invept_r32_m128,
		Invept_r64_m128,
		Invvpid_r32_m128,
		Invvpid_r64_m128,
		Invpcid_r32_m128,
		Invpcid_r64_m128,
		EVEX_Vpmultishiftqb_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpmultishiftqb_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpmultishiftqb_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vexpandps_xmm_k1z_xmmm128,
		EVEX_Vexpandps_ymm_k1z_ymmm256,
		EVEX_Vexpandps_zmm_k1z_zmmm512,
		EVEX_Vexpandpd_xmm_k1z_xmmm128,
		EVEX_Vexpandpd_ymm_k1z_ymmm256,
		EVEX_Vexpandpd_zmm_k1z_zmmm512,
		EVEX_Vpexpandd_xmm_k1z_xmmm128,
		EVEX_Vpexpandd_ymm_k1z_ymmm256,
		EVEX_Vpexpandd_zmm_k1z_zmmm512,
		EVEX_Vpexpandq_xmm_k1z_xmmm128,
		EVEX_Vpexpandq_ymm_k1z_ymmm256,
		EVEX_Vpexpandq_zmm_k1z_zmmm512,
		EVEX_Vcompressps_xmmm128_k1z_xmm,
		EVEX_Vcompressps_ymmm256_k1z_ymm,
		EVEX_Vcompressps_zmmm512_k1z_zmm,
		EVEX_Vcompresspd_xmmm128_k1z_xmm,
		EVEX_Vcompresspd_ymmm256_k1z_ymm,
		EVEX_Vcompresspd_zmmm512_k1z_zmm,
		EVEX_Vpcompressd_xmmm128_k1z_xmm,
		EVEX_Vpcompressd_ymmm256_k1z_ymm,
		EVEX_Vpcompressd_zmmm512_k1z_zmm,
		EVEX_Vpcompressq_xmmm128_k1z_xmm,
		EVEX_Vpcompressq_ymmm256_k1z_ymm,
		EVEX_Vpcompressq_zmmm512_k1z_zmm,
		VEX_Vpmaskmovd_xmm_xmm_m128,
		VEX_Vpmaskmovd_ymm_ymm_m256,
		VEX_Vpmaskmovq_xmm_xmm_m128,
		VEX_Vpmaskmovq_ymm_ymm_m256,
		EVEX_Vpermb_xmm_k1z_xmm_xmmm128,
		EVEX_Vpermb_ymm_k1z_ymm_ymmm256,
		EVEX_Vpermb_zmm_k1z_zmm_zmmm512,
		EVEX_Vpermw_xmm_k1z_xmm_xmmm128,
		EVEX_Vpermw_ymm_k1z_ymm_ymmm256,
		EVEX_Vpermw_zmm_k1z_zmm_zmmm512,
		VEX_Vpmaskmovd_m128_xmm_xmm,
		VEX_Vpmaskmovd_m256_ymm_ymm,
		VEX_Vpmaskmovq_m128_xmm_xmm,
		VEX_Vpmaskmovq_m256_ymm_ymm,
		EVEX_Vpshufbitqmb_kr_k1_xmm_xmmm128,
		EVEX_Vpshufbitqmb_kr_k1_ymm_ymmm256,
		EVEX_Vpshufbitqmb_kr_k1_zmm_zmmm512,
		VEX_Vpgatherdd_xmm_vm32x_xmm,
		VEX_Vpgatherdd_ymm_vm32y_ymm,
		VEX_Vpgatherdq_xmm_vm32x_xmm,
		VEX_Vpgatherdq_ymm_vm32x_ymm,
		EVEX_Vpgatherdd_xmm_k1_vm32x,
		EVEX_Vpgatherdd_ymm_k1_vm32y,
		EVEX_Vpgatherdd_zmm_k1_vm32z,
		EVEX_Vpgatherdq_xmm_k1_vm32x,
		EVEX_Vpgatherdq_ymm_k1_vm32x,
		EVEX_Vpgatherdq_zmm_k1_vm32y,
		VEX_Vpgatherqd_xmm_vm64x_xmm,
		VEX_Vpgatherqd_xmm_vm64y_xmm,
		VEX_Vpgatherqq_xmm_vm64x_xmm,
		VEX_Vpgatherqq_ymm_vm64y_ymm,
		EVEX_Vpgatherqd_xmm_k1_vm64x,
		EVEX_Vpgatherqd_xmm_k1_vm64y,
		EVEX_Vpgatherqd_ymm_k1_vm64z,
		EVEX_Vpgatherqq_xmm_k1_vm64x,
		EVEX_Vpgatherqq_ymm_k1_vm64y,
		EVEX_Vpgatherqq_zmm_k1_vm64z,
		VEX_Vgatherdps_xmm_vm32x_xmm,
		VEX_Vgatherdps_ymm_vm32y_ymm,
		VEX_Vgatherdpd_xmm_vm32x_xmm,
		VEX_Vgatherdpd_ymm_vm32x_ymm,
		EVEX_Vgatherdps_xmm_k1_vm32x,
		EVEX_Vgatherdps_ymm_k1_vm32y,
		EVEX_Vgatherdps_zmm_k1_vm32z,
		EVEX_Vgatherdpd_xmm_k1_vm32x,
		EVEX_Vgatherdpd_ymm_k1_vm32x,
		EVEX_Vgatherdpd_zmm_k1_vm32y,
		VEX_Vgatherqps_xmm_vm64x_xmm,
		VEX_Vgatherqps_xmm_vm64y_xmm,
		VEX_Vgatherqpd_xmm_vm64x_xmm,
		VEX_Vgatherqpd_ymm_vm64y_ymm,
		EVEX_Vgatherqps_xmm_k1_vm64x,
		EVEX_Vgatherqps_xmm_k1_vm64y,
		EVEX_Vgatherqps_ymm_k1_vm64z,
		EVEX_Vgatherqpd_xmm_k1_vm64x,
		EVEX_Vgatherqpd_ymm_k1_vm64y,
		EVEX_Vgatherqpd_zmm_k1_vm64z,
		VEX_Vfmaddsub132ps_xmm_xmm_xmmm128,
		VEX_Vfmaddsub132ps_ymm_ymm_ymmm256,
		VEX_Vfmaddsub132pd_xmm_xmm_xmmm128,
		VEX_Vfmaddsub132pd_ymm_ymm_ymmm256,
		EVEX_Vfmaddsub132ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmaddsub132ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmaddsub132ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmaddsub132pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmaddsub132pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmaddsub132pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfmsubadd132ps_xmm_xmm_xmmm128,
		VEX_Vfmsubadd132ps_ymm_ymm_ymmm256,
		VEX_Vfmsubadd132pd_xmm_xmm_xmmm128,
		VEX_Vfmsubadd132pd_ymm_ymm_ymmm256,
		EVEX_Vfmsubadd132ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmsubadd132ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmsubadd132ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmsubadd132pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmsubadd132pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmsubadd132pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfmadd132ps_xmm_xmm_xmmm128,
		VEX_Vfmadd132ps_ymm_ymm_ymmm256,
		VEX_Vfmadd132pd_xmm_xmm_xmmm128,
		VEX_Vfmadd132pd_ymm_ymm_ymmm256,
		EVEX_Vfmadd132ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmadd132ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmadd132ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmadd132pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmadd132pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmadd132pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfmadd132ss_xmm_xmm_xmmm32,
		VEX_Vfmadd132sd_xmm_xmm_xmmm64,
		EVEX_Vfmadd132ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfmadd132sd_xmm_k1z_xmm_xmmm64_er,
		VEX_Vfmsub132ps_xmm_xmm_xmmm128,
		VEX_Vfmsub132ps_ymm_ymm_ymmm256,
		VEX_Vfmsub132pd_xmm_xmm_xmmm128,
		VEX_Vfmsub132pd_ymm_ymm_ymmm256,
		EVEX_Vfmsub132ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmsub132ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmsub132ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmsub132pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmsub132pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmsub132pd_zmm_k1z_zmm_zmmm512b64_er,
		EVEX_V4fmaddps_zmm_k1z_zmmp3_m128,
		VEX_Vfmsub132ss_xmm_xmm_xmmm32,
		VEX_Vfmsub132sd_xmm_xmm_xmmm64,
		EVEX_Vfmsub132ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfmsub132sd_xmm_k1z_xmm_xmmm64_er,
		EVEX_V4fmaddss_xmm_k1z_xmmp3_m128,
		VEX_Vfnmadd132ps_xmm_xmm_xmmm128,
		VEX_Vfnmadd132ps_ymm_ymm_ymmm256,
		VEX_Vfnmadd132pd_xmm_xmm_xmmm128,
		VEX_Vfnmadd132pd_ymm_ymm_ymmm256,
		EVEX_Vfnmadd132ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfnmadd132ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfnmadd132ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfnmadd132pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfnmadd132pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfnmadd132pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfnmadd132ss_xmm_xmm_xmmm32,
		VEX_Vfnmadd132sd_xmm_xmm_xmmm64,
		EVEX_Vfnmadd132ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfnmadd132sd_xmm_k1z_xmm_xmmm64_er,
		VEX_Vfnmsub132ps_xmm_xmm_xmmm128,
		VEX_Vfnmsub132ps_ymm_ymm_ymmm256,
		VEX_Vfnmsub132pd_xmm_xmm_xmmm128,
		VEX_Vfnmsub132pd_ymm_ymm_ymmm256,
		EVEX_Vfnmsub132ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfnmsub132ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfnmsub132ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfnmsub132pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfnmsub132pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfnmsub132pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfnmsub132ss_xmm_xmm_xmmm32,
		VEX_Vfnmsub132sd_xmm_xmm_xmmm64,
		EVEX_Vfnmsub132ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfnmsub132sd_xmm_k1z_xmm_xmmm64_er,
		EVEX_Vpscatterdd_vm32x_k1_xmm,
		EVEX_Vpscatterdd_vm32y_k1_ymm,
		EVEX_Vpscatterdd_vm32z_k1_zmm,
		EVEX_Vpscatterdq_vm32x_k1_xmm,
		EVEX_Vpscatterdq_vm32x_k1_ymm,
		EVEX_Vpscatterdq_vm32y_k1_zmm,
		EVEX_Vpscatterqd_vm64x_k1_xmm,
		EVEX_Vpscatterqd_vm64y_k1_xmm,
		EVEX_Vpscatterqd_vm64z_k1_ymm,
		EVEX_Vpscatterqq_vm64x_k1_xmm,
		EVEX_Vpscatterqq_vm64y_k1_ymm,
		EVEX_Vpscatterqq_vm64z_k1_zmm,
		EVEX_Vscatterdps_vm32x_k1_xmm,
		EVEX_Vscatterdps_vm32y_k1_ymm,
		EVEX_Vscatterdps_vm32z_k1_zmm,
		EVEX_Vscatterdpd_vm32x_k1_xmm,
		EVEX_Vscatterdpd_vm32x_k1_ymm,
		EVEX_Vscatterdpd_vm32y_k1_zmm,
		EVEX_Vscatterqps_vm64x_k1_xmm,
		EVEX_Vscatterqps_vm64y_k1_xmm,
		EVEX_Vscatterqps_vm64z_k1_ymm,
		EVEX_Vscatterqpd_vm64x_k1_xmm,
		EVEX_Vscatterqpd_vm64y_k1_ymm,
		EVEX_Vscatterqpd_vm64z_k1_zmm,
		VEX_Vfmaddsub213ps_xmm_xmm_xmmm128,
		VEX_Vfmaddsub213ps_ymm_ymm_ymmm256,
		VEX_Vfmaddsub213pd_xmm_xmm_xmmm128,
		VEX_Vfmaddsub213pd_ymm_ymm_ymmm256,
		EVEX_Vfmaddsub213ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmaddsub213ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmaddsub213ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmaddsub213pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmaddsub213pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmaddsub213pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfmsubadd213ps_xmm_xmm_xmmm128,
		VEX_Vfmsubadd213ps_ymm_ymm_ymmm256,
		VEX_Vfmsubadd213pd_xmm_xmm_xmmm128,
		VEX_Vfmsubadd213pd_ymm_ymm_ymmm256,
		EVEX_Vfmsubadd213ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmsubadd213ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmsubadd213ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmsubadd213pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmsubadd213pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmsubadd213pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfmadd213ps_xmm_xmm_xmmm128,
		VEX_Vfmadd213ps_ymm_ymm_ymmm256,
		VEX_Vfmadd213pd_xmm_xmm_xmmm128,
		VEX_Vfmadd213pd_ymm_ymm_ymmm256,
		EVEX_Vfmadd213ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmadd213ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmadd213ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmadd213pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmadd213pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmadd213pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfmadd213ss_xmm_xmm_xmmm32,
		VEX_Vfmadd213sd_xmm_xmm_xmmm64,
		EVEX_Vfmadd213ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfmadd213sd_xmm_k1z_xmm_xmmm64_er,
		VEX_Vfmsub213ps_xmm_xmm_xmmm128,
		VEX_Vfmsub213ps_ymm_ymm_ymmm256,
		VEX_Vfmsub213pd_xmm_xmm_xmmm128,
		VEX_Vfmsub213pd_ymm_ymm_ymmm256,
		EVEX_Vfmsub213ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmsub213ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmsub213ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmsub213pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmsub213pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmsub213pd_zmm_k1z_zmm_zmmm512b64_er,
		EVEX_V4fnmaddps_zmm_k1z_zmmp3_m128,
		VEX_Vfmsub213ss_xmm_xmm_xmmm32,
		VEX_Vfmsub213sd_xmm_xmm_xmmm64,
		EVEX_Vfmsub213ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfmsub213sd_xmm_k1z_xmm_xmmm64_er,
		EVEX_V4fnmaddss_xmm_k1z_xmmp3_m128,
		VEX_Vfnmadd213ps_xmm_xmm_xmmm128,
		VEX_Vfnmadd213ps_ymm_ymm_ymmm256,
		VEX_Vfnmadd213pd_xmm_xmm_xmmm128,
		VEX_Vfnmadd213pd_ymm_ymm_ymmm256,
		EVEX_Vfnmadd213ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfnmadd213ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfnmadd213ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfnmadd213pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfnmadd213pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfnmadd213pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfnmadd213ss_xmm_xmm_xmmm32,
		VEX_Vfnmadd213sd_xmm_xmm_xmmm64,
		EVEX_Vfnmadd213ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfnmadd213sd_xmm_k1z_xmm_xmmm64_er,
		VEX_Vfnmsub213ps_xmm_xmm_xmmm128,
		VEX_Vfnmsub213ps_ymm_ymm_ymmm256,
		VEX_Vfnmsub213pd_xmm_xmm_xmmm128,
		VEX_Vfnmsub213pd_ymm_ymm_ymmm256,
		EVEX_Vfnmsub213ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfnmsub213ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfnmsub213ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfnmsub213pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfnmsub213pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfnmsub213pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfnmsub213ss_xmm_xmm_xmmm32,
		VEX_Vfnmsub213sd_xmm_xmm_xmmm64,
		EVEX_Vfnmsub213ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfnmsub213sd_xmm_k1z_xmm_xmmm64_er,
		EVEX_Vpmadd52luq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpmadd52luq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpmadd52luq_zmm_k1z_zmm_zmmm512b64,
		EVEX_Vpmadd52huq_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vpmadd52huq_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vpmadd52huq_zmm_k1z_zmm_zmmm512b64,
		VEX_Vfmaddsub231ps_xmm_xmm_xmmm128,
		VEX_Vfmaddsub231ps_ymm_ymm_ymmm256,
		VEX_Vfmaddsub231pd_xmm_xmm_xmmm128,
		VEX_Vfmaddsub231pd_ymm_ymm_ymmm256,
		EVEX_Vfmaddsub231ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmaddsub231ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmaddsub231ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmaddsub231pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmaddsub231pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmaddsub231pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfmsubadd231ps_xmm_xmm_xmmm128,
		VEX_Vfmsubadd231ps_ymm_ymm_ymmm256,
		VEX_Vfmsubadd231pd_xmm_xmm_xmmm128,
		VEX_Vfmsubadd231pd_ymm_ymm_ymmm256,
		EVEX_Vfmsubadd231ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmsubadd231ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmsubadd231ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmsubadd231pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmsubadd231pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmsubadd231pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfmadd231ps_xmm_xmm_xmmm128,
		VEX_Vfmadd231ps_ymm_ymm_ymmm256,
		VEX_Vfmadd231pd_xmm_xmm_xmmm128,
		VEX_Vfmadd231pd_ymm_ymm_ymmm256,
		EVEX_Vfmadd231ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmadd231ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmadd231ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmadd231pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmadd231pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmadd231pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfmadd231ss_xmm_xmm_xmmm32,
		VEX_Vfmadd231sd_xmm_xmm_xmmm64,
		EVEX_Vfmadd231ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfmadd231sd_xmm_k1z_xmm_xmmm64_er,
		VEX_Vfmsub231ps_xmm_xmm_xmmm128,
		VEX_Vfmsub231ps_ymm_ymm_ymmm256,
		VEX_Vfmsub231pd_xmm_xmm_xmmm128,
		VEX_Vfmsub231pd_ymm_ymm_ymmm256,
		EVEX_Vfmsub231ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmsub231ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmsub231ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmsub231pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfmsub231pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfmsub231pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfmsub231ss_xmm_xmm_xmmm32,
		VEX_Vfmsub231sd_xmm_xmm_xmmm64,
		EVEX_Vfmsub231ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfmsub231sd_xmm_k1z_xmm_xmmm64_er,
		VEX_Vfnmadd231ps_xmm_xmm_xmmm128,
		VEX_Vfnmadd231ps_ymm_ymm_ymmm256,
		VEX_Vfnmadd231pd_xmm_xmm_xmmm128,
		VEX_Vfnmadd231pd_ymm_ymm_ymmm256,
		EVEX_Vfnmadd231ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfnmadd231ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfnmadd231ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfnmadd231pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfnmadd231pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfnmadd231pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfnmadd231ss_xmm_xmm_xmmm32,
		VEX_Vfnmadd231sd_xmm_xmm_xmmm64,
		EVEX_Vfnmadd231ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfnmadd231sd_xmm_k1z_xmm_xmmm64_er,
		VEX_Vfnmsub231ps_xmm_xmm_xmmm128,
		VEX_Vfnmsub231ps_ymm_ymm_ymmm256,
		VEX_Vfnmsub231pd_xmm_xmm_xmmm128,
		VEX_Vfnmsub231pd_ymm_ymm_ymmm256,
		EVEX_Vfnmsub231ps_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfnmsub231ps_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfnmsub231ps_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfnmsub231pd_xmm_k1z_xmm_xmmm128b64,
		EVEX_Vfnmsub231pd_ymm_k1z_ymm_ymmm256b64,
		EVEX_Vfnmsub231pd_zmm_k1z_zmm_zmmm512b64_er,
		VEX_Vfnmsub231ss_xmm_xmm_xmmm32,
		VEX_Vfnmsub231sd_xmm_xmm_xmmm64,
		EVEX_Vfnmsub231ss_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfnmsub231sd_xmm_k1z_xmm_xmmm64_er,
		EVEX_Vpconflictd_xmm_k1z_xmmm128b32,
		EVEX_Vpconflictd_ymm_k1z_ymmm256b32,
		EVEX_Vpconflictd_zmm_k1z_zmmm512b32,
		EVEX_Vpconflictq_xmm_k1z_xmmm128b64,
		EVEX_Vpconflictq_ymm_k1z_ymmm256b64,
		EVEX_Vpconflictq_zmm_k1z_zmmm512b64,
		EVEX_Vgatherpf0dps_vm32z_k1,
		EVEX_Vgatherpf0dpd_vm32y_k1,
		EVEX_Vgatherpf1dps_vm32z_k1,
		EVEX_Vgatherpf1dpd_vm32y_k1,
		EVEX_Vscatterpf0dps_vm32z_k1,
		EVEX_Vscatterpf0dpd_vm32y_k1,
		EVEX_Vscatterpf1dps_vm32z_k1,
		EVEX_Vscatterpf1dpd_vm32y_k1,
		EVEX_Vgatherpf0qps_vm64z_k1,
		EVEX_Vgatherpf0qpd_vm64z_k1,
		EVEX_Vgatherpf1qps_vm64z_k1,
		EVEX_Vgatherpf1qpd_vm64z_k1,
		EVEX_Vscatterpf0qps_vm64z_k1,
		EVEX_Vscatterpf0qpd_vm64z_k1,
		EVEX_Vscatterpf1qps_vm64z_k1,
		EVEX_Vscatterpf1qpd_vm64z_k1,
		Sha1nexte_xmm_xmmm128,
		EVEX_Vexp2ps_zmm_k1z_zmmm512b32_sae,
		EVEX_Vexp2pd_zmm_k1z_zmmm512b64_sae,
		Sha1msg1_xmm_xmmm128,
		Sha1msg2_xmm_xmmm128,
		EVEX_Vrcp28ps_zmm_k1z_zmmm512b32_sae,
		EVEX_Vrcp28pd_zmm_k1z_zmmm512b64_sae,
		Sha256rnds2_xmm_xmmm128,
		EVEX_Vrcp28ss_xmm_k1z_xmm_xmmm32_sae,
		EVEX_Vrcp28sd_xmm_k1z_xmm_xmmm64_sae,
		Sha256msg1_xmm_xmmm128,
		EVEX_Vrsqrt28ps_zmm_k1z_zmmm512b32_sae,
		EVEX_Vrsqrt28pd_zmm_k1z_zmmm512b64_sae,
		Sha256msg2_xmm_xmmm128,
		EVEX_Vrsqrt28ss_xmm_k1z_xmm_xmmm32_sae,
		EVEX_Vrsqrt28sd_xmm_k1z_xmm_xmmm64_sae,
		Gf2p8mulb_xmm_xmmm128,
		VEX_Vgf2p8mulb_xmm_xmm_xmmm128,
		VEX_Vgf2p8mulb_ymm_ymm_ymmm256,
		EVEX_Vgf2p8mulb_xmm_k1z_xmm_xmmm128,
		EVEX_Vgf2p8mulb_ymm_k1z_ymm_ymmm256,
		EVEX_Vgf2p8mulb_zmm_k1z_zmm_zmmm512,
		Aesimc_xmm_xmmm128,
		VEX_Vaesimc_xmm_xmmm128,
		Aesenc_xmm_xmmm128,
		VEX_Vaesenc_xmm_xmm_xmmm128,
		VEX_Vaesenc_ymm_ymm_ymmm256,
		EVEX_Vaesenc_xmm_xmm_xmmm128,
		EVEX_Vaesenc_ymm_ymm_ymmm256,
		EVEX_Vaesenc_zmm_zmm_zmmm512,
		Aesenclast_xmm_xmmm128,
		VEX_Vaesenclast_xmm_xmm_xmmm128,
		VEX_Vaesenclast_ymm_ymm_ymmm256,
		EVEX_Vaesenclast_xmm_xmm_xmmm128,
		EVEX_Vaesenclast_ymm_ymm_ymmm256,
		EVEX_Vaesenclast_zmm_zmm_zmmm512,
		Aesdec_xmm_xmmm128,
		VEX_Vaesdec_xmm_xmm_xmmm128,
		VEX_Vaesdec_ymm_ymm_ymmm256,
		EVEX_Vaesdec_xmm_xmm_xmmm128,
		EVEX_Vaesdec_ymm_ymm_ymmm256,
		EVEX_Vaesdec_zmm_zmm_zmmm512,
		Aesdeclast_xmm_xmmm128,
		VEX_Vaesdeclast_xmm_xmm_xmmm128,
		VEX_Vaesdeclast_ymm_ymm_ymmm256,
		EVEX_Vaesdeclast_xmm_xmm_xmmm128,
		EVEX_Vaesdeclast_ymm_ymm_ymmm256,
		EVEX_Vaesdeclast_zmm_zmm_zmmm512,
		Movbe_r16_m16,
		Movbe_r32_m32,
		Movbe_r64_m64,
		Crc32_r32_rm8,
		Crc32_r64_rm8,
		Movbe_m16_r16,
		Movbe_m32_r32,
		Movbe_m64_r64,
		Crc32_r32_rm16,
		Crc32_r32_rm32,
		Crc32_r64_rm64,
		VEX_Andn_r32_r32_rm32,
		VEX_Andn_r64_r64_rm64,
		VEX_Blsr_r32_rm32,
		VEX_Blsr_r64_rm64,
		VEX_Blsmsk_r32_rm32,
		VEX_Blsmsk_r64_rm64,
		VEX_Blsi_r32_rm32,
		VEX_Blsi_r64_rm64,
		VEX_Bzhi_r32_rm32_r32,
		VEX_Bzhi_r64_rm64_r64,
		Wrussd_m32_r32,
		Wrussq_m64_r64,
		VEX_Pext_r32_r32_rm32,
		VEX_Pext_r64_r64_rm64,
		VEX_Pdep_r32_r32_rm32,
		VEX_Pdep_r64_r64_rm64,
		Wrssd_m32_r32,
		Wrssq_m64_r64,
		Adcx_r32_rm32,
		Adcx_r64_rm64,
		Adox_r32_rm32,
		Adox_r64_rm64,
		VEX_Mulx_r32_r32_rm32,
		VEX_Mulx_r64_r64_rm64,
		VEX_Bextr_r32_rm32_r32,
		VEX_Bextr_r64_rm64_r64,
		VEX_Shlx_r32_rm32_r32,
		VEX_Shlx_r64_rm64_r64,
		VEX_Sarx_r32_rm32_r32,
		VEX_Sarx_r64_rm64_r64,
		VEX_Shrx_r32_rm32_r32,
		VEX_Shrx_r64_rm64_r64,
		Movdir64b_r16_m512,
		Movdir64b_r32_m512,
		Movdir64b_r64_m512,
		Enqcmds_r16_m512,
		Enqcmds_r32_m512,
		Enqcmds_r64_m512,
		Enqcmd_r16_m512,
		Enqcmd_r32_m512,
		Enqcmd_r64_m512,
		Movdiri_m32_r32,
		Movdiri_m64_r64,
		VEX_Vpermq_ymm_ymmm256_imm8,
		EVEX_Vpermq_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vpermq_zmm_k1z_zmmm512b64_imm8,
		VEX_Vpermpd_ymm_ymmm256_imm8,
		EVEX_Vpermpd_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vpermpd_zmm_k1z_zmmm512b64_imm8,
		VEX_Vpblendd_xmm_xmm_xmmm128_imm8,
		VEX_Vpblendd_ymm_ymm_ymmm256_imm8,
		EVEX_Valignd_xmm_k1z_xmm_xmmm128b32_imm8,
		EVEX_Valignd_ymm_k1z_ymm_ymmm256b32_imm8,
		EVEX_Valignd_zmm_k1z_zmm_zmmm512b32_imm8,
		EVEX_Valignq_xmm_k1z_xmm_xmmm128b64_imm8,
		EVEX_Valignq_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Valignq_zmm_k1z_zmm_zmmm512b64_imm8,
		VEX_Vpermilps_xmm_xmmm128_imm8,
		VEX_Vpermilps_ymm_ymmm256_imm8,
		EVEX_Vpermilps_xmm_k1z_xmmm128b32_imm8,
		EVEX_Vpermilps_ymm_k1z_ymmm256b32_imm8,
		EVEX_Vpermilps_zmm_k1z_zmmm512b32_imm8,
		VEX_Vpermilpd_xmm_xmmm128_imm8,
		VEX_Vpermilpd_ymm_ymmm256_imm8,
		EVEX_Vpermilpd_xmm_k1z_xmmm128b64_imm8,
		EVEX_Vpermilpd_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vpermilpd_zmm_k1z_zmmm512b64_imm8,
		VEX_Vperm2f128_ymm_ymm_ymmm256_imm8,
		Roundps_xmm_xmmm128_imm8,
		VEX_Vroundps_xmm_xmmm128_imm8,
		VEX_Vroundps_ymm_ymmm256_imm8,
		EVEX_Vrndscaleps_xmm_k1z_xmmm128b32_imm8,
		EVEX_Vrndscaleps_ymm_k1z_ymmm256b32_imm8,
		EVEX_Vrndscaleps_zmm_k1z_zmmm512b32_imm8_sae,
		Roundpd_xmm_xmmm128_imm8,
		VEX_Vroundpd_xmm_xmmm128_imm8,
		VEX_Vroundpd_ymm_ymmm256_imm8,
		EVEX_Vrndscalepd_xmm_k1z_xmmm128b64_imm8,
		EVEX_Vrndscalepd_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vrndscalepd_zmm_k1z_zmmm512b64_imm8_sae,
		Roundss_xmm_xmmm32_imm8,
		VEX_Vroundss_xmm_xmm_xmmm32_imm8,
		EVEX_Vrndscaless_xmm_k1z_xmm_xmmm32_imm8_sae,
		Roundsd_xmm_xmmm64_imm8,
		VEX_Vroundsd_xmm_xmm_xmmm64_imm8,
		EVEX_Vrndscalesd_xmm_k1z_xmm_xmmm64_imm8_sae,
		Blendps_xmm_xmmm128_imm8,
		VEX_Vblendps_xmm_xmm_xmmm128_imm8,
		VEX_Vblendps_ymm_ymm_ymmm256_imm8,
		Blendpd_xmm_xmmm128_imm8,
		VEX_Vblendpd_xmm_xmm_xmmm128_imm8,
		VEX_Vblendpd_ymm_ymm_ymmm256_imm8,
		Pblendw_xmm_xmmm128_imm8,
		VEX_Vpblendw_xmm_xmm_xmmm128_imm8,
		VEX_Vpblendw_ymm_ymm_ymmm256_imm8,
		Palignr_mm_mmm64_imm8,
		Palignr_xmm_xmmm128_imm8,
		VEX_Vpalignr_xmm_xmm_xmmm128_imm8,
		VEX_Vpalignr_ymm_ymm_ymmm256_imm8,
		EVEX_Vpalignr_xmm_k1z_xmm_xmmm128_imm8,
		EVEX_Vpalignr_ymm_k1z_ymm_ymmm256_imm8,
		EVEX_Vpalignr_zmm_k1z_zmm_zmmm512_imm8,
		Pextrb_r32m8_xmm_imm8,
		Pextrb_r64m8_xmm_imm8,
		VEX_Vpextrb_r32m8_xmm_imm8,
		VEX_Vpextrb_r64m8_xmm_imm8,
		EVEX_Vpextrb_r32m8_xmm_imm8,
		EVEX_Vpextrb_r64m8_xmm_imm8,
		Pextrw_r32m16_xmm_imm8,
		Pextrw_r64m16_xmm_imm8,
		VEX_Vpextrw_r32m16_xmm_imm8,
		VEX_Vpextrw_r64m16_xmm_imm8,
		EVEX_Vpextrw_r32m16_xmm_imm8,
		EVEX_Vpextrw_r64m16_xmm_imm8,
		Pextrd_rm32_xmm_imm8,
		Pextrq_rm64_xmm_imm8,
		VEX_Vpextrd_rm32_xmm_imm8,
		VEX_Vpextrq_rm64_xmm_imm8,
		EVEX_Vpextrd_rm32_xmm_imm8,
		EVEX_Vpextrq_rm64_xmm_imm8,
		Extractps_rm32_xmm_imm8,
		Extractps_r64m32_xmm_imm8,
		VEX_Vextractps_rm32_xmm_imm8,
		VEX_Vextractps_r64m32_xmm_imm8,
		EVEX_Vextractps_rm32_xmm_imm8,
		EVEX_Vextractps_r64m32_xmm_imm8,
		VEX_Vinsertf128_ymm_ymm_xmmm128_imm8,
		EVEX_Vinsertf32x4_ymm_k1z_ymm_xmmm128_imm8,
		EVEX_Vinsertf32x4_zmm_k1z_zmm_xmmm128_imm8,
		EVEX_Vinsertf64x2_ymm_k1z_ymm_xmmm128_imm8,
		EVEX_Vinsertf64x2_zmm_k1z_zmm_xmmm128_imm8,
		VEX_Vextractf128_xmmm128_ymm_imm8,
		EVEX_Vextractf32x4_xmmm128_k1z_ymm_imm8,
		EVEX_Vextractf32x4_xmmm128_k1z_zmm_imm8,
		EVEX_Vextractf64x2_xmmm128_k1z_ymm_imm8,
		EVEX_Vextractf64x2_xmmm128_k1z_zmm_imm8,
		EVEX_Vinsertf32x8_zmm_k1z_zmm_ymmm256_imm8,
		EVEX_Vinsertf64x4_zmm_k1z_zmm_ymmm256_imm8,
		EVEX_Vextractf32x8_ymmm256_k1z_zmm_imm8,
		EVEX_Vextractf64x4_ymmm256_k1z_zmm_imm8,
		VEX_Vcvtps2ph_xmmm64_xmm_imm8,
		VEX_Vcvtps2ph_xmmm128_ymm_imm8,
		EVEX_Vcvtps2ph_xmmm64_k1z_xmm_imm8,
		EVEX_Vcvtps2ph_xmmm128_k1z_ymm_imm8,
		EVEX_Vcvtps2ph_ymmm256_k1z_zmm_imm8_sae,
		EVEX_Vpcmpud_kr_k1_xmm_xmmm128b32_imm8,
		EVEX_Vpcmpud_kr_k1_ymm_ymmm256b32_imm8,
		EVEX_Vpcmpud_kr_k1_zmm_zmmm512b32_imm8,
		EVEX_Vpcmpuq_kr_k1_xmm_xmmm128b64_imm8,
		EVEX_Vpcmpuq_kr_k1_ymm_ymmm256b64_imm8,
		EVEX_Vpcmpuq_kr_k1_zmm_zmmm512b64_imm8,
		EVEX_Vpcmpd_kr_k1_xmm_xmmm128b32_imm8,
		EVEX_Vpcmpd_kr_k1_ymm_ymmm256b32_imm8,
		EVEX_Vpcmpd_kr_k1_zmm_zmmm512b32_imm8,
		EVEX_Vpcmpq_kr_k1_xmm_xmmm128b64_imm8,
		EVEX_Vpcmpq_kr_k1_ymm_ymmm256b64_imm8,
		EVEX_Vpcmpq_kr_k1_zmm_zmmm512b64_imm8,
		Pinsrb_xmm_r32m8_imm8,
		Pinsrb_xmm_r64m8_imm8,
		VEX_Vpinsrb_xmm_xmm_r32m8_imm8,
		VEX_Vpinsrb_xmm_xmm_r64m8_imm8,
		EVEX_Vpinsrb_xmm_xmm_r32m8_imm8,
		EVEX_Vpinsrb_xmm_xmm_r64m8_imm8,
		Insertps_xmm_xmmm32_imm8,
		VEX_Vinsertps_xmm_xmm_xmmm32_imm8,
		EVEX_Vinsertps_xmm_xmm_xmmm32_imm8,
		Pinsrd_xmm_rm32_imm8,
		Pinsrq_xmm_rm64_imm8,
		VEX_Vpinsrd_xmm_xmm_rm32_imm8,
		VEX_Vpinsrq_xmm_xmm_rm64_imm8,
		EVEX_Vpinsrd_xmm_xmm_rm32_imm8,
		EVEX_Vpinsrq_xmm_xmm_rm64_imm8,
		EVEX_Vshuff32x4_ymm_k1z_ymm_ymmm256b32_imm8,
		EVEX_Vshuff32x4_zmm_k1z_zmm_zmmm512b32_imm8,
		EVEX_Vshuff64x2_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Vshuff64x2_zmm_k1z_zmm_zmmm512b64_imm8,
		EVEX_Vpternlogd_xmm_k1z_xmm_xmmm128b32_imm8,
		EVEX_Vpternlogd_ymm_k1z_ymm_ymmm256b32_imm8,
		EVEX_Vpternlogd_zmm_k1z_zmm_zmmm512b32_imm8,
		EVEX_Vpternlogq_xmm_k1z_xmm_xmmm128b64_imm8,
		EVEX_Vpternlogq_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Vpternlogq_zmm_k1z_zmm_zmmm512b64_imm8,
		EVEX_Vgetmantps_xmm_k1z_xmmm128b32_imm8,
		EVEX_Vgetmantps_ymm_k1z_ymmm256b32_imm8,
		EVEX_Vgetmantps_zmm_k1z_zmmm512b32_imm8_sae,
		EVEX_Vgetmantpd_xmm_k1z_xmmm128b64_imm8,
		EVEX_Vgetmantpd_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vgetmantpd_zmm_k1z_zmmm512b64_imm8_sae,
		EVEX_Vgetmantss_xmm_k1z_xmm_xmmm32_imm8_sae,
		EVEX_Vgetmantsd_xmm_k1z_xmm_xmmm64_imm8_sae,
		VEX_Kshiftrb_kr_kr_imm8,
		VEX_Kshiftrw_kr_kr_imm8,
		VEX_Kshiftrd_kr_kr_imm8,
		VEX_Kshiftrq_kr_kr_imm8,
		VEX_Kshiftlb_kr_kr_imm8,
		VEX_Kshiftlw_kr_kr_imm8,
		VEX_Kshiftld_kr_kr_imm8,
		VEX_Kshiftlq_kr_kr_imm8,
		VEX_Vinserti128_ymm_ymm_xmmm128_imm8,
		EVEX_Vinserti32x4_ymm_k1z_ymm_xmmm128_imm8,
		EVEX_Vinserti32x4_zmm_k1z_zmm_xmmm128_imm8,
		EVEX_Vinserti64x2_ymm_k1z_ymm_xmmm128_imm8,
		EVEX_Vinserti64x2_zmm_k1z_zmm_xmmm128_imm8,
		VEX_Vextracti128_xmmm128_ymm_imm8,
		EVEX_Vextracti32x4_xmmm128_k1z_ymm_imm8,
		EVEX_Vextracti32x4_xmmm128_k1z_zmm_imm8,
		EVEX_Vextracti64x2_xmmm128_k1z_ymm_imm8,
		EVEX_Vextracti64x2_xmmm128_k1z_zmm_imm8,
		EVEX_Vinserti32x8_zmm_k1z_zmm_ymmm256_imm8,
		EVEX_Vinserti64x4_zmm_k1z_zmm_ymmm256_imm8,
		EVEX_Vextracti32x8_ymmm256_k1z_zmm_imm8,
		EVEX_Vextracti64x4_ymmm256_k1z_zmm_imm8,
		EVEX_Vpcmpub_kr_k1_xmm_xmmm128_imm8,
		EVEX_Vpcmpub_kr_k1_ymm_ymmm256_imm8,
		EVEX_Vpcmpub_kr_k1_zmm_zmmm512_imm8,
		EVEX_Vpcmpuw_kr_k1_xmm_xmmm128_imm8,
		EVEX_Vpcmpuw_kr_k1_ymm_ymmm256_imm8,
		EVEX_Vpcmpuw_kr_k1_zmm_zmmm512_imm8,
		EVEX_Vpcmpb_kr_k1_xmm_xmmm128_imm8,
		EVEX_Vpcmpb_kr_k1_ymm_ymmm256_imm8,
		EVEX_Vpcmpb_kr_k1_zmm_zmmm512_imm8,
		EVEX_Vpcmpw_kr_k1_xmm_xmmm128_imm8,
		EVEX_Vpcmpw_kr_k1_ymm_ymmm256_imm8,
		EVEX_Vpcmpw_kr_k1_zmm_zmmm512_imm8,
		Dpps_xmm_xmmm128_imm8,
		VEX_Vdpps_xmm_xmm_xmmm128_imm8,
		VEX_Vdpps_ymm_ymm_ymmm256_imm8,
		Dppd_xmm_xmmm128_imm8,
		VEX_Vdppd_xmm_xmm_xmmm128_imm8,
		Mpsadbw_xmm_xmmm128_imm8,
		VEX_Vmpsadbw_xmm_xmm_xmmm128_imm8,
		VEX_Vmpsadbw_ymm_ymm_ymmm256_imm8,
		EVEX_Vdbpsadbw_xmm_k1z_xmm_xmmm128_imm8,
		EVEX_Vdbpsadbw_ymm_k1z_ymm_ymmm256_imm8,
		EVEX_Vdbpsadbw_zmm_k1z_zmm_zmmm512_imm8,
		EVEX_Vshufi32x4_ymm_k1z_ymm_ymmm256b32_imm8,
		EVEX_Vshufi32x4_zmm_k1z_zmm_zmmm512b32_imm8,
		EVEX_Vshufi64x2_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Vshufi64x2_zmm_k1z_zmm_zmmm512b64_imm8,
		Pclmulqdq_xmm_xmmm128_imm8,
		VEX_Vpclmulqdq_xmm_xmm_xmmm128_imm8,
		VEX_Vpclmulqdq_ymm_ymm_ymmm256_imm8,
		EVEX_Vpclmulqdq_xmm_xmm_xmmm128_imm8,
		EVEX_Vpclmulqdq_ymm_ymm_ymmm256_imm8,
		EVEX_Vpclmulqdq_zmm_zmm_zmmm512_imm8,
		VEX_Vperm2i128_ymm_ymm_ymmm256_imm8,
		VEX_Vpermil2ps_xmm_xmm_xmmm128_xmm_imm4,
		VEX_Vpermil2ps_ymm_ymm_ymmm256_ymm_imm4,
		VEX_Vpermil2ps_xmm_xmm_xmm_xmmm128_imm4,
		VEX_Vpermil2ps_ymm_ymm_ymm_ymmm256_imm4,
		VEX_Vpermil2pd_xmm_xmm_xmmm128_xmm_imm4,
		VEX_Vpermil2pd_ymm_ymm_ymmm256_ymm_imm4,
		VEX_Vpermil2pd_xmm_xmm_xmm_xmmm128_imm4,
		VEX_Vpermil2pd_ymm_ymm_ymm_ymmm256_imm4,
		VEX_Vblendvps_xmm_xmm_xmmm128_xmm,
		VEX_Vblendvps_ymm_ymm_ymmm256_ymm,
		VEX_Vblendvpd_xmm_xmm_xmmm128_xmm,
		VEX_Vblendvpd_ymm_ymm_ymmm256_ymm,
		VEX_Vpblendvb_xmm_xmm_xmmm128_xmm,
		VEX_Vpblendvb_ymm_ymm_ymmm256_ymm,
		EVEX_Vrangeps_xmm_k1z_xmm_xmmm128b32_imm8,
		EVEX_Vrangeps_ymm_k1z_ymm_ymmm256b32_imm8,
		EVEX_Vrangeps_zmm_k1z_zmm_zmmm512b32_imm8_sae,
		EVEX_Vrangepd_xmm_k1z_xmm_xmmm128b64_imm8,
		EVEX_Vrangepd_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Vrangepd_zmm_k1z_zmm_zmmm512b64_imm8_sae,
		EVEX_Vrangess_xmm_k1z_xmm_xmmm32_imm8_sae,
		EVEX_Vrangesd_xmm_k1z_xmm_xmmm64_imm8_sae,
		EVEX_Vfixupimmps_xmm_k1z_xmm_xmmm128b32_imm8,
		EVEX_Vfixupimmps_ymm_k1z_ymm_ymmm256b32_imm8,
		EVEX_Vfixupimmps_zmm_k1z_zmm_zmmm512b32_imm8_sae,
		EVEX_Vfixupimmpd_xmm_k1z_xmm_xmmm128b64_imm8,
		EVEX_Vfixupimmpd_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Vfixupimmpd_zmm_k1z_zmm_zmmm512b64_imm8_sae,
		EVEX_Vfixupimmss_xmm_k1z_xmm_xmmm32_imm8_sae,
		EVEX_Vfixupimmsd_xmm_k1z_xmm_xmmm64_imm8_sae,
		EVEX_Vreduceps_xmm_k1z_xmmm128b32_imm8,
		EVEX_Vreduceps_ymm_k1z_ymmm256b32_imm8,
		EVEX_Vreduceps_zmm_k1z_zmmm512b32_imm8_sae,
		EVEX_Vreducepd_xmm_k1z_xmmm128b64_imm8,
		EVEX_Vreducepd_ymm_k1z_ymmm256b64_imm8,
		EVEX_Vreducepd_zmm_k1z_zmmm512b64_imm8_sae,
		EVEX_Vreducess_xmm_k1z_xmm_xmmm32_imm8_sae,
		EVEX_Vreducesd_xmm_k1z_xmm_xmmm64_imm8_sae,
		VEX_Vfmaddsubps_xmm_xmm_xmmm128_xmm,
		VEX_Vfmaddsubps_ymm_ymm_ymmm256_ymm,
		VEX_Vfmaddsubps_xmm_xmm_xmm_xmmm128,
		VEX_Vfmaddsubps_ymm_ymm_ymm_ymmm256,
		VEX_Vfmaddsubpd_xmm_xmm_xmmm128_xmm,
		VEX_Vfmaddsubpd_ymm_ymm_ymmm256_ymm,
		VEX_Vfmaddsubpd_xmm_xmm_xmm_xmmm128,
		VEX_Vfmaddsubpd_ymm_ymm_ymm_ymmm256,
		VEX_Vfmsubaddps_xmm_xmm_xmmm128_xmm,
		VEX_Vfmsubaddps_ymm_ymm_ymmm256_ymm,
		VEX_Vfmsubaddps_xmm_xmm_xmm_xmmm128,
		VEX_Vfmsubaddps_ymm_ymm_ymm_ymmm256,
		VEX_Vfmsubaddpd_xmm_xmm_xmmm128_xmm,
		VEX_Vfmsubaddpd_ymm_ymm_ymmm256_ymm,
		VEX_Vfmsubaddpd_xmm_xmm_xmm_xmmm128,
		VEX_Vfmsubaddpd_ymm_ymm_ymm_ymmm256,
		Pcmpestrm_xmm_xmmm128_imm8,
		Pcmpestrm64_xmm_xmmm128_imm8,
		VEX_Vpcmpestrm_xmm_xmmm128_imm8,
		VEX_Vpcmpestrm64_xmm_xmmm128_imm8,
		Pcmpestri_xmm_xmmm128_imm8,
		Pcmpestri64_xmm_xmmm128_imm8,
		VEX_Vpcmpestri_xmm_xmmm128_imm8,
		VEX_Vpcmpestri64_xmm_xmmm128_imm8,
		Pcmpistrm_xmm_xmmm128_imm8,
		VEX_Vpcmpistrm_xmm_xmmm128_imm8,
		Pcmpistri_xmm_xmmm128_imm8,
		VEX_Vpcmpistri_xmm_xmmm128_imm8,
		EVEX_Vfpclassps_kr_k1_xmmm128b32_imm8,
		EVEX_Vfpclassps_kr_k1_ymmm256b32_imm8,
		EVEX_Vfpclassps_kr_k1_zmmm512b32_imm8,
		EVEX_Vfpclasspd_kr_k1_xmmm128b64_imm8,
		EVEX_Vfpclasspd_kr_k1_ymmm256b64_imm8,
		EVEX_Vfpclasspd_kr_k1_zmmm512b64_imm8,
		EVEX_Vfpclassss_kr_k1_xmmm32_imm8,
		EVEX_Vfpclasssd_kr_k1_xmmm64_imm8,
		VEX_Vfmaddps_xmm_xmm_xmmm128_xmm,
		VEX_Vfmaddps_ymm_ymm_ymmm256_ymm,
		VEX_Vfmaddps_xmm_xmm_xmm_xmmm128,
		VEX_Vfmaddps_ymm_ymm_ymm_ymmm256,
		VEX_Vfmaddpd_xmm_xmm_xmmm128_xmm,
		VEX_Vfmaddpd_ymm_ymm_ymmm256_ymm,
		VEX_Vfmaddpd_xmm_xmm_xmm_xmmm128,
		VEX_Vfmaddpd_ymm_ymm_ymm_ymmm256,
		VEX_Vfmaddss_xmm_xmm_xmmm32_xmm,
		VEX_Vfmaddss_xmm_xmm_xmm_xmmm32,
		VEX_Vfmaddsd_xmm_xmm_xmmm64_xmm,
		VEX_Vfmaddsd_xmm_xmm_xmm_xmmm64,
		VEX_Vfmsubps_xmm_xmm_xmmm128_xmm,
		VEX_Vfmsubps_ymm_ymm_ymmm256_ymm,
		VEX_Vfmsubps_xmm_xmm_xmm_xmmm128,
		VEX_Vfmsubps_ymm_ymm_ymm_ymmm256,
		VEX_Vfmsubpd_xmm_xmm_xmmm128_xmm,
		VEX_Vfmsubpd_ymm_ymm_ymmm256_ymm,
		VEX_Vfmsubpd_xmm_xmm_xmm_xmmm128,
		VEX_Vfmsubpd_ymm_ymm_ymm_ymmm256,
		VEX_Vfmsubss_xmm_xmm_xmmm32_xmm,
		VEX_Vfmsubss_xmm_xmm_xmm_xmmm32,
		VEX_Vfmsubsd_xmm_xmm_xmmm64_xmm,
		VEX_Vfmsubsd_xmm_xmm_xmm_xmmm64,
		EVEX_Vpshldw_xmm_k1z_xmm_xmmm128_imm8,
		EVEX_Vpshldw_ymm_k1z_ymm_ymmm256_imm8,
		EVEX_Vpshldw_zmm_k1z_zmm_zmmm512_imm8,
		EVEX_Vpshldd_xmm_k1z_xmm_xmmm128b32_imm8,
		EVEX_Vpshldd_ymm_k1z_ymm_ymmm256b32_imm8,
		EVEX_Vpshldd_zmm_k1z_zmm_zmmm512b32_imm8,
		EVEX_Vpshldq_xmm_k1z_xmm_xmmm128b64_imm8,
		EVEX_Vpshldq_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Vpshldq_zmm_k1z_zmm_zmmm512b64_imm8,
		EVEX_Vpshrdw_xmm_k1z_xmm_xmmm128_imm8,
		EVEX_Vpshrdw_ymm_k1z_ymm_ymmm256_imm8,
		EVEX_Vpshrdw_zmm_k1z_zmm_zmmm512_imm8,
		EVEX_Vpshrdd_xmm_k1z_xmm_xmmm128b32_imm8,
		EVEX_Vpshrdd_ymm_k1z_ymm_ymmm256b32_imm8,
		EVEX_Vpshrdd_zmm_k1z_zmm_zmmm512b32_imm8,
		EVEX_Vpshrdq_xmm_k1z_xmm_xmmm128b64_imm8,
		EVEX_Vpshrdq_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Vpshrdq_zmm_k1z_zmm_zmmm512b64_imm8,
		VEX_Vfnmaddps_xmm_xmm_xmmm128_xmm,
		VEX_Vfnmaddps_ymm_ymm_ymmm256_ymm,
		VEX_Vfnmaddps_xmm_xmm_xmm_xmmm128,
		VEX_Vfnmaddps_ymm_ymm_ymm_ymmm256,
		VEX_Vfnmaddpd_xmm_xmm_xmmm128_xmm,
		VEX_Vfnmaddpd_ymm_ymm_ymmm256_ymm,
		VEX_Vfnmaddpd_xmm_xmm_xmm_xmmm128,
		VEX_Vfnmaddpd_ymm_ymm_ymm_ymmm256,
		VEX_Vfnmaddss_xmm_xmm_xmmm32_xmm,
		VEX_Vfnmaddss_xmm_xmm_xmm_xmmm32,
		VEX_Vfnmaddsd_xmm_xmm_xmmm64_xmm,
		VEX_Vfnmaddsd_xmm_xmm_xmm_xmmm64,
		VEX_Vfnmsubps_xmm_xmm_xmmm128_xmm,
		VEX_Vfnmsubps_ymm_ymm_ymmm256_ymm,
		VEX_Vfnmsubps_xmm_xmm_xmm_xmmm128,
		VEX_Vfnmsubps_ymm_ymm_ymm_ymmm256,
		VEX_Vfnmsubpd_xmm_xmm_xmmm128_xmm,
		VEX_Vfnmsubpd_ymm_ymm_ymmm256_ymm,
		VEX_Vfnmsubpd_xmm_xmm_xmm_xmmm128,
		VEX_Vfnmsubpd_ymm_ymm_ymm_ymmm256,
		VEX_Vfnmsubss_xmm_xmm_xmmm32_xmm,
		VEX_Vfnmsubss_xmm_xmm_xmm_xmmm32,
		VEX_Vfnmsubsd_xmm_xmm_xmmm64_xmm,
		VEX_Vfnmsubsd_xmm_xmm_xmm_xmmm64,
		Sha1rnds4_xmm_xmmm128_imm8,
		Gf2p8affineqb_xmm_xmmm128_imm8,
		VEX_Vgf2p8affineqb_xmm_xmm_xmmm128_imm8,
		VEX_Vgf2p8affineqb_ymm_ymm_ymmm256_imm8,
		EVEX_Vgf2p8affineqb_xmm_k1z_xmm_xmmm128b64_imm8,
		EVEX_Vgf2p8affineqb_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Vgf2p8affineqb_zmm_k1z_zmm_zmmm512b64_imm8,
		Gf2p8affineinvqb_xmm_xmmm128_imm8,
		VEX_Vgf2p8affineinvqb_xmm_xmm_xmmm128_imm8,
		VEX_Vgf2p8affineinvqb_ymm_ymm_ymmm256_imm8,
		EVEX_Vgf2p8affineinvqb_xmm_k1z_xmm_xmmm128b64_imm8,
		EVEX_Vgf2p8affineinvqb_ymm_k1z_ymm_ymmm256b64_imm8,
		EVEX_Vgf2p8affineinvqb_zmm_k1z_zmm_zmmm512b64_imm8,
		Aeskeygenassist_xmm_xmmm128_imm8,
		VEX_Vaeskeygenassist_xmm_xmmm128_imm8,
		VEX_Rorx_r32_rm32_imm8,
		VEX_Rorx_r64_rm64_imm8,
		XOP_Vpmacssww_xmm_xmm_xmmm128_xmm,
		XOP_Vpmacsswd_xmm_xmm_xmmm128_xmm,
		XOP_Vpmacssdql_xmm_xmm_xmmm128_xmm,
		XOP_Vpmacssdd_xmm_xmm_xmmm128_xmm,
		XOP_Vpmacssdqh_xmm_xmm_xmmm128_xmm,
		XOP_Vpmacsww_xmm_xmm_xmmm128_xmm,
		XOP_Vpmacswd_xmm_xmm_xmmm128_xmm,
		XOP_Vpmacsdql_xmm_xmm_xmmm128_xmm,
		XOP_Vpmacsdd_xmm_xmm_xmmm128_xmm,
		XOP_Vpmacsdqh_xmm_xmm_xmmm128_xmm,
		XOP_Vpcmov_xmm_xmm_xmmm128_xmm,
		XOP_Vpcmov_ymm_ymm_ymmm256_ymm,
		XOP_Vpcmov_xmm_xmm_xmm_xmmm128,
		XOP_Vpcmov_ymm_ymm_ymm_ymmm256,
		XOP_Vpperm_xmm_xmm_xmmm128_xmm,
		XOP_Vpperm_xmm_xmm_xmm_xmmm128,
		XOP_Vpmadcsswd_xmm_xmm_xmmm128_xmm,
		XOP_Vpmadcswd_xmm_xmm_xmmm128_xmm,
		XOP_Vprotb_xmm_xmmm128_imm8,
		XOP_Vprotw_xmm_xmmm128_imm8,
		XOP_Vprotd_xmm_xmmm128_imm8,
		XOP_Vprotq_xmm_xmmm128_imm8,
		XOP_Vpcomb_xmm_xmm_xmmm128_imm8,
		XOP_Vpcomw_xmm_xmm_xmmm128_imm8,
		XOP_Vpcomd_xmm_xmm_xmmm128_imm8,
		XOP_Vpcomq_xmm_xmm_xmmm128_imm8,
		XOP_Vpcomub_xmm_xmm_xmmm128_imm8,
		XOP_Vpcomuw_xmm_xmm_xmmm128_imm8,
		XOP_Vpcomud_xmm_xmm_xmmm128_imm8,
		XOP_Vpcomuq_xmm_xmm_xmmm128_imm8,
		XOP_Blcfill_r32_rm32,
		XOP_Blcfill_r64_rm64,
		XOP_Blsfill_r32_rm32,
		XOP_Blsfill_r64_rm64,
		XOP_Blcs_r32_rm32,
		XOP_Blcs_r64_rm64,
		XOP_Tzmsk_r32_rm32,
		XOP_Tzmsk_r64_rm64,
		XOP_Blcic_r32_rm32,
		XOP_Blcic_r64_rm64,
		XOP_Blsic_r32_rm32,
		XOP_Blsic_r64_rm64,
		XOP_T1mskc_r32_rm32,
		XOP_T1mskc_r64_rm64,
		XOP_Blcmsk_r32_rm32,
		XOP_Blcmsk_r64_rm64,
		XOP_Blci_r32_rm32,
		XOP_Blci_r64_rm64,
		XOP_Llwpcb_r32,
		XOP_Llwpcb_r64,
		XOP_Slwpcb_r32,
		XOP_Slwpcb_r64,
		XOP_Vfrczps_xmm_xmmm128,
		XOP_Vfrczps_ymm_ymmm256,
		XOP_Vfrczpd_xmm_xmmm128,
		XOP_Vfrczpd_ymm_ymmm256,
		XOP_Vfrczss_xmm_xmmm32,
		XOP_Vfrczsd_xmm_xmmm64,
		XOP_Vprotb_xmm_xmmm128_xmm,
		XOP_Vprotb_xmm_xmm_xmmm128,
		XOP_Vprotw_xmm_xmmm128_xmm,
		XOP_Vprotw_xmm_xmm_xmmm128,
		XOP_Vprotd_xmm_xmmm128_xmm,
		XOP_Vprotd_xmm_xmm_xmmm128,
		XOP_Vprotq_xmm_xmmm128_xmm,
		XOP_Vprotq_xmm_xmm_xmmm128,
		XOP_Vpshlb_xmm_xmmm128_xmm,
		XOP_Vpshlb_xmm_xmm_xmmm128,
		XOP_Vpshlw_xmm_xmmm128_xmm,
		XOP_Vpshlw_xmm_xmm_xmmm128,
		XOP_Vpshld_xmm_xmmm128_xmm,
		XOP_Vpshld_xmm_xmm_xmmm128,
		XOP_Vpshlq_xmm_xmmm128_xmm,
		XOP_Vpshlq_xmm_xmm_xmmm128,
		XOP_Vpshab_xmm_xmmm128_xmm,
		XOP_Vpshab_xmm_xmm_xmmm128,
		XOP_Vpshaw_xmm_xmmm128_xmm,
		XOP_Vpshaw_xmm_xmm_xmmm128,
		XOP_Vpshad_xmm_xmmm128_xmm,
		XOP_Vpshad_xmm_xmm_xmmm128,
		XOP_Vpshaq_xmm_xmmm128_xmm,
		XOP_Vpshaq_xmm_xmm_xmmm128,
		XOP_Vphaddbw_xmm_xmmm128,
		XOP_Vphaddbd_xmm_xmmm128,
		XOP_Vphaddbq_xmm_xmmm128,
		XOP_Vphaddwd_xmm_xmmm128,
		XOP_Vphaddwq_xmm_xmmm128,
		XOP_Vphadddq_xmm_xmmm128,
		XOP_Vphaddubw_xmm_xmmm128,
		XOP_Vphaddubd_xmm_xmmm128,
		XOP_Vphaddubq_xmm_xmmm128,
		XOP_Vphadduwd_xmm_xmmm128,
		XOP_Vphadduwq_xmm_xmmm128,
		XOP_Vphaddudq_xmm_xmmm128,
		XOP_Vphsubbw_xmm_xmmm128,
		XOP_Vphsubwd_xmm_xmmm128,
		XOP_Vphsubdq_xmm_xmmm128,
		XOP_Bextr_r32_rm32_imm32,
		XOP_Bextr_r64_rm64_imm32,
		XOP_Lwpins_r32_rm32_imm32,
		XOP_Lwpins_r64_rm32_imm32,
		XOP_Lwpval_r32_rm32_imm32,
		XOP_Lwpval_r64_rm32_imm32,
		D3NOW_Pi2fw_mm_mmm64,
		D3NOW_Pi2fd_mm_mmm64,
		D3NOW_Pf2iw_mm_mmm64,
		D3NOW_Pf2id_mm_mmm64,
		D3NOW_Pfrcpv_mm_mmm64,
		D3NOW_Pfrsqrtv_mm_mmm64,
		D3NOW_Pfnacc_mm_mmm64,
		D3NOW_Pfpnacc_mm_mmm64,
		D3NOW_Pfcmpge_mm_mmm64,
		D3NOW_Pfmin_mm_mmm64,
		D3NOW_Pfrcp_mm_mmm64,
		D3NOW_Pfrsqrt_mm_mmm64,
		D3NOW_Pfsub_mm_mmm64,
		D3NOW_Pfadd_mm_mmm64,
		D3NOW_Pfcmpgt_mm_mmm64,
		D3NOW_Pfmax_mm_mmm64,
		D3NOW_Pfrcpit1_mm_mmm64,
		D3NOW_Pfrsqit1_mm_mmm64,
		D3NOW_Pfsubr_mm_mmm64,
		D3NOW_Pfacc_mm_mmm64,
		D3NOW_Pfcmpeq_mm_mmm64,
		D3NOW_Pfmul_mm_mmm64,
		D3NOW_Pfrcpit2_mm_mmm64,
		D3NOW_Pmulhrw_mm_mmm64,
		D3NOW_Pswapd_mm_mmm64,
		D3NOW_Pavgusb_mm_mmm64,
		Rmpadjust,
		Rmpupdate,
		Psmash,
		Pvalidatew,
		Pvalidated,
		Pvalidateq,
		Serialize,
		Xsusldtrk,
		Xresldtrk,
		Invlpgbw,
		Invlpgbd,
		Invlpgbq,
		Tlbsync,
		Prefetchreserved3_m8,
		Prefetchreserved4_m8,
		Prefetchreserved5_m8,
		Prefetchreserved6_m8,
		Prefetchreserved7_m8,
		Ud0,
		Vmgexit,
		Getsecq,
		VEX_Ldtilecfg_m512,
		VEX_Tilerelease,
		VEX_Sttilecfg_m512,
		VEX_Tilezero_tmm,
		VEX_Tileloaddt1_tmm_sibmem,
		VEX_Tilestored_sibmem_tmm,
		VEX_Tileloadd_tmm_sibmem,
		VEX_Tdpbf16ps_tmm_tmm_tmm,
		VEX_Tdpbuud_tmm_tmm_tmm,
		VEX_Tdpbusd_tmm_tmm_tmm,
		VEX_Tdpbsud_tmm_tmm_tmm,
		VEX_Tdpbssd_tmm_tmm_tmm,
		Fnstdw_AX,
		Fnstsg_AX,
		Rdshr_rm32,
		Wrshr_rm32,
		Smint,
		Dmint,
		Rdm,
		Svdc_m80_Sreg,
		Rsdc_Sreg_m80,
		Svldt_m80,
		Rsldt_m80,
		Svts_m80,
		Rsts_m80,
		Smint_0F7E,
		Bb0_reset,
		Bb1_reset,
		Cpu_write,
		Cpu_read,
		Altinst,
		Paveb_mm_mmm64,
		Paddsiw_mm_mmm64,
		Pmagw_mm_mmm64,
		Pdistib_mm_m64,
		Psubsiw_mm_mmm64,
		Pmvzb_mm_m64,
		Pmulhrw_mm_mmm64,
		Pmvnzb_mm_m64,
		Pmvlzb_mm_m64,
		Pmvgezb_mm_m64,
		Pmulhriw_mm_mmm64,
		Pmachriw_mm_m64,
		Cyrix_D9D7,
		Cyrix_D9E2,
		Ftstp,
		Cyrix_D9E7,
		Frint2,
		Frichop,
		Cyrix_DED8,
		Cyrix_DEDA,
		Cyrix_DEDC,
		Cyrix_DEDD,
		Cyrix_DEDE,
		Frinear,
		Tdcall,
		Seamret,
		Seamops,
		Seamcall,
		Aesencwide128kl_m384,
		Aesdecwide128kl_m384,
		Aesencwide256kl_m512,
		Aesdecwide256kl_m512,
		Loadiwkey_xmm_xmm,
		Aesenc128kl_xmm_m384,
		Aesdec128kl_xmm_m384,
		Aesenc256kl_xmm_m512,
		Aesdec256kl_xmm_m512,
		Encodekey128_r32_r32,
		Encodekey256_r32_r32,
		VEX_Vbroadcastss_xmm_xmm,
		VEX_Vbroadcastss_ymm_xmm,
		VEX_Vbroadcastsd_ymm_xmm,
		Vmgexit_F2,
		Uiret,
		Testui,
		Clui,
		Stui,
		Senduipi_r64,
		Hreset_imm8,
		VEX_Vpdpbusd_xmm_xmm_xmmm128,
		VEX_Vpdpbusd_ymm_ymm_ymmm256,
		VEX_Vpdpbusds_xmm_xmm_xmmm128,
		VEX_Vpdpbusds_ymm_ymm_ymmm256,
		VEX_Vpdpwssd_xmm_xmm_xmmm128,
		VEX_Vpdpwssd_ymm_ymm_ymmm256,
		VEX_Vpdpwssds_xmm_xmm_xmmm128,
		VEX_Vpdpwssds_ymm_ymm_ymmm256,
		Ccs_hash_16,
		Ccs_hash_32,
		Ccs_hash_64,
		Ccs_encrypt_16,
		Ccs_encrypt_32,
		Ccs_encrypt_64,
		Lkgs_rm16,
		Lkgs_r32m16,
		Lkgs_r64m16,
		Eretu,
		Erets,
		EVEX_Vaddph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vaddph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vaddph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vaddsh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vcmpph_kr_k1_xmm_xmmm128b16_imm8,
		EVEX_Vcmpph_kr_k1_ymm_ymmm256b16_imm8,
		EVEX_Vcmpph_kr_k1_zmm_zmmm512b16_imm8_sae,
		EVEX_Vcmpsh_kr_k1_xmm_xmmm16_imm8_sae,
		EVEX_Vcomish_xmm_xmmm16_sae,
		EVEX_Vcvtdq2ph_xmm_k1z_xmmm128b32,
		EVEX_Vcvtdq2ph_xmm_k1z_ymmm256b32,
		EVEX_Vcvtdq2ph_ymm_k1z_zmmm512b32_er,
		EVEX_Vcvtpd2ph_xmm_k1z_xmmm128b64,
		EVEX_Vcvtpd2ph_xmm_k1z_ymmm256b64,
		EVEX_Vcvtpd2ph_xmm_k1z_zmmm512b64_er,
		EVEX_Vcvtph2dq_xmm_k1z_xmmm64b16,
		EVEX_Vcvtph2dq_ymm_k1z_xmmm128b16,
		EVEX_Vcvtph2dq_zmm_k1z_ymmm256b16_er,
		EVEX_Vcvtph2pd_xmm_k1z_xmmm32b16,
		EVEX_Vcvtph2pd_ymm_k1z_xmmm64b16,
		EVEX_Vcvtph2pd_zmm_k1z_xmmm128b16_sae,
		EVEX_Vcvtph2psx_xmm_k1z_xmmm64b16,
		EVEX_Vcvtph2psx_ymm_k1z_xmmm128b16,
		EVEX_Vcvtph2psx_zmm_k1z_ymmm256b16_sae,
		EVEX_Vcvtph2qq_xmm_k1z_xmmm32b16,
		EVEX_Vcvtph2qq_ymm_k1z_xmmm64b16,
		EVEX_Vcvtph2qq_zmm_k1z_xmmm128b16_er,
		EVEX_Vcvtph2udq_xmm_k1z_xmmm64b16,
		EVEX_Vcvtph2udq_ymm_k1z_xmmm128b16,
		EVEX_Vcvtph2udq_zmm_k1z_ymmm256b16_er,
		EVEX_Vcvtph2uqq_xmm_k1z_xmmm32b16,
		EVEX_Vcvtph2uqq_ymm_k1z_xmmm64b16,
		EVEX_Vcvtph2uqq_zmm_k1z_xmmm128b16_er,
		EVEX_Vcvtph2uw_xmm_k1z_xmmm128b16,
		EVEX_Vcvtph2uw_ymm_k1z_ymmm256b16,
		EVEX_Vcvtph2uw_zmm_k1z_zmmm512b16_er,
		EVEX_Vcvtph2w_xmm_k1z_xmmm128b16,
		EVEX_Vcvtph2w_ymm_k1z_ymmm256b16,
		EVEX_Vcvtph2w_zmm_k1z_zmmm512b16_er,
		EVEX_Vcvtps2phx_xmm_k1z_xmmm128b32,
		EVEX_Vcvtps2phx_xmm_k1z_ymmm256b32,
		EVEX_Vcvtps2phx_ymm_k1z_zmmm512b32_er,
		EVEX_Vcvtqq2ph_xmm_k1z_xmmm128b64,
		EVEX_Vcvtqq2ph_xmm_k1z_ymmm256b64,
		EVEX_Vcvtqq2ph_xmm_k1z_zmmm512b64_er,
		EVEX_Vcvtsd2sh_xmm_k1z_xmm_xmmm64_er,
		EVEX_Vcvtsh2sd_xmm_k1z_xmm_xmmm16_sae,
		EVEX_Vcvtsh2si_r32_xmmm16_er,
		EVEX_Vcvtsh2si_r64_xmmm16_er,
		EVEX_Vcvtsh2ss_xmm_k1z_xmm_xmmm16_sae,
		EVEX_Vcvtsh2usi_r32_xmmm16_er,
		EVEX_Vcvtsh2usi_r64_xmmm16_er,
		EVEX_Vcvtsi2sh_xmm_xmm_rm32_er,
		EVEX_Vcvtsi2sh_xmm_xmm_rm64_er,
		EVEX_Vcvtss2sh_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vcvttph2dq_xmm_k1z_xmmm64b16,
		EVEX_Vcvttph2dq_ymm_k1z_xmmm128b16,
		EVEX_Vcvttph2dq_zmm_k1z_ymmm256b16_sae,
		EVEX_Vcvttph2qq_xmm_k1z_xmmm32b16,
		EVEX_Vcvttph2qq_ymm_k1z_xmmm64b16,
		EVEX_Vcvttph2qq_zmm_k1z_xmmm128b16_sae,
		EVEX_Vcvttph2udq_xmm_k1z_xmmm64b16,
		EVEX_Vcvttph2udq_ymm_k1z_xmmm128b16,
		EVEX_Vcvttph2udq_zmm_k1z_ymmm256b16_sae,
		EVEX_Vcvttph2uqq_xmm_k1z_xmmm32b16,
		EVEX_Vcvttph2uqq_ymm_k1z_xmmm64b16,
		EVEX_Vcvttph2uqq_zmm_k1z_xmmm128b16_sae,
		EVEX_Vcvttph2uw_xmm_k1z_xmmm128b16,
		EVEX_Vcvttph2uw_ymm_k1z_ymmm256b16,
		EVEX_Vcvttph2uw_zmm_k1z_zmmm512b16_sae,
		EVEX_Vcvttph2w_xmm_k1z_xmmm128b16,
		EVEX_Vcvttph2w_ymm_k1z_ymmm256b16,
		EVEX_Vcvttph2w_zmm_k1z_zmmm512b16_sae,
		EVEX_Vcvttsh2si_r32_xmmm16_sae,
		EVEX_Vcvttsh2si_r64_xmmm16_sae,
		EVEX_Vcvttsh2usi_r32_xmmm16_sae,
		EVEX_Vcvttsh2usi_r64_xmmm16_sae,
		EVEX_Vcvtudq2ph_xmm_k1z_xmmm128b32,
		EVEX_Vcvtudq2ph_xmm_k1z_ymmm256b32,
		EVEX_Vcvtudq2ph_ymm_k1z_zmmm512b32_er,
		EVEX_Vcvtuqq2ph_xmm_k1z_xmmm128b64,
		EVEX_Vcvtuqq2ph_xmm_k1z_ymmm256b64,
		EVEX_Vcvtuqq2ph_xmm_k1z_zmmm512b64_er,
		EVEX_Vcvtusi2sh_xmm_xmm_rm32_er,
		EVEX_Vcvtusi2sh_xmm_xmm_rm64_er,
		EVEX_Vcvtuw2ph_xmm_k1z_xmmm128b16,
		EVEX_Vcvtuw2ph_ymm_k1z_ymmm256b16,
		EVEX_Vcvtuw2ph_zmm_k1z_zmmm512b16_er,
		EVEX_Vcvtw2ph_xmm_k1z_xmmm128b16,
		EVEX_Vcvtw2ph_ymm_k1z_ymmm256b16,
		EVEX_Vcvtw2ph_zmm_k1z_zmmm512b16_er,
		EVEX_Vdivph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vdivph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vdivph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vdivsh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfcmaddcph_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfcmaddcph_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfcmaddcph_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmaddcph_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmaddcph_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmaddcph_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfcmaddcsh_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfmaddcsh_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfcmulcph_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfcmulcph_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfcmulcph_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfmulcph_xmm_k1z_xmm_xmmm128b32,
		EVEX_Vfmulcph_ymm_k1z_ymm_ymmm256b32,
		EVEX_Vfmulcph_zmm_k1z_zmm_zmmm512b32_er,
		EVEX_Vfcmulcsh_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfmulcsh_xmm_k1z_xmm_xmmm32_er,
		EVEX_Vfmaddsub132ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmaddsub132ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmaddsub132ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmaddsub213ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmaddsub213ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmaddsub213ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmaddsub231ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmaddsub231ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmaddsub231ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmsubadd132ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmsubadd132ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmsubadd132ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmsubadd213ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmsubadd213ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmsubadd213ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmsubadd231ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmsubadd231ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmsubadd231ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmadd132ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmadd132ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmadd132ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmadd213ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmadd213ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmadd213ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmadd231ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmadd231ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmadd231ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfnmadd132ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfnmadd132ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfnmadd132ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfnmadd213ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfnmadd213ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfnmadd213ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfnmadd231ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfnmadd231ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfnmadd231ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmadd132sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfmadd213sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfmadd231sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfnmadd132sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfnmadd213sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfnmadd231sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfmsub132ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmsub132ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmsub132ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmsub213ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmsub213ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmsub213ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmsub231ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfmsub231ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfmsub231ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfnmsub132ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfnmsub132ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfnmsub132ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfnmsub213ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfnmsub213ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfnmsub213ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfnmsub231ph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vfnmsub231ph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vfnmsub231ph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vfmsub132sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfmsub213sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfmsub231sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfnmsub132sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfnmsub213sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfnmsub231sh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vfpclassph_kr_k1_xmmm128b16_imm8,
		EVEX_Vfpclassph_kr_k1_ymmm256b16_imm8,
		EVEX_Vfpclassph_kr_k1_zmmm512b16_imm8,
		EVEX_Vfpclasssh_kr_k1_xmmm16_imm8,
		EVEX_Vgetexpph_xmm_k1z_xmmm128b16,
		EVEX_Vgetexpph_ymm_k1z_ymmm256b16,
		EVEX_Vgetexpph_zmm_k1z_zmmm512b16_sae,
		EVEX_Vgetexpsh_xmm_k1z_xmm_xmmm16_sae,
		EVEX_Vgetmantph_xmm_k1z_xmmm128b16_imm8,
		EVEX_Vgetmantph_ymm_k1z_ymmm256b16_imm8,
		EVEX_Vgetmantph_zmm_k1z_zmmm512b16_imm8_sae,
		EVEX_Vgetmantsh_xmm_k1z_xmm_xmmm16_imm8_sae,
		EVEX_Vmaxph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vmaxph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vmaxph_zmm_k1z_zmm_zmmm512b16_sae,
		EVEX_Vmaxsh_xmm_k1z_xmm_xmmm16_sae,
		EVEX_Vminph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vminph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vminph_zmm_k1z_zmm_zmmm512b16_sae,
		EVEX_Vminsh_xmm_k1z_xmm_xmmm16_sae,
		EVEX_Vmovsh_xmm_k1z_m16,
		EVEX_Vmovsh_m16_k1_xmm,
		EVEX_Vmovsh_xmm_k1z_xmm_xmm,
		EVEX_Vmovsh_xmm_k1z_xmm_xmm_MAP5_11,
		EVEX_Vmovw_xmm_r32m16,
		EVEX_Vmovw_xmm_r64m16,
		EVEX_Vmovw_r32m16_xmm,
		EVEX_Vmovw_r64m16_xmm,
		EVEX_Vmulph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vmulph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vmulph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vmulsh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vrcpph_xmm_k1z_xmmm128b16,
		EVEX_Vrcpph_ymm_k1z_ymmm256b16,
		EVEX_Vrcpph_zmm_k1z_zmmm512b16,
		EVEX_Vrcpsh_xmm_k1z_xmm_xmmm16,
		EVEX_Vreduceph_xmm_k1z_xmmm128b16_imm8,
		EVEX_Vreduceph_ymm_k1z_ymmm256b16_imm8,
		EVEX_Vreduceph_zmm_k1z_zmmm512b16_imm8_sae,
		EVEX_Vreducesh_xmm_k1z_xmm_xmmm16_imm8_sae,
		EVEX_Vrndscaleph_xmm_k1z_xmmm128b16_imm8,
		EVEX_Vrndscaleph_ymm_k1z_ymmm256b16_imm8,
		EVEX_Vrndscaleph_zmm_k1z_zmmm512b16_imm8_sae,
		EVEX_Vrndscalesh_xmm_k1z_xmm_xmmm16_imm8_sae,
		EVEX_Vrsqrtph_xmm_k1z_xmmm128b16,
		EVEX_Vrsqrtph_ymm_k1z_ymmm256b16,
		EVEX_Vrsqrtph_zmm_k1z_zmmm512b16,
		EVEX_Vrsqrtsh_xmm_k1z_xmm_xmmm16,
		EVEX_Vscalefph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vscalefph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vscalefph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vscalefsh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vsqrtph_xmm_k1z_xmmm128b16,
		EVEX_Vsqrtph_ymm_k1z_ymmm256b16,
		EVEX_Vsqrtph_zmm_k1z_zmmm512b16_er,
		EVEX_Vsqrtsh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vsubph_xmm_k1z_xmm_xmmm128b16,
		EVEX_Vsubph_ymm_k1z_ymm_ymmm256b16,
		EVEX_Vsubph_zmm_k1z_zmm_zmmm512b16_er,
		EVEX_Vsubsh_xmm_k1z_xmm_xmmm16_er,
		EVEX_Vucomish_xmm_xmmm16_sae,
		Rdudbg,
		Wrudbg,
		VEX_KNC_Jkzd_kr_rel8_64,
		VEX_KNC_Jknzd_kr_rel8_64,
		VEX_KNC_Vprefetchnta_m8,
		VEX_KNC_Vprefetch0_m8,
		VEX_KNC_Vprefetch1_m8,
		VEX_KNC_Vprefetch2_m8,
		VEX_KNC_Vprefetchenta_m8,
		VEX_KNC_Vprefetche0_m8,
		VEX_KNC_Vprefetche1_m8,
		VEX_KNC_Vprefetche2_m8,
		VEX_KNC_Kand_kr_kr,
		VEX_KNC_Kandn_kr_kr,
		VEX_KNC_Kandnr_kr_kr,
		VEX_KNC_Knot_kr_kr,
		VEX_KNC_Kor_kr_kr,
		VEX_KNC_Kxnor_kr_kr,
		VEX_KNC_Kxor_kr_kr,
		VEX_KNC_Kmerge2l1h_kr_kr,
		VEX_KNC_Kmerge2l1l_kr_kr,
		VEX_KNC_Jkzd_kr_rel32_64,
		VEX_KNC_Jknzd_kr_rel32_64,
		VEX_KNC_Kmov_kr_kr,
		VEX_KNC_Kmov_kr_r32,
		VEX_KNC_Kmov_r32_kr,
		VEX_KNC_Kconcath_r64_kr_kr,
		VEX_KNC_Kconcatl_r64_kr_kr,
		VEX_KNC_Kortest_kr_kr,
		VEX_KNC_Delay_r32,
		VEX_KNC_Delay_r64,
		VEX_KNC_Spflt_r32,
		VEX_KNC_Spflt_r64,
		VEX_KNC_Clevict1_m8,
		VEX_KNC_Clevict0_m8,
		VEX_KNC_Popcnt_r32_r32,
		VEX_KNC_Popcnt_r64_r64,
		VEX_KNC_Tzcnt_r32_r32,
		VEX_KNC_Tzcnt_r64_r64,
		VEX_KNC_Tzcnti_r32_r32,
		VEX_KNC_Tzcnti_r64_r64,
		VEX_KNC_Lzcnt_r32_r32,
		VEX_KNC_Lzcnt_r64_r64,
		VEX_KNC_Undoc_r32_rm32_128_F3_0F38_W0_F0,
		VEX_KNC_Undoc_r64_rm64_128_F3_0F38_W1_F0,
		VEX_KNC_Undoc_r32_rm32_128_F2_0F38_W0_F0,
		VEX_KNC_Undoc_r64_rm64_128_F2_0F38_W1_F0,
		VEX_KNC_Undoc_r32_rm32_128_F2_0F38_W0_F1,
		VEX_KNC_Undoc_r64_rm64_128_F2_0F38_W1_F1,
		VEX_KNC_Kextract_kr_r64_imm8,
		MVEX_Vprefetchnta_m,
		MVEX_Vprefetch0_m,
		MVEX_Vprefetch1_m,
		MVEX_Vprefetch2_m,
		MVEX_Vprefetchenta_m,
		MVEX_Vprefetche0_m,
		MVEX_Vprefetche1_m,
		MVEX_Vprefetche2_m,
		MVEX_Vmovaps_zmm_k1_zmmmt,
		MVEX_Vmovapd_zmm_k1_zmmmt,
		MVEX_Vmovaps_mt_k1_zmm,
		MVEX_Vmovapd_mt_k1_zmm,
		MVEX_Vmovnrapd_m_k1_zmm,
		MVEX_Vmovnrngoapd_m_k1_zmm,
		MVEX_Vmovnraps_m_k1_zmm,
		MVEX_Vmovnrngoaps_m_k1_zmm,
		MVEX_Vaddps_zmm_k1_zmm_zmmmt,
		MVEX_Vaddpd_zmm_k1_zmm_zmmmt,
		MVEX_Vmulps_zmm_k1_zmm_zmmmt,
		MVEX_Vmulpd_zmm_k1_zmm_zmmmt,
		MVEX_Vcvtps2pd_zmm_k1_zmmmt,
		MVEX_Vcvtpd2ps_zmm_k1_zmmmt,
		MVEX_Vsubps_zmm_k1_zmm_zmmmt,
		MVEX_Vsubpd_zmm_k1_zmm_zmmmt,
		MVEX_Vpcmpgtd_kr_k1_zmm_zmmmt,
		MVEX_Vmovdqa32_zmm_k1_zmmmt,
		MVEX_Vmovdqa64_zmm_k1_zmmmt,
		MVEX_Vpshufd_zmm_k1_zmmmt_imm8,
		MVEX_Vpsrld_zmm_k1_zmmmt_imm8,
		MVEX_Vpsrad_zmm_k1_zmmmt_imm8,
		MVEX_Vpslld_zmm_k1_zmmmt_imm8,
		MVEX_Vpcmpeqd_kr_k1_zmm_zmmmt,
		MVEX_Vcvtudq2pd_zmm_k1_zmmmt,
		MVEX_Vmovdqa32_mt_k1_zmm,
		MVEX_Vmovdqa64_mt_k1_zmm,
		MVEX_Clevict1_m,
		MVEX_Clevict0_m,
		MVEX_Vcmpps_kr_k1_zmm_zmmmt_imm8,
		MVEX_Vcmppd_kr_k1_zmm_zmmmt_imm8,
		MVEX_Vpandd_zmm_k1_zmm_zmmmt,
		MVEX_Vpandq_zmm_k1_zmm_zmmmt,
		MVEX_Vpandnd_zmm_k1_zmm_zmmmt,
		MVEX_Vpandnq_zmm_k1_zmm_zmmmt,
		MVEX_Vcvtdq2pd_zmm_k1_zmmmt,
		MVEX_Vpord_zmm_k1_zmm_zmmmt,
		MVEX_Vporq_zmm_k1_zmm_zmmmt,
		MVEX_Vpxord_zmm_k1_zmm_zmmmt,
		MVEX_Vpxorq_zmm_k1_zmm_zmmmt,
		MVEX_Vpsubd_zmm_k1_zmm_zmmmt,
		MVEX_Vpaddd_zmm_k1_zmm_zmmmt,
		MVEX_Vbroadcastss_zmm_k1_mt,
		MVEX_Vbroadcastsd_zmm_k1_mt,
		MVEX_Vbroadcastf32x4_zmm_k1_mt,
		MVEX_Vbroadcastf64x4_zmm_k1_mt,
		MVEX_Vptestmd_kr_k1_zmm_zmmmt,
		MVEX_Vpermd_zmm_k1_zmm_zmmmt,
		MVEX_Vpminsd_zmm_k1_zmm_zmmmt,
		MVEX_Vpminud_zmm_k1_zmm_zmmmt,
		MVEX_Vpmaxsd_zmm_k1_zmm_zmmmt,
		MVEX_Vpmaxud_zmm_k1_zmm_zmmmt,
		MVEX_Vpmulld_zmm_k1_zmm_zmmmt,
		MVEX_Vgetexpps_zmm_k1_zmmmt,
		MVEX_Vgetexppd_zmm_k1_zmmmt,
		MVEX_Vpsrlvd_zmm_k1_zmm_zmmmt,
		MVEX_Vpsravd_zmm_k1_zmm_zmmmt,
		MVEX_Vpsllvd_zmm_k1_zmm_zmmmt,
		MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_48,
		MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_49,
		MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_4A,
		MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_4B,
		MVEX_Vaddnps_zmm_k1_zmm_zmmmt,
		MVEX_Vaddnpd_zmm_k1_zmm_zmmmt,
		MVEX_Vgmaxabsps_zmm_k1_zmm_zmmmt,
		MVEX_Vgminps_zmm_k1_zmm_zmmmt,
		MVEX_Vgminpd_zmm_k1_zmm_zmmmt,
		MVEX_Vgmaxps_zmm_k1_zmm_zmmmt,
		MVEX_Vgmaxpd_zmm_k1_zmm_zmmmt,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_54,
		MVEX_Vfixupnanps_zmm_k1_zmm_zmmmt,
		MVEX_Vfixupnanpd_zmm_k1_zmm_zmmmt,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_56,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_57,
		MVEX_Vpbroadcastd_zmm_k1_mt,
		MVEX_Vpbroadcastq_zmm_k1_mt,
		MVEX_Vbroadcasti32x4_zmm_k1_mt,
		MVEX_Vbroadcasti64x4_zmm_k1_mt,
		MVEX_Vpadcd_zmm_k1_kr_zmmmt,
		MVEX_Vpaddsetcd_zmm_k1_kr_zmmmt,
		MVEX_Vpsbbd_zmm_k1_kr_zmmmt,
		MVEX_Vpsubsetbd_zmm_k1_kr_zmmmt,
		MVEX_Vpblendmd_zmm_k1_zmm_zmmmt,
		MVEX_Vpblendmq_zmm_k1_zmm_zmmmt,
		MVEX_Vblendmps_zmm_k1_zmm_zmmmt,
		MVEX_Vblendmpd_zmm_k1_zmm_zmmmt,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_67,
		MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_68,
		MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_69,
		MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_6A,
		MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_6B,
		MVEX_Vpsubrd_zmm_k1_zmm_zmmmt,
		MVEX_Vsubrps_zmm_k1_zmm_zmmmt,
		MVEX_Vsubrpd_zmm_k1_zmm_zmmmt,
		MVEX_Vpsbbrd_zmm_k1_kr_zmmmt,
		MVEX_Vpsubrsetbd_zmm_k1_kr_zmmmt,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_70,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_71,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_72,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_73,
		MVEX_Vpcmpltd_kr_k1_zmm_zmmmt,
		MVEX_Vscaleps_zmm_k1_zmm_zmmmt,
		MVEX_Vpmulhud_zmm_k1_zmm_zmmmt,
		MVEX_Vpmulhd_zmm_k1_zmm_zmmmt,
		MVEX_Vpgatherdd_zmm_k1_mvt,
		MVEX_Vpgatherdq_zmm_k1_mvt,
		MVEX_Vgatherdps_zmm_k1_mvt,
		MVEX_Vgatherdpd_zmm_k1_mvt,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_94,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W1_94,
		MVEX_Vfmadd132ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfmadd132pd_zmm_k1_zmm_zmmmt,
		MVEX_Vfmsub132ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfmsub132pd_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmadd132ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmadd132pd_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmsub132ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmsub132pd_zmm_k1_zmm_zmmmt,
		MVEX_Vpscatterdd_mvt_k1_zmm,
		MVEX_Vpscatterdq_mvt_k1_zmm,
		MVEX_Vscatterdps_mvt_k1_zmm,
		MVEX_Vscatterdpd_mvt_k1_zmm,
		MVEX_Vfmadd233ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfmadd213ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfmadd213pd_zmm_k1_zmm_zmmmt,
		MVEX_Vfmsub213ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfmsub213pd_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmadd213ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmadd213pd_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmsub213ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmsub213pd_zmm_k1_zmm_zmmmt,
		MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_B0,
		MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_B2,
		MVEX_Vpmadd233d_zmm_k1_zmm_zmmmt,
		MVEX_Vpmadd231d_zmm_k1_zmm_zmmmt,
		MVEX_Vfmadd231ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfmadd231pd_zmm_k1_zmm_zmmmt,
		MVEX_Vfmsub231ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfmsub231pd_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmadd231ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmadd231pd_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmsub231ps_zmm_k1_zmm_zmmmt,
		MVEX_Vfnmsub231pd_zmm_k1_zmm_zmmmt,
		MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_C0,
		MVEX_Vgatherpf0hintdps_mvt_k1,
		MVEX_Vgatherpf0hintdpd_mvt_k1,
		MVEX_Vgatherpf0dps_mvt_k1,
		MVEX_Vgatherpf1dps_mvt_k1,
		MVEX_Vscatterpf0hintdps_mvt_k1,
		MVEX_Vscatterpf0hintdpd_mvt_k1,
		MVEX_Vscatterpf0dps_mvt_k1,
		MVEX_Vscatterpf1dps_mvt_k1,
		MVEX_Vexp223ps_zmm_k1_zmmmt,
		MVEX_Vlog2ps_zmm_k1_zmmmt,
		MVEX_Vrcp23ps_zmm_k1_zmmmt,
		MVEX_Vrsqrt23ps_zmm_k1_zmmmt,
		MVEX_Vaddsetsps_zmm_k1_zmm_zmmmt,
		MVEX_Vpaddsetsd_zmm_k1_zmm_zmmmt,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_CE,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W1_CE,
		MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_CF,
		MVEX_Vloadunpackld_zmm_k1_mt,
		MVEX_Vloadunpacklq_zmm_k1_mt,
		MVEX_Vpackstoreld_mt_k1_zmm,
		MVEX_Vpackstorelq_mt_k1_zmm,
		MVEX_Vloadunpacklps_zmm_k1_mt,
		MVEX_Vloadunpacklpd_zmm_k1_mt,
		MVEX_Vpackstorelps_mt_k1_zmm,
		MVEX_Vpackstorelpd_mt_k1_zmm,
		MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D2,
		MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_D2,
		MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D3,
		MVEX_Vloadunpackhd_zmm_k1_mt,
		MVEX_Vloadunpackhq_zmm_k1_mt,
		MVEX_Vpackstorehd_mt_k1_zmm,
		MVEX_Vpackstorehq_mt_k1_zmm,
		MVEX_Vloadunpackhps_zmm_k1_mt,
		MVEX_Vloadunpackhpd_zmm_k1_mt,
		MVEX_Vpackstorehps_mt_k1_zmm,
		MVEX_Vpackstorehpd_mt_k1_zmm,
		MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D6,
		MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_D6,
		MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D7,
		MVEX_Valignd_zmm_k1_zmm_zmmmt_imm8,
		MVEX_Vpermf32x4_zmm_k1_zmmmt_imm8,
		MVEX_Vpcmpud_kr_k1_zmm_zmmmt_imm8,
		MVEX_Vpcmpd_kr_k1_zmm_zmmmt_imm8,
		MVEX_Vgetmantps_zmm_k1_zmmmt_imm8,
		MVEX_Vgetmantpd_zmm_k1_zmmmt_imm8,
		MVEX_Vrndfxpntps_zmm_k1_zmmmt_imm8,
		MVEX_Vrndfxpntpd_zmm_k1_zmmmt_imm8,
		MVEX_Vcvtfxpntudq2ps_zmm_k1_zmmmt_imm8,
		MVEX_Vcvtfxpntps2udq_zmm_k1_zmmmt_imm8,
		MVEX_Vcvtfxpntpd2udq_zmm_k1_zmmmt_imm8,
		MVEX_Vcvtfxpntdq2ps_zmm_k1_zmmmt_imm8,
		MVEX_Vcvtfxpntps2dq_zmm_k1_zmmmt_imm8,
		MVEX_Undoc_zmm_k1_zmmmt_imm8_512_66_0F3A_W0_D0,
		MVEX_Undoc_zmm_k1_zmmmt_imm8_512_66_0F3A_W0_D1,
		MVEX_Vcvtfxpntpd2dq_zmm_k1_zmmmt_imm8,
		Via_undoc_F30FA6F0_16,
		Via_undoc_F30FA6F0_32,
		Via_undoc_F30FA6F0_64,
		Via_undoc_F30FA6F8_16,
		Via_undoc_F30FA6F8_32,
		Via_undoc_F30FA6F8_64,
		Xsha512_16,
		Xsha512_32,
		Xsha512_64,
		Xstore_alt_16,
		Xstore_alt_32,
		Xstore_alt_64,
		Xsha512_alt_16,
		Xsha512_alt_32,
		Xsha512_alt_64,
		Zero_bytes,
		Wrmsrns,
		Wrmsrlist,
		Rdmsrlist,
		Rmpquery,
		Prefetchit1_m8,
		Prefetchit0_m8,
		Aadd_m32_r32,
		Aadd_m64_r64,
		Aand_m32_r32,
		Aand_m64_r64,
		Axor_m32_r32,
		Axor_m64_r64,
		Aor_m32_r32,
		Aor_m64_r64,
		VEX_Vpdpbuud_xmm_xmm_xmmm128,
		VEX_Vpdpbuud_ymm_ymm_ymmm256,
		VEX_Vpdpbsud_xmm_xmm_xmmm128,
		VEX_Vpdpbsud_ymm_ymm_ymmm256,
		VEX_Vpdpbssd_xmm_xmm_xmmm128,
		VEX_Vpdpbssd_ymm_ymm_ymmm256,
		VEX_Vpdpbuuds_xmm_xmm_xmmm128,
		VEX_Vpdpbuuds_ymm_ymm_ymmm256,
		VEX_Vpdpbsuds_xmm_xmm_xmmm128,
		VEX_Vpdpbsuds_ymm_ymm_ymmm256,
		VEX_Vpdpbssds_xmm_xmm_xmmm128,
		VEX_Vpdpbssds_ymm_ymm_ymmm256,
		VEX_Tdpfp16ps_tmm_tmm_tmm,
		VEX_Vcvtneps2bf16_xmm_xmmm128,
		VEX_Vcvtneps2bf16_xmm_ymmm256,
		VEX_Vcvtneoph2ps_xmm_m128,
		VEX_Vcvtneoph2ps_ymm_m256,
		VEX_Vcvtneeph2ps_xmm_m128,
		VEX_Vcvtneeph2ps_ymm_m256,
		VEX_Vcvtneebf162ps_xmm_m128,
		VEX_Vcvtneebf162ps_ymm_m256,
		VEX_Vcvtneobf162ps_xmm_m128,
		VEX_Vcvtneobf162ps_ymm_m256,
		VEX_Vbcstnesh2ps_xmm_m16,
		VEX_Vbcstnesh2ps_ymm_m16,
		VEX_Vbcstnebf162ps_xmm_m16,
		VEX_Vbcstnebf162ps_ymm_m16,
		VEX_Vpmadd52luq_xmm_xmm_xmmm128,
		VEX_Vpmadd52luq_ymm_ymm_ymmm256,
		VEX_Vpmadd52huq_xmm_xmm_xmmm128,
		VEX_Vpmadd52huq_ymm_ymm_ymmm256,
		VEX_Cmpoxadd_m32_r32_r32,
		VEX_Cmpoxadd_m64_r64_r64,
		VEX_Cmpnoxadd_m32_r32_r32,
		VEX_Cmpnoxadd_m64_r64_r64,
		VEX_Cmpbxadd_m32_r32_r32,
		VEX_Cmpbxadd_m64_r64_r64,
		VEX_Cmpnbxadd_m32_r32_r32,
		VEX_Cmpnbxadd_m64_r64_r64,
		VEX_Cmpzxadd_m32_r32_r32,
		VEX_Cmpzxadd_m64_r64_r64,
		VEX_Cmpnzxadd_m32_r32_r32,
		VEX_Cmpnzxadd_m64_r64_r64,
		VEX_Cmpbexadd_m32_r32_r32,
		VEX_Cmpbexadd_m64_r64_r64,
		VEX_Cmpnbexadd_m32_r32_r32,
		VEX_Cmpnbexadd_m64_r64_r64,
		VEX_Cmpsxadd_m32_r32_r32,
		VEX_Cmpsxadd_m64_r64_r64,
		VEX_Cmpnsxadd_m32_r32_r32,
		VEX_Cmpnsxadd_m64_r64_r64,
		VEX_Cmppxadd_m32_r32_r32,
		VEX_Cmppxadd_m64_r64_r64,
		VEX_Cmpnpxadd_m32_r32_r32,
		VEX_Cmpnpxadd_m64_r64_r64,
		VEX_Cmplxadd_m32_r32_r32,
		VEX_Cmplxadd_m64_r64_r64,
		VEX_Cmpnlxadd_m32_r32_r32,
		VEX_Cmpnlxadd_m64_r64_r64,
		VEX_Cmplexadd_m32_r32_r32,
		VEX_Cmplexadd_m64_r64_r64,
		VEX_Cmpnlexadd_m32_r32_r32,
		VEX_Cmpnlexadd_m64_r64_r64,
		VEX_Tcmmrlfp16ps_tmm_tmm_tmm,
		VEX_Tcmmimfp16ps_tmm_tmm_tmm,
		Pbndkb,
		VEX_Vsha512rnds2_ymm_ymm_xmm,
		VEX_Vsha512msg1_ymm_xmm,
		VEX_Vsha512msg2_ymm_ymm,
		VEX_Vpdpwuud_xmm_xmm_xmmm128,
		VEX_Vpdpwuud_ymm_ymm_ymmm256,
		VEX_Vpdpwusd_xmm_xmm_xmmm128,
		VEX_Vpdpwusd_ymm_ymm_ymmm256,
		VEX_Vpdpwsud_xmm_xmm_xmmm128,
		VEX_Vpdpwsud_ymm_ymm_ymmm256,
		VEX_Vpdpwuuds_xmm_xmm_xmmm128,
		VEX_Vpdpwuuds_ymm_ymm_ymmm256,
		VEX_Vpdpwusds_xmm_xmm_xmmm128,
		VEX_Vpdpwusds_ymm_ymm_ymmm256,
		VEX_Vpdpwsuds_xmm_xmm_xmmm128,
		VEX_Vpdpwsuds_ymm_ymm_ymmm256,
		VEX_Vsm3msg1_xmm_xmm_xmmm128,
		VEX_Vsm3msg2_xmm_xmm_xmmm128,
		VEX_Vsm4key4_xmm_xmm_xmmm128,
		VEX_Vsm4key4_ymm_ymm_ymmm256,
		VEX_Vsm4rnds4_xmm_xmm_xmmm128,
		VEX_Vsm4rnds4_ymm_ymm_ymmm256,
		VEX_Vsm3rnds2_xmm_xmm_xmmm128_imm8
	}
	internal static class CodeExtensions
	{
		internal static bool IgnoresSegment(this Code code)
		{
			if ((uint)(code - 290) <= 2u || (uint)(code - 1040) <= 3u || (uint)(code - 1047) <= 3u)
			{
				return true;
			}
			return false;
		}

		internal static bool IgnoresIndex(this Code code)
		{
			if (code == Code.Bndldx_bnd_mib || code == Code.Bndstx_mib_bnd)
			{
				return true;
			}
			return false;
		}

		internal static bool IsTileStrideIndex(this Code code)
		{
			if ((uint)(code - 4228) <= 2u)
			{
				return true;
			}
			return false;
		}
	}
	public abstract class CodeReader
	{
		public abstract int ReadByte();
	}
	public enum CodeSize
	{
		Unknown,
		Code16,
		Code32,
		Code64
	}
	public abstract class CodeWriter
	{
		public abstract void WriteByte(byte value);
	}
	public struct ConstantOffsets
	{
		public byte DisplacementOffset;

		public byte DisplacementSize;

		public byte ImmediateOffset;

		public byte ImmediateSize;

		public byte ImmediateOffset2;

		public byte ImmediateSize2;

		private byte pad1;

		private byte pad2;

		public readonly bool HasDisplacement => DisplacementSize != 0;

		public readonly bool HasImmediate => ImmediateSize != 0;

		public readonly bool HasImmediate2 => ImmediateSize2 != 0;
	}
	internal enum OpSize : byte
	{
		Size16,
		Size32,
		Size64
	}
	[Flags]
	internal enum StateFlags : uint
	{
		IpRel64 = 1u,
		IpRel32 = 2u,
		HasRex = 8u,
		b = 0x10u,
		z = 0x20u,
		IsInvalid = 0x40u,
		W = 0x80u,
		NoImm = 0x100u,
		Addr64 = 0x200u,
		BranchImm8 = 0x400u,
		Xbegin = 0x800u,
		Lock = 0x1000u,
		AllowLock = 0x2000u,
		NoMoreBytes = 0x4000u,
		Has66 = 0x8000u,
		MvexSssMask = 7u,
		MvexSssShift = 0x10u,
		MvexEH = 0x80000u,
		EncodingMask = 7u,
		EncodingShift = 0x1Du
	}
	public sealed class Decoder : IEnumerable<Instruction>, IEnumerable
	{
		internal struct ZState
		{
			public uint instructionLength;

			public uint extraRegisterBase;

			public uint extraIndexRegisterBase;

			public uint extraBaseRegisterBase;

			public uint extraIndexRegisterBaseVSIB;

			public StateFlags flags;

			public MandatoryPrefixByte mandatoryPrefix;

			public byte segmentPrio;
		}

		internal struct State
		{
			public uint modrm;

			public uint mod;

			public uint reg;

			public uint rm;

			public ZState zs;

			public uint vvvv;

			public uint vvvv_invalidCheck;

			public uint aaa;

			public uint extraRegisterBaseEVEX;

			public uint extraBaseRegisterBaseEVEX;

			public uint vectorLength;

			public OpSize operandSize;

			public OpSize addressSize;

			public readonly EncodingKind Encoding => (EncodingKind)(((uint)zs.flags >> 29) & 7);
		}

		private readonly struct RegInfo2
		{
			public readonly Register baseReg;

			public readonly Register indexReg;

			public RegInfo2(Register baseReg, Register indexReg)
			{
				this.baseReg = baseReg;
				this.indexReg = indexReg;
			}

			public void Deconstruct(out Register baseReg, out Register indexReg)
			{
				baseReg = this.baseReg;
				indexReg = this.indexReg;
			}
		}

		public struct Enumerator : IEnumerator<Instruction>, IEnumerator, IDisposable
		{
			private readonly Decoder decoder;

			private Instruction instruction;

			public Instruction Current => instruction;

			Instruction IEnumerator<Instruction>.Current => Current;

			object IEnumerator.Current => Current;

			internal Enumerator(Decoder decoder)
			{
				this.decoder = decoder;
				instruction = default(Instruction);
			}

			public bool MoveNext()
			{
				decoder.Decode(out instruction);
				return instruction.Length != 0;
			}

			void IEnumerator.Reset()
			{
				throw new InvalidOperationException();
			}

			public void Dispose()
			{
			}
		}

		private ulong instructionPointer;

		private readonly CodeReader reader;

		private readonly RegInfo2[] memRegs16;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_MAP0;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_VEX_0F;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_VEX_0F38;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_VEX_0F3A;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_EVEX_0F;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_EVEX_0F38;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_EVEX_0F3A;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_EVEX_MAP5;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_EVEX_MAP6;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_XOP_MAP8;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_XOP_MAP9;

		private readonly Iced.Intel.DecoderInternal.OpCodeHandler[] handlers_XOP_MAP10;

		internal State state;

		internal uint displIndex;

		internal readonly DecoderOptions options;

		internal readonly uint invalidCheckMask;

		internal readonly uint is64bMode_and_W;

		internal readonly uint reg15Mask;

		private readonly uint maskE0;

		private readonly uint rexMask;

		internal readonly CodeSize defaultCodeSize;

		internal readonly OpSize defaultOperandSize;

		private readonly OpSize defaultAddressSize;

		internal readonly OpSize defaultInvertedOperandSize;

		internal readonly OpSize defaultInvertedAddressSize;

		internal readonly bool is64bMode;

		private static readonly RegInfo2[] s_memRegs16;

		public ulong IP
		{
			get
			{
				return instructionPointer;
			}
			set
			{
				instructionPointer = value;
			}
		}

		public int Bitness { get; }

		public DecoderError LastError
		{
			get
			{
				if ((state.zs.flags & StateFlags.NoMoreBytes) != 0)
				{
					return DecoderError.NoMoreBytes;
				}
				if ((state.zs.flags & StateFlags.IsInvalid) != 0)
				{
					return DecoderError.InvalidInstruction;
				}
				return DecoderError.None;
			}
		}

		static Decoder()
		{
			s_memRegs16 = new RegInfo2[8]
			{
				new RegInfo2(Register.BX, Register.SI),
				new RegInfo2(Register.BX, Register.DI),
				new RegInfo2(Register.BP, Register.SI),
				new RegInfo2(Register.BP, Register.DI),
				new RegInfo2(Register.SI, Register.None),
				new RegInfo2(Register.DI, Register.None),
				new RegInfo2(Register.BP, Register.None),
				new RegInfo2(Register.BX, Register.None)
			};
			_ = OpCodeHandler_Invalid.Instance;
			_ = InstructionMemorySizes.SizesNormal;
			_ = OpCodeHandler_D3NOW.CodeValues;
			_ = InstructionOpCounts.OpCount;
			_ = MnemonicUtilsData.toMnemonic;
		}

		private Decoder(CodeReader reader, ulong ip, DecoderOptions options, int bitness)
		{
			this.reader = reader ?? throw new ArgumentNullException("reader");
			instructionPointer = ip;
			this.options = options;
			invalidCheckMask = (((options & DecoderOptions.NoInvalidCheck) == 0) ? uint.MaxValue : 0u);
			memRegs16 = s_memRegs16;
			Bitness = bitness;
			switch (bitness)
			{
			case 64:
				is64bMode = true;
				defaultCodeSize = CodeSize.Code64;
				defaultOperandSize = OpSize.Size32;
				defaultInvertedOperandSize = OpSize.Size16;
				defaultAddressSize = OpSize.Size64;
				defaultInvertedAddressSize = OpSize.Size32;
				maskE0 = 224u;
				rexMask = 240u;
				break;
			case 32:
				is64bMode = false;
				defaultCodeSize = CodeSize.Code32;
				defaultOperandSize = OpSize.Size32;
				defaultInvertedOperandSize = OpSize.Size16;
				defaultAddressSize = OpSize.Size32;
				defaultInvertedAddressSize = OpSize.Size16;
				maskE0 = 0u;
				rexMask = 0u;
				break;
			default:
				is64bMode = false;
				defaultCodeSize = CodeSize.Code16;
				defaultOperandSize = OpSize.Size16;
				defaultInvertedOperandSize = OpSize.Size32;
				defaultAddressSize = OpSize.Size16;
				defaultInvertedAddressSize = OpSize.Size32;
				maskE0 = 0u;
				rexMask = 0u;
				break;
			}
			is64bMode_and_W = (is64bMode ? 128u : 0u);
			reg15Mask = (is64bMode ? 15u : 7u);
			handlers_MAP0 = OpCodeHandlersTables_Legacy.Handlers_MAP0;
			handlers_VEX_0F = OpCodeHandlersTables_VEX.Handlers_0F;
			handlers_VEX_0F38 = OpCodeHandlersTables_VEX.Handlers_0F38;
			handlers_VEX_0F3A = OpCodeHandlersTables_VEX.Handlers_0F3A;
			handlers_EVEX_0F = OpCodeHandlersTables_EVEX.Handlers_0F;
			handlers_EVEX_0F38 = OpCodeHandlersTables_EVEX.Handlers_0F38;
			handlers_EVEX_0F3A = OpCodeHandlersTables_EVEX.Handlers_0F3A;
			handlers_EVEX_MAP5 = OpCodeHandlersTables_EVEX.Handlers_MAP5;
			handlers_EVEX_MAP6 = OpCodeHandlersTables_EVEX.Handlers_MAP6;
			handlers_XOP_MAP8 = OpCodeHandlersTables_XOP.Handlers_MAP8;
			handlers_XOP_MAP9 = OpCodeHandlersTables_XOP.Handlers_MAP9;
			handlers_XOP_MAP10 = OpCodeHandlersTables_XOP.Handlers_MAP10;
		}

		public static Decoder Create(int bitness, CodeReader reader, ulong ip, DecoderOptions options = DecoderOptions.None)
		{
			if (bitness == 16 || bitness == 32 || bitness == 64)
			{
				return new Decoder(reader, ip, options, bitness);
			}
			throw new ArgumentOutOfRangeException("bitness");
		}

		public static Decoder Create(int bitness, byte[] data, ulong ip, DecoderOptions options = DecoderOptions.None)
		{
			return Create(bitness, new ByteArrayCodeReader(data), ip, options);
		}

		public static Decoder Create(int bitness, CodeReader reader, DecoderOptions options = DecoderOptions.None)
		{
			return Create(bitness, reader, 0uL, options);
		}

		public static Decoder Create(int bitness, byte[] data, DecoderOptions options = DecoderOptions.None)
		{
			return Create(bitness, new ByteArrayCodeReader(data), 0uL, options);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal uint ReadByte()
		{
			uint instructionLength = state.zs.instructionLength;
			if (instructionLength < 15)
			{
				uint num = (uint)reader.ReadByte();
				if (num <= 255)
				{
					state.zs.instructionLength = instructionLength + 1;
					return num;
				}
				state.zs.flags |= StateFlags.NoMoreBytes;
			}
			state.zs.flags |= StateFlags.IsInvalid;
			return 0u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal uint ReadUInt16()
		{
			return ReadByte() | (ReadByte() << 8);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal uint ReadUInt32()
		{
			return ReadByte() | (ReadByte() << 8) | (ReadByte() << 16) | (ReadByte() << 24);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ulong ReadUInt64()
		{
			return ReadUInt32() | ((ulong)ReadUInt32() << 32);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Instruction Decode()
		{
			Decode(out var instruction);
			return instruction;
		}

		public void Decode(out Instruction instruction)
		{
			instruction = default(Instruction);
			state.zs = default(ZState);
			state.operandSize = defaultOperandSize;
			state.addressSize = defaultAddressSize;
			uint num = ReadByte();
			if ((num & rexMask) == 64)
			{
				StateFlags stateFlags = state.zs.flags | StateFlags.HasRex;
				if ((num & 8) != 0)
				{
					stateFlags |= StateFlags.W;
					state.operandSize = OpSize.Size64;
				}
				state.zs.flags = stateFlags;
				state.zs.extraRegisterBase = (num << 1) & 8;
				state.zs.extraIndexRegisterBase = (num << 2) & 8;
				state.zs.extraBaseRegisterBase = (num << 3) & 8;
				num = ReadByte();
			}
			DecodeTable(handlers_MAP0[num], ref instruction);
			instruction.InternalCodeSize = defaultCodeSize;
			uint num2 = (uint)(instruction.Length = (int)state.zs.instructionLength);
			ulong num3 = instructionPointer;
			num3 = (instruction.NextIP = (instructionPointer = num3 + num2));
			StateFlags flags = state.zs.flags;
			if ((flags & (StateFlags.IpRel64 | StateFlags.IpRel32 | StateFlags.IsInvalid | StateFlags.Lock)) == 0)
			{
				return;
			}
			ulong num5 = (instruction.MemoryDisplacement64 += num3);
			if ((flags & (StateFlags.IpRel64 | StateFlags.IsInvalid | StateFlags.Lock)) != StateFlags.IpRel64)
			{
				if ((flags & StateFlags.IpRel64) == 0)
				{
					instruction.MemoryDisplacement64 = num5 - num3;
				}
				if ((flags & StateFlags.IpRel32) != 0)
				{
					instruction.MemoryDisplacement64 = (uint)((int)instruction.MemoryDisplacement64 + (int)num3);
				}
				if ((flags & StateFlags.IsInvalid) != 0 || ((uint)(flags & (StateFlags.Lock | StateFlags.AllowLock)) & invalidCheckMask) == 4096)
				{
					instruction = default(Instruction);
					state.zs.flags = flags | StateFlags.IsInvalid;
					instruction.InternalCodeSize = defaultCodeSize;
					instruction.Length = (int)num2;
					instruction.NextIP = num3;
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ResetRexPrefixState()
		{
			state.zs.flags &= ~(StateFlags.HasRex | StateFlags.W);
			if ((state.zs.flags & StateFlags.Has66) == 0)
			{
				state.operandSize = defaultOperandSize;
			}
			else
			{
				state.operandSize = defaultInvertedOperandSize;
			}
			state.zs.extraRegisterBase = 0u;
			state.zs.extraIndexRegisterBase = 0u;
			state.zs.extraBaseRegisterBase = 0u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void CallOpCodeHandlerXXTable(ref Instruction instruction)
		{
			uint num = ReadByte();
			DecodeTable(handlers_MAP0[num], ref instruction);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal uint GetCurrentInstructionPointer32()
		{
			return (uint)(int)instructionPointer + state.zs.instructionLength;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ulong GetCurrentInstructionPointer64()
		{
			return instructionPointer + state.zs.instructionLength;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ClearMandatoryPrefix(ref Instruction instruction)
		{
			instruction.InternalClearHasRepeRepnePrefix();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void SetXacquireXrelease(ref Instruction instruction)
		{
			if (instruction.HasLockPrefix)
			{
				if (state.zs.mandatoryPrefix == MandatoryPrefixByte.PF2)
				{
					ClearMandatoryPrefixF2(ref instruction);
					instruction.InternalSetHasXacquirePrefix();
				}
				else if (state.zs.mandatoryPrefix == MandatoryPrefixByte.PF3)
				{
					ClearMandatoryPrefixF3(ref instruction);
					instruction.InternalSetHasXreleasePrefix();
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ClearMandatoryPrefixF3(ref Instruction instruction)
		{
			instruction.InternalClearHasRepePrefix();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ClearMandatoryPrefixF2(ref Instruction instruction)
		{
			instruction.InternalClearHasRepnePrefix();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void SetInvalidInstruction()
		{
			state.zs.flags |= StateFlags.IsInvalid;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void DecodeTable(Iced.Intel.DecoderInternal.OpCodeHandler[] table, ref Instruction instruction)
		{
			DecodeTable(table[ReadByte()], ref instruction);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void DecodeTable(Iced.Intel.DecoderInternal.OpCodeHandler handler, ref Instruction instruction)
		{
			if (handler.HasModRM)
			{
				uint num = ReadByte();
				state.modrm = num;
				state.mod = num >> 6;
				state.reg = (num >> 3) & 7;
				state.rm = num & 7;
			}
			handler.Decode(this, ref instruction);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ReadModRM()
		{
			uint num = ReadByte();
			state.modrm = num;
			state.mod = num >> 6;
			state.reg = (num >> 3) & 7;
			state.rm = num & 7;
		}

		internal void VEX2(ref Instruction instruction)
		{
			if ((((uint)(state.zs.flags & StateFlags.HasRex) | (uint)state.zs.mandatoryPrefix) & invalidCheckMask) != 0)
			{
				SetInvalidInstruction();
			}
			state.zs.flags &= ~StateFlags.W;
			state.zs.extraIndexRegisterBase = 0u;
			state.zs.extraBaseRegisterBase = 0u;
			uint modrm = state.modrm;
			state.vectorLength = (modrm >> 2) & 1;
			state.zs.mandatoryPrefix = (MandatoryPrefixByte)(modrm & 3);
			modrm = ~modrm;
			state.zs.extraRegisterBase = (modrm >> 4) & 8;
			modrm = (modrm >> 3) & 0xF;
			state.vvvv = modrm;
			state.vvvv_invalidCheck = modrm;
			DecodeTable(handlers_VEX_0F, ref instruction);
		}

		internal void VEX3(ref Instruction instruction)
		{
			if ((((uint)(state.zs.flags & StateFlags.HasRex) | (uint)state.zs.mandatoryPrefix) & invalidCheckMask) != 0)
			{
				SetInvalidInstruction();
			}
			state.zs.flags &= ~StateFlags.W;
			uint num = ReadByte();
			state.zs.flags |= (StateFlags)(num & 0x80);
			state.vectorLength = (num >> 2) & 1;
			state.zs.mandatoryPrefix = (MandatoryPrefixByte)(num & 3);
			num = (~num >> 3) & 0xF;
			state.vvvv_invalidCheck = num;
			state.vvvv = num & reg15Mask;
			uint modrm = state.modrm;
			uint num2 = ~modrm & maskE0;
			state.zs.extraRegisterBase = (num2 >> 4) & 8;
			state.zs.extraIndexRegisterBase = (num2 >> 3) & 8;
			state.zs.extraBaseRegisterBase = (num2 >> 2) & 8;
			uint num3 = ReadByte();
			Iced.Intel.DecoderInternal.OpCodeHandler[] array;
			switch ((int)(modrm & 0x1F))
			{
			case 1:
				array = handlers_VEX_0F;
				break;
			case 2:
				array = handlers_VEX_0F38;
				break;
			case 3:
				array = handlers_VEX_0F3A;
				break;
			default:
				SetInvalidInstruction();
				return;
			}
			DecodeTable(array[num3], ref instruction);
		}

		internal void XOP(ref Instruction instruction)
		{
			if ((((uint)(state.zs.flags & StateFlags.HasRex) | (uint)state.zs.mandatoryPrefix) & invalidCheckMask) != 0)
			{
				SetInvalidInstruction();
			}
			state.zs.flags &= ~StateFlags.W;
			uint num = ReadByte();
			state.zs.flags |= (StateFlags)(num & 0x80);
			state.vectorLength = (num >> 2) & 1;
			state.zs.mandatoryPrefix = (MandatoryPrefixByte)(num & 3);
			num = (~num >> 3) & 0xF;
			state.vvvv_invalidCheck = num;
			state.vvvv = num & reg15Mask;
			uint modrm = state.modrm;
			uint num2 = ~modrm & maskE0;
			state.zs.extraRegisterBase = (num2 >> 4) & 8;
			state.zs.extraIndexRegisterBase = (num2 >> 3) & 8;
			state.zs.extraBaseRegisterBase = (num2 >> 2) & 8;
			uint num3 = ReadByte();
			Iced.Intel.DecoderInternal.OpCodeHandler[] array;
			switch ((int)(modrm & 0x1F))
			{
			case 8:
				array = handlers_XOP_MAP8;
				break;
			case 9:
				array = handlers_XOP_MAP9;
				break;
			case 10:
				array = handlers_XOP_MAP10;
				break;
			default:
				SetInvalidInstruction();
				return;
			}
			DecodeTable(array[num3], ref instruction);
		}

		internal void EVEX_MVEX(ref Instruction instruction)
		{
			if ((((uint)(state.zs.flags & StateFlags.HasRex) | (uint)state.zs.mandatoryPrefix) & invalidCheckMask) != 0)
			{
				SetInvalidInstruction();
			}
			state.zs.flags &= ~StateFlags.W;
			uint modrm = state.modrm;
			uint num = ReadByte();
			uint num2 = ReadByte();
			uint num3 = ReadByte();
			uint num4 = ReadByte();
			if ((num & 4) != 0)
			{
				if ((modrm & 8) == 0)
				{
					state.zs.mandatoryPrefix = (MandatoryPrefixByte)(num & 3);
					state.zs.flags |= (StateFlags)(num & 0x80);
					uint num5 = num2 & 7;
					state.aaa = num5;
					instruction.InternalOpMask = num5;
					if ((num2 & 0x80) != 0)
					{
						if ((num5 ^ invalidCheckMask) == uint.MaxValue)
						{
							SetInvalidInstruction();
						}
						state.zs.flags |= StateFlags.z;
						instruction.InternalSetZeroingMasking();
					}
					state.zs.flags |= (StateFlags)(num2 & 0x10);
					state.vectorLength = (num2 >> 5) & 3;
					num = (~num >> 3) & 0xF;
					if (is64bMode)
					{
						uint num6 = (~num2 & 8) << 1;
						state.zs.extraIndexRegisterBaseVSIB = num6;
						num6 += num;
						state.vvvv = num6;
						state.vvvv_invalidCheck = num6;
						uint num7 = ~modrm;
						state.zs.extraRegisterBase = (num7 >> 4) & 8;
						state.zs.extraIndexRegisterBase = (num7 >> 3) & 8;
						state.extraRegisterBaseEVEX = num7 & 0x10;
						num7 >>= 2;
						state.extraBaseRegisterBaseEVEX = num7 & 0x18;
						state.zs.extraBaseRegisterBase = num7 & 8;
					}
					else
					{
						state.vvvv_invalidCheck = num;
						state.vvvv = num & 7;
						state.zs.flags |= (StateFlags)((~num2 & 8) << 3);
					}
					Iced.Intel.DecoderInternal.OpCodeHandler[] array;
					switch ((int)(modrm & 7))
					{
					case 1:
						array = handlers_EVEX_0F;
						break;
					case 2:
						array = handlers_EVEX_0F38;
						break;
					case 3:
						array = handlers_EVEX_0F3A;
						break;
					case 5:
						array = handlers_EVEX_MAP5;
						break;
					case 6:
						array = handlers_EVEX_MAP6;
						break;
					default:
						SetInvalidInstruction();
						return;
					}
					Iced.Intel.DecoderInternal.OpCodeHandler obj = array[num3];
					state.modrm = num4;
					state.mod = num4 >> 6;
					state.reg = (num4 >> 3) & 7;
					state.rm = num4 & 7;
					if ((((uint)(state.zs.flags & StateFlags.b) | state.vectorLength) & invalidCheckMask) == 3)
					{
						SetInvalidInstruction();
					}
					obj.Decode(this, ref instruction);
				}
				else
				{
					SetInvalidInstruction();
				}
			}
			else
			{
				SetInvalidInstruction();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Register ReadOpSegReg()
		{
			uint reg = state.reg;
			if (reg < 6)
			{
				return (Register)(71 + reg);
			}
			SetInvalidInstruction();
			return Register.None;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool ReadOpMem(ref Instruction instruction)
		{
			if (state.addressSize == OpSize.Size64)
			{
				return ReadOpMem32Or64(ref instruction, Register.RAX, Register.RAX, TupleType.N1, isVsib: false);
			}
			if (state.addressSize == OpSize.Size32)
			{
				return ReadOpMem32Or64(ref instruction, Register.EAX, Register.EAX, TupleType.N1, isVsib: false);
			}
			ReadOpMem16(ref instruction, TupleType.N1);
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ReadOpMemSib(ref Instruction instruction)
		{
			bool flag;
			if (state.addressSize == OpSize.Size64)
			{
				flag = ReadOpMem32Or64(ref instruction, Register.RAX, Register.RAX, TupleType.N1, isVsib: false);
			}
			else if (state.addressSize == OpSize.Size32)
			{
				flag = ReadOpMem32Or64(ref instruction, Register.EAX, Register.EAX, TupleType.N1, isVsib: false);
			}
			else
			{
				ReadOpMem16(ref instruction, TupleType.N1);
				flag = false;
			}
			if (invalidCheckMask != 0 && !flag)
			{
				SetInvalidInstruction();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ReadOpMem_MPX(ref Instruction instruction)
		{
			if (is64bMode)
			{
				state.addressSize = OpSize.Size64;
				ReadOpMem32Or64(ref instruction, Register.RAX, Register.RAX, TupleType.N1, isVsib: false);
				return;
			}
			if (state.addressSize == OpSize.Size32)
			{
				ReadOpMem32Or64(ref instruction, Register.EAX, Register.EAX, TupleType.N1, isVsib: false);
				return;
			}
			ReadOpMem16(ref instruction, TupleType.N1);
			if (invalidCheckMask != 0)
			{
				SetInvalidInstruction();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ReadOpMem(ref Instruction instruction, TupleType tupleType)
		{
			if (state.addressSize == OpSize.Size64)
			{
				ReadOpMem32Or64(ref instruction, Register.RAX, Register.RAX, tupleType, isVsib: false);
			}
			else if (state.addressSize == OpSize.Size32)
			{
				ReadOpMem32Or64(ref instruction, Register.EAX, Register.EAX, tupleType, isVsib: false);
			}
			else
			{
				ReadOpMem16(ref instruction, tupleType);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void ReadOpMem_VSIB(ref Instruction instruction, Register vsibIndex, TupleType tupleType)
		{
			bool flag;
			if (state.addressSize == OpSize.Size64)
			{
				flag = ReadOpMem32Or64(ref instruction, Register.RAX, vsibIndex, tupleType, isVsib: true);
			}
			else if (state.addressSize == OpSize.Size32)
			{
				flag = ReadOpMem32Or64(ref instruction, Register.EAX, vsibIndex, tupleType, isVsib: true);
			}
			else
			{
				ReadOpMem16(ref instruction, tupleType);
				flag = false;
			}
			if (invalidCheckMask != 0 && !flag)
			{
				SetInvalidInstruction();
			}
		}

		private void ReadOpMem16(ref Instruction instruction, TupleType tupleType)
		{
			RegInfo2 regInfo = memRegs16[state.rm];
			var (internalMemoryBase, internalMemoryIndex) = (RegInfo2)(ref regInfo);
			switch ((int)state.mod)
			{
			case 0:
				if (state.rm == 6)
				{
					instruction.InternalSetMemoryDisplSize(2u);
					displIndex = state.zs.instructionLength;
					instruction.MemoryDisplacement64 = ReadUInt16();
					internalMemoryBase = Register.None;
				}
				break;
			case 1:
				instruction.InternalSetMemoryDisplSize(1u);
				displIndex = state.zs.instructionLength;
				if (tupleType == TupleType.N1)
				{
					instruction.MemoryDisplacement64 = (ushort)(sbyte)ReadByte();
				}
				else
				{
					instruction.MemoryDisplacement64 = (ushort)(GetDisp8N(tupleType) * (uint)(sbyte)ReadByte());
				}
				break;
			default:
				instruction.InternalSetMemoryDisplSize(2u);
				displIndex = state.zs.instructionLength;
				instruction.MemoryDisplacement64 = ReadUInt16();
				break;
			}
			instruction.InternalMemoryBase = internalMemoryBase;
			instruction.InternalMemoryIndex = internalMemoryIndex;
		}

		private bool ReadOpMem32Or64(ref Instruction instruction, Register baseReg, Register indexReg, TupleType tupleType, bool isVsib)
		{
			uint num;
			uint scale;
			uint num2;
			switch ((int)state.mod)
			{
			case 0:
				if (state.rm == 4)
				{
					num = ReadByte();
					scale = 0u;
					num2 = 0u;
					break;
				}
				if (state.rm == 5)
				{
					displIndex = state.zs.instructionLength;
					if (state.addressSize == OpSize.Size64)
					{
						instruction.MemoryDisplacement64 = (ulong)(int)ReadUInt32();
						instruction.InternalSetMemoryDisplSize(4u);
					}
					else
					{
						instruction.MemoryDisplacement64 = ReadUInt32();
						instruction.InternalSetMemoryDisplSize(3u);
					}
					if (is64bMode)
					{
						if (state.addressSize == OpSize.Size64)
						{
							state.zs.flags |= StateFlags.IpRel64;
							instruction.InternalMemoryBase = Register.RIP;
						}
						else
						{
							state.zs.flags |= StateFlags.IpRel32;
							instruction.InternalMemoryBase = Register.EIP;
						}
					}
					return false;
				}
				instruction.InternalMemoryBase = (Register)((int)(state.zs.extraBaseRegisterBase + state.rm) + (int)baseReg);
				return false;
			case 1:
				if (state.rm == 4)
				{
					num = ReadByte();
					scale = 1u;
					displIndex = state.zs.instructionLength;
					num2 = ((tupleType != TupleType.N1) ? (GetDisp8N(tupleType) * (uint)(sbyte)ReadByte()) : ((uint)(sbyte)ReadByte()));
					break;
				}
				instruction.InternalSetMemoryDisplSize(1u);
				displIndex = state.zs.instructionLength;
				if (state.addressSize == OpSize.Size64)
				{
					if (tupleType == TupleType.N1)
					{
						instruction.MemoryDisplacement64 = (ulong)(sbyte)ReadByte();
					}
					else
					{
						instruction.MemoryDisplacement64 = (ulong)(GetDisp8N(tupleType) * (sbyte)ReadByte());
					}
				}
				else if (tupleType == TupleType.N1)
				{
					instruction.MemoryDisplacement64 = (uint)(sbyte)ReadByte();
				}
				else
				{
					instruction.MemoryDisplacement64 = GetDisp8N(tupleType) * (uint)(sbyte)ReadByte();
				}
				instruction.InternalMemoryBase = (Register)((int)(state.zs.extraBaseRegisterBase + state.rm) + (int)baseReg);
				return false;
			default:
				if (state.rm == 4)
				{
					num = ReadByte();
					scale = ((state.addressSize == OpSize.Size64) ? 4u : 3u);
					displIndex = state.zs.instructionLength;
					num2 = ReadUInt32();
					break;
				}
				displIndex = state.zs.instructionLength;
				if (state.addressSize == OpSize.Size64)
				{
					instruction.MemoryDisplacement64 = (ulong)(int)ReadUInt32();
					instruction.InternalSetMemoryDisplSize(4u);
				}
				else
				{
					instruction.MemoryDisplacement64 = ReadUInt32();
					instruction.InternalSetMemoryDisplSize(3u);
				}
				instruction.InternalMemoryBase = (Register)((int)(state.zs.extraBaseRegisterBase + state.rm) + (int)baseReg);
				return false;
			}
			uint num3 = ((num >> 3) & 7) + state.zs.extraIndexRegisterBase;
			uint num4 = num & 7;
			instruction.InternalMemoryIndexScale = (int)(num >> 6);
			if (!isVsib)
			{
				if (num3 != 4)
				{
					instruction.InternalMemoryIndex = (Register)((int)num3 + (int)indexReg);
				}
			}
			else
			{
				instruction.InternalMemoryIndex = (Register)((int)(num3 + state.zs.extraIndexRegisterBaseVSIB) + (int)indexReg);
			}
			if (num4 == 5 && state.mod == 0)
			{
				displIndex = state.zs.instructionLength;
				if (state.addressSize == OpSize.Size64)
				{
					instruction.MemoryDisplacement64 = (ulong)(int)ReadUInt32();
					instruction.InternalSetMemoryDisplSize(4u);
				}
				else
				{
					instruction.MemoryDisplacement64 = ReadUInt32();
					instruction.InternalSetMemoryDisplSize(3u);
				}
			}
			else
			{
				instruction.InternalMemoryBase = (Register)((int)(num4 + state.zs.extraBaseRegisterBase) + (int)baseReg);
				instruction.InternalSetMemoryDisplSize(scale);
				if (state.addressSize == OpSize.Size64)
				{
					instruction.MemoryDisplacement64 = (ulong)(int)num2;
				}
				else
				{
					instruction.MemoryDisplacement64 = num2;
				}
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private uint GetDisp8N(TupleType tupleType)
		{
			return TupleTypeTable.GetDisp8N(tupleType, (state.zs.flags & StateFlags.b) != 0);
		}

		public ConstantOffsets GetConstantOffsets(in Instruction instruction)
		{
			ConstantOffsets result = default(ConstantOffsets);
			int memoryDisplSize = instruction.MemoryDisplSize;
			if (memoryDisplSize != 0)
			{
				result.DisplacementOffset = (byte)displIndex;
				if (memoryDisplSize == 8 && (state.zs.flags & StateFlags.Addr64) == 0)
				{
					result.DisplacementSize = 4;
				}
				else
				{
					result.DisplacementSize = (byte)memoryDisplSize;
				}
			}
			if ((state.zs.flags & StateFlags.NoImm) == 0)
			{
				int num = 0;
				for (int num2 = instruction.OpCount - 1; num2 >= 0; num2--)
				{
					switch (instruction.GetOpKind(num2))
					{
					case OpKind.Immediate8:
					case OpKind.Immediate8to16:
					case OpKind.Immediate8to32:
					case OpKind.Immediate8to64:
						result.ImmediateOffset = (byte)(instruction.Length - num - 1);
						result.ImmediateSize = 1;
						break;
					case OpKind.Immediate16:
						result.ImmediateOffset = (byte)(instruction.Length - num - 2);
						result.ImmediateSize = 2;
						break;
					case OpKind.Immediate32:
					case OpKind.Immediate32to64:
						result.ImmediateOffset = (byte)(instruction.Length - num - 4);
						result.ImmediateSize = 4;
						break;
					case OpKind.Immediate64:
						result.ImmediateOffset = (byte)(instruction.Length - num - 8);
						result.ImmediateSize = 8;
						break;
					case OpKind.Immediate8_2nd:
						result.ImmediateOffset2 = (byte)(instruction.Length - 1);
						result.ImmediateSize2 = 1;
						num = 1;
						continue;
					case OpKind.NearBranch16:
						if ((state.zs.flags & StateFlags.BranchImm8) != 0)
						{
							result.ImmediateOffset = (byte)(instruction.Length - 1);
							result.ImmediateSize = 1;
						}
						else if ((state.zs.flags & StateFlags.Xbegin) == 0)
						{
							result.ImmediateOffset = (byte)(instruction.Length - 2);
							result.ImmediateSize = 2;
						}
						else if (state.operandSize != OpSize.Size16)
						{
							result.ImmediateOffset = (byte)(instruction.Length - 4);
							result.ImmediateSize = 4;
						}
						else
						{
							result.ImmediateOffset = (byte)(instruction.Length - 2);
							result.ImmediateSize = 2;
						}
						continue;
					case OpKind.NearBranch32:
					case OpKind.NearBranch64:
						if ((state.zs.flags & StateFlags.BranchImm8) != 0)
						{
							result.ImmediateOffset = (byte)(instruction.Length - 1);
							result.ImmediateSize = 1;
						}
						else if ((state.zs.flags & StateFlags.Xbegin) == 0)
						{
							result.ImmediateOffset = (byte)(instruction.Length - 4);
							result.ImmediateSize = 4;
						}
						else if (state.operandSize != OpSize.Size16)
						{
							result.ImmediateOffset = (byte)(instruction.Length - 4);
							result.ImmediateSize = 4;
						}
						else
						{
							result.ImmediateOffset = (byte)(instruction.Length - 2);
							result.ImmediateSize = 2;
						}
						continue;
					case OpKind.FarBranch16:
						result.ImmediateOffset = (byte)(instruction.Length - 4);
						result.ImmediateSize = 2;
						result.ImmediateOffset2 = (byte)(instruction.Length - 2);
						result.ImmediateSize2 = 2;
						continue;
					case OpKind.FarBranch32:
						result.ImmediateOffset = (byte)(instruction.Length - 6);
						result.ImmediateSize = 4;
						result.ImmediateOffset2 = (byte)(instruction.Length - 2);
						result.ImmediateSize2 = 2;
						continue;
					default:
						continue;
					}
					break;
				}
			}
			return result;
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

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

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public enum DecoderError
	{
		None,
		InvalidInstruction,
		NoMoreBytes
	}
	[Flags]
	public enum DecoderOptions : uint
	{
		None = 0u,
		NoInvalidCheck = 1u,
		AMD = 2u,
		ForceReservedNop = 4u,
		Umov = 8u,
		Xbts = 0x10u,
		Cmpxchg486A = 0x20u,
		OldFpu = 0x40u,
		Pcommit = 0x80u,
		Loadall286 = 0x100u,
		Loadall386 = 0x200u,
		Cl1invmb = 0x400u,
		MovTr = 0x800u,
		Jmpe = 0x1000u,
		NoPause = 0x2000u,
		NoWbnoinvd = 0x4000u,
		Udbg = 0x8000u,
		NoMPFX_0FBC = 0x10000u,
		NoMPFX_0FBD = 0x20000u,
		NoLahfSahf64 = 0x40000u,
		MPX = 0x80000u,
		Cyrix = 0x100000u,
		Cyrix_SMINT_0F7E = 0x200000u,
		Cyrix_DMI = 0x400000u,
		ALTINST = 0x800000u,
		KNC = 0x1000000u
	}
	public sealed class Encoder
	{
		private static readonly uint[] s_immSizes = new uint[19]
		{
			0u, 1u, 2u, 4u, 8u, 3u, 2u, 4u, 6u, 1u,
			1u, 1u, 2u, 2u, 2u, 4u, 4u, 1u, 1u
		};

		internal uint Internal_PreventVEX2;

		internal uint Internal_VEX_WIG_LIG;

		internal uint Internal_VEX_LIG;

		internal uint Internal_EVEX_WIG;

		internal uint Internal_EVEX_LIG;

		internal const string ERROR_ONLY_1632_BIT_MODE = "The instruction can only be used in 16/32-bit mode";

		internal const string ERROR_ONLY_64_BIT_MODE = "The instruction can only be used in 64-bit mode";

		private readonly CodeWriter writer;

		private readonly int bitness;

		private readonly Iced.Intel.EncoderInternal.OpCodeHandler[] handlers;

		private readonly uint[] immSizes;

		private ulong currentRip;

		private string errorMessage;

		private Iced.Intel.EncoderInternal.OpCodeHandler handler;

		private uint eip;

		private uint displAddr;

		private uint immAddr;

		internal uint Immediate;

		internal uint ImmediateHi;

		private uint Displ;

		private uint DisplHi;

		private readonly EncoderFlags opSize16Flags;

		private readonly EncoderFlags opSize32Flags;

		private readonly EncoderFlags adrSize16Flags;

		private readonly EncoderFlags adrSize32Flags;

		internal uint OpCode;

		internal EncoderFlags EncoderFlags;

		private DisplSize DisplSize;

		internal ImmSize ImmSize;

		private byte ModRM;

		private byte Sib;

		public bool PreventVEX2
		{
			get
			{
				return Internal_PreventVEX2 != 0;
			}
			set
			{
				Internal_PreventVEX2 = (value ? uint.MaxValue : 0u);
			}
		}

		public uint VEX_WIG
		{
			get
			{
				return (Internal_VEX_WIG_LIG >> 7) & 1;
			}
			set
			{
				Internal_VEX_WIG_LIG = (Internal_VEX_WIG_LIG & 0xFFFFFF7Fu) | ((value & 1) << 7);
			}
		}

		public uint VEX_LIG
		{
			get
			{
				return (Internal_VEX_WIG_LIG >> 2) & 1;
			}
			set
			{
				Internal_VEX_WIG_LIG = (Internal_VEX_WIG_LIG & 0xFFFFFFFBu) | ((value & 1) << 2);
				Internal_VEX_LIG = (value & 1) << 2;
			}
		}

		public uint EVEX_WIG
		{
			get
			{
				return Internal_EVEX_WIG >> 7;
			}
			set
			{
				Internal_EVEX_WIG = (value & 1) << 7;
			}
		}

		public uint EVEX_LIG
		{
			get
			{
				return Internal_EVEX_LIG >> 5;
			}
			set
			{
				Internal_EVEX_LIG = (value & 3) << 5;
			}
		}

		public int Bitness => bitness;

		internal string? ErrorMessage
		{
			set
			{
				if (errorMessage == null)
				{
					errorMessage = value;
				}
			}
		}

		private static ReadOnlySpan<byte> SegmentOverrides => "&.6>de"u8;

		private Encoder(CodeWriter writer, int bitness)
		{
			if (writer == null)
			{
				ThrowHelper.ThrowArgumentNullException_writer();
			}
			immSizes = s_immSizes;
			this.writer = writer;
			this.bitness = bitness;
			handlers = OpCodeHandlers.Handlers;
			handler = null;
			opSize16Flags = ((bitness != 16) ? EncoderFlags.P66 : EncoderFlags.None);
			opSize32Flags = ((bitness == 16) ? EncoderFlags.P66 : EncoderFlags.None);
			adrSize16Flags = ((bitness != 16) ? EncoderFlags.P67 : EncoderFlags.None);
			adrSize32Flags = ((bitness != 32) ? EncoderFlags.P67 : EncoderFlags.None);
		}

		public static Encoder Create(int bitness, CodeWriter writer)
		{
			if (bitness == 16 || bitness == 32 || bitness == 64)
			{
				return new Encoder(writer, bitness);
			}
			throw new ArgumentOutOfRangeException("bitness");
		}

		public uint Encode(in Instruction instruction, ulong rip)
		{
			if (!TryEncode(in instruction, rip, out uint encodedLength, out string text))
			{
				ThrowEncoderException(in instruction, text);
			}
			return encodedLength;
		}

		private static void ThrowEncoderException(in Instruction instruction, string errorMessage)
		{
			throw new EncoderException(errorMessage, in instruction);
		}

		public bool TryEncode(in Instruction instruction, ulong rip, out uint encodedLength, [NotNullWhen(false)] out string? errorMessage)
		{
			currentRip = rip;
			eip = (uint)rip;
			this.errorMessage = null;
			EncoderFlags = EncoderFlags.None;
			DisplSize = DisplSize.None;
			ImmSize = ImmSize.None;
			ModRM = 0;
			Iced.Intel.EncoderInternal.OpCodeHandler opCodeHandler = (handler = handlers[(int)instruction.Code]);
			OpCode = opCodeHandler.OpCode;
			if (opCodeHandler.GroupIndex >= 0)
			{
				EncoderFlags = EncoderFlags.ModRM;
				ModRM = (byte)(opCodeHandler.GroupIndex << 3);
			}
			if (opCodeHandler.RmGroupIndex >= 0)
			{
				EncoderFlags = EncoderFlags.ModRM;
				ModRM |= (byte)(opCodeHandler.RmGroupIndex | 0xC0);
			}
			switch (opCodeHandler.EncFlags3 & (EncFlags3.Bit16or32 | EncFlags3.Bit64))
			{
			case EncFlags3.Bit16or32:
				if (bitness == 64)
				{
					ErrorMessage = "The instruction can only be used in 16/32-bit mode";
				}
				break;
			case EncFlags3.Bit64:
				if (bitness != 64)
				{
					ErrorMessage = "The instruction can only be used in 64-bit mode";
				}
				break;
			default:
				throw new InvalidOperationException();
			case EncFlags3.Bit16or32 | EncFlags3.Bit64:
				break;
			}
			switch (opCodeHandler.OpSize)
			{
			case CodeSize.Code16:
				EncoderFlags |= opSize16Flags;
				break;
			case CodeSize.Code32:
				EncoderFlags |= opSize32Flags;
				break;
			case CodeSize.Code64:
				if ((opCodeHandler.EncFlags3 & EncFlags3.DefaultOpSize64) == 0)
				{
					EncoderFlags |= EncoderFlags.W;
				}
				break;
			default:
				throw new InvalidOperationException();
			case CodeSize.Unknown:
				break;
			}
			switch (opCodeHandler.AddrSize)
			{
			case CodeSize.Code16:
				EncoderFlags |= adrSize16Flags;
				break;
			case CodeSize.Code32:
				EncoderFlags |= adrSize32Flags;
				break;
			default:
				throw new InvalidOperationException();
			case CodeSize.Unknown:
			case CodeSize.Code64:
				break;
			}
			if (!opCodeHandler.IsSpecialInstr)
			{
				Op[] operands = opCodeHandler.Operands;
				for (int i = 0; i < operands.Length; i++)
				{
					operands[i].Encode(this, in instruction, i);
				}
				if ((opCodeHandler.EncFlags3 & EncFlags3.Fwait) != EncFlags3.None)
				{
					WriteByteInternal(155u);
				}
				opCodeHandler.Encode(this, in instruction);
				uint opCode = OpCode;
				if (!opCodeHandler.Is2ByteOpCode)
				{
					WriteByteInternal(opCode);
				}
				else
				{
					WriteByteInternal(opCode >> 8);
					WriteByteInternal(opCode);
				}
				if ((EncoderFlags & (EncoderFlags.ModRM | EncoderFlags.Displ)) != EncoderFlags.None)
				{
					WriteModRM();
				}
				if (ImmSize != ImmSize.None)
				{
					WriteImmediate();
				}
			}
			else
			{
				opCodeHandler.Encode(this, in instruction);
			}
			uint num = (uint)((int)currentRip - (int)rip);
			if (num > 15 && !opCodeHandler.IsSpecialInstr)
			{
				ErrorMessage = $"Instruction length > {15} bytes";
			}
			errorMessage = this.errorMessage;
			if (errorMessage != null)
			{
				encodedLength = 0u;
				return false;
			}
			encodedLength = num;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool Verify(int operand, OpKind expected, OpKind actual)
		{
			if (expected == actual)
			{
				return true;
			}
			ErrorMessage = $"Operand {operand}: Expected: {expected}, actual: {actual}";
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool Verify(int operand, Register expected, Register actual)
		{
			if (expected == actual)
			{
				return true;
			}
			ErrorMessage = $"Operand {operand}: Expected: {expected}, actual: {actual}";
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool Verify(int operand, Register register, Register regLo, Register regHi)
		{
			if (bitness != 64 && regHi > regLo + 7)
			{
				regHi = regLo + 7;
			}
			if (regLo <= register && register <= regHi)
			{
				return true;
			}
			ErrorMessage = $"Operand {operand}: Register {register} is not between {regLo} and {regHi} (inclusive)";
			return false;
		}

		internal void AddBranch(OpKind opKind, int immSize, in Instruction instruction, int operand)
		{
			if (!Verify(operand, opKind, instruction.GetOpKind(operand)))
			{
				return;
			}
			switch (immSize)
			{
			case 1:
				switch (opKind)
				{
				case OpKind.NearBranch16:
					EncoderFlags |= opSize16Flags;
					ImmSize = ImmSize.RipRelSize1_Target16;
					Immediate = instruction.NearBranch16;
					break;
				case OpKind.NearBranch32:
					EncoderFlags |= opSize32Flags;
					ImmSize = ImmSize.RipRelSize1_Target32;
					Immediate = instruction.NearBranch32;
					break;
				case OpKind.NearBranch64:
				{
					ImmSize = ImmSize.RipRelSize1_Target64;
					ulong nearBranch = instruction.NearBranch64;
					Immediate = (uint)nearBranch;
					ImmediateHi = (uint)(nearBranch >> 32);
					break;
				}
				default:
					throw new InvalidOperationException();
				}
				break;
			case 2:
				if (opKind == OpKind.NearBranch16)
				{
					EncoderFlags |= opSize16Flags;
					ImmSize = ImmSize.RipRelSize2_Target16;
					Immediate = instruction.NearBranch16;
					break;
				}
				throw new InvalidOperationException();
			case 4:
				switch (opKind)
				{
				case OpKind.NearBranch32:
					EncoderFlags |= opSize32Flags;
					ImmSize = ImmSize.RipRelSize4_Target32;
					Immediate = instruction.NearBranch32;
					break;
				case OpKind.NearBranch64:
				{
					ImmSize = ImmSize.RipRelSize4_Target64;
					ulong nearBranch = instruction.NearBranch64;
					Immediate = (uint)nearBranch;
					ImmediateHi = (uint)(nearBranch >> 32);
					break;
				}
				default:
					throw new InvalidOperationException();
				}
				break;
			default:
				throw new InvalidOperationException();
			}
		}

		internal void AddBranchX(int immSize, in Instruction instruction, int operand)
		{
			if (bitness == 64)
			{
				if (Verify(operand, OpKind.NearBranch64, instruction.GetOpKind(operand)))
				{
					ulong nearBranch = instruction.NearBranch64;
					switch (immSize)
					{
					case 2:
						EncoderFlags |= EncoderFlags.P66;
						ImmSize = ImmSize.RipRelSize2_Target64;
						Immediate = (uint)nearBranch;
						ImmediateHi = (uint)(nearBranch >> 32);
						break;
					case 4:
						ImmSize = ImmSize.RipRelSize4_Target64;
						Immediate = (uint)nearBranch;
						ImmediateHi = (uint)(nearBranch >> 32);
						break;
					default:
						throw new InvalidOperationException();
					}
				}
			}
			else if (Verify(operand, OpKind.NearBranch32, instruction.GetOpKind(operand)))
			{
				switch (immSize)
				{
				case 2:
					EncoderFlags |= (EncoderFlags)((bitness & 0x20) << 2);
					ImmSize = ImmSize.RipRelSize2_Target32;
					Immediate = instruction.NearBranch32;
					break;
				case 4:
					EncoderFlags |= (EncoderFlags)((bitness & 0x10) << 3);
					ImmSize = ImmSize.RipRelSize4_Target32;
					Immediate = instruction.NearBranch32;
					break;
				default:
					throw new InvalidOperationException();
				}
			}
		}

		internal void AddBranchDisp(int displSize, in Instruction instruction, int operand)
		{
			OpKind expected;
			switch (displSize)
			{
			case 2:
				expected = OpKind.NearBranch16;
				ImmSize = ImmSize.Size2;
				Immediate = instruction.NearBranch16;
				break;
			case 4:
				expected = OpKind.NearBranch32;
				ImmSize = ImmSize.Size4;
				Immediate = instruction.NearBranch32;
				break;
			default:
				throw new InvalidOperationException();
			}
			Verify(operand, expected, instruction.GetOpKind(operand));
		}

		internal void AddFarBranch(in Instruction instruction, int operand, int size)
		{
			if (size == 2)
			{
				if (!Verify(operand, OpKind.FarBranch16, instruction.GetOpKind(operand)))
				{
					return;
				}
				ImmSize = ImmSize.Size2_2;
				Immediate = instruction.FarBranch16;
				ImmediateHi = instruction.FarBranchSelector;
			}
			else
			{
				if (!Verify(operand, OpKind.FarBranch32, instruction.GetOpKind(operand)))
				{
					return;
				}
				ImmSize = ImmSize.Size4_2;
				Immediate = instruction.FarBranch32;
				ImmediateHi = instruction.FarBranchSelector;
			}
			if (bitness != size * 8)
			{
				EncoderFlags |= EncoderFlags.P66;
			}
		}

		internal void SetAddrSize(int regSize)
		{
			if (bitness == 64)
			{
				switch (regSize)
				{
				case 2:
					ErrorMessage = $"Invalid register size: {regSize * 8}, must be 32-bit or 64-bit";
					break;
				case 4:
					EncoderFlags |= EncoderFlags.P67;
					break;
				}
			}
			else if (regSize == 8)
			{
				ErrorMessage = $"Invalid register size: {regSize * 8}, must be 16-bit or 32-bit";
			}
			else if (bitness == 16)
			{
				if (regSize == 4)
				{
					EncoderFlags |= EncoderFlags.P67;
				}
			}
			else if (regSize == 2)
			{
				EncoderFlags |= EncoderFlags.P67;
			}
		}

		internal void AddAbsMem(in Instruction instruction, int operand)
		{
			EncoderFlags |= EncoderFlags.Displ;
			OpKind opKind = instruction.GetOpKind(operand);
			if (opKind == OpKind.Memory)
			{
				if (instruction.MemoryBase != Register.None || instruction.MemoryIndex != Register.None)
				{
					ErrorMessage = $"Operand {operand}: Absolute addresses can't have base and/or index regs";
					return;
				}
				if (instruction.MemoryIndexScale != 1)
				{
					ErrorMessage = $"Operand {operand}: Absolute addresses must have scale == *1";
					return;
				}
				switch (instruction.MemoryDisplSize)
				{
				case 2:
					if (bitness == 64)
					{
						ErrorMessage = $"Operand {operand}: 16-bit abs addresses can't be used in 64-bit mode";
						break;
					}
					if (bitness == 32)
					{
						EncoderFlags |= EncoderFlags.P67;
					}
					DisplSize = DisplSize.Size2;
					if (instruction.MemoryDisplacement64 > 65535)
					{
						ErrorMessage = $"Operand {operand}: Displacement must fit in a ushort";
					}
					else
					{
						Displ = instruction.MemoryDisplacement32;
					}
					break;
				case 4:
					EncoderFlags |= adrSize32Flags;
					DisplSize = DisplSize.Size4;
					if (instruction.MemoryDisplacement64 > uint.MaxValue)
					{
						ErrorMessage = $"Operand {operand}: Displacement must fit in a uint";
					}
					else
					{
						Displ = instruction.MemoryDisplacement32;
					}
					break;
				case 8:
					if (bitness != 64)
					{
						ErrorMessage = $"Operand {operand}: 64-bit abs address is only available in 64-bit mode";
					}
					else
					{
						DisplSize = DisplSize.Size8;
						ulong memoryDisplacement = instruction.MemoryDisplacement64;
						Displ = (uint)memoryDisplacement;
						DisplHi = (uint)(memoryDisplacement >> 32);
					}
					break;
				default:
					ErrorMessage = $"Operand {operand}: {"Instruction"}.{"MemoryDisplSize"} must be initialized to 2 (16-bit), 4 (32-bit) or 8 (64-bit)";
					break;
				}
			}
			else
			{
				ErrorMessage = $"Operand {operand}: Expected OpKind {"Memory"}, actual: {opKind}";
			}
		}

		internal void AddModRMRegister(in Instruction instruction, int operand, Register regLo, Register regHi)
		{
			if (!Verify(operand, OpKind.Register, instruction.GetOpKind(operand)))
			{
				return;
			}
			Register opRegister = instruction.GetOpRegister(operand);
			if (!Verify(operand, opRegister, regLo, regHi))
			{
				return;
			}
			uint num = (uint)(opRegister - regLo);
			if (regLo == Register.AL)
			{
				if (opRegister >= Register.SPL)
				{
					num -= 4;
					EncoderFlags |= EncoderFlags.REX;
				}
				else if (opRegister >= Register.AH)
				{
					EncoderFlags |= EncoderFlags.HighLegacy8BitRegs;
				}
			}
			ModRM |= (byte)((num & 7) << 3);
			EncoderFlags |= EncoderFlags.ModRM;
			EncoderFlags |= (EncoderFlags)((num & 8) >> 1);
			EncoderFlags |= (EncoderFlags)((num & 0x10) << 5);
		}

		internal void AddReg(in Instruction instruction, int operand, Register regLo, Register regHi)
		{
			if (!Verify(operand, OpKind.Register, instruction.GetOpKind(operand)))
			{
				return;
			}
			Register opRegister = instruction.GetOpRegister(operand);
			if (!Verify(operand, opRegister, regLo, regHi))
			{
				return;
			}
			uint num = (uint)(opRegister - regLo);
			if (regLo == Register.AL)
			{
				if (opRegister >= Register.SPL)
				{
					num -= 4;
					EncoderFlags |= EncoderFlags.REX;
				}
				else if (opRegister >= Register.AH)
				{
					EncoderFlags |= EncoderFlags.HighLegacy8BitRegs;
				}
			}
			OpCode |= num & 7;
			EncoderFlags |= (EncoderFlags)(num >> 3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void AddRegOrMem(in Instruction instruction, int operand, Register regLo, Register regHi, bool allowMemOp, bool allowRegOp)
		{
			AddRegOrMem(in instruction, operand, regLo, regHi, Register.None, Register.None, allowMemOp, allowRegOp);
		}

		internal void AddRegOrMem(in Instruction instruction, int operand, Register regLo, Register regHi, Register vsibIndexRegLo, Register vsibIndexRegHi, bool allowMemOp, bool allowRegOp)
		{
			OpKind opKind = instruction.GetOpKind(operand);
			EncoderFlags |= EncoderFlags.ModRM;
			switch (opKind)
			{
			case OpKind.Register:
			{
				if (!allowRegOp)
				{
					ErrorMessage = $"Operand {operand}: register operand is not allowed";
					break;
				}
				Register opRegister = instruction.GetOpRegister(operand);
				if (!Verify(operand, opRegister, regLo, regHi))
				{
					break;
				}
				uint num2 = (uint)(opRegister - regLo);
				if (regLo == Register.AL)
				{
					if (opRegister >= Register.R8L)
					{
						num2 -= 4;
					}
					else if (opRegister >= Register.SPL)
					{
						num2 -= 4;
						EncoderFlags |= EncoderFlags.REX;
					}
					else if (opRegister >= Register.AH)
					{
						EncoderFlags |= EncoderFlags.HighLegacy8BitRegs;
					}
				}
				ModRM |= (byte)(num2 & 7);
				ModRM |= 192;
				EncoderFlags |= (EncoderFlags)((num2 >> 3) & 3);
				break;
			}
			case OpKind.Memory:
			{
				if (!allowMemOp)
				{
					ErrorMessage = $"Operand {operand}: memory operand is not allowed";
					break;
				}
				if (instruction.MemorySize.IsBroadcast())
				{
					EncoderFlags |= EncoderFlags.Broadcast;
				}
				CodeSize codeSize = instruction.CodeSize;
				if (codeSize == CodeSize.Unknown)
				{
					codeSize = ((bitness == 64) ? CodeSize.Code64 : ((bitness != 32) ? CodeSize.Code16 : CodeSize.Code32));
				}
				int num = InstructionUtils.GetAddressSizeInBytes(instruction.MemoryBase, instruction.MemoryIndex, instruction.MemoryDisplSize, codeSize) * 8;
				if (num != bitness)
				{
					EncoderFlags |= EncoderFlags.P67;
				}
				if ((EncoderFlags & EncoderFlags.RegIsMemory) != EncoderFlags.None && GetRegisterOpSize(in instruction) != num)
				{
					ErrorMessage = $"Operand {operand}: Register operand size must equal memory addressing mode (16/32/64)";
				}
				else if (num == 16)
				{
					if (vsibIndexRegLo != Register.None)
					{
						ErrorMessage = $"Operand {operand}: VSIB operands can't use 16-bit addressing. It must be 32-bit or 64-bit addressing";
					}
					else
					{
						AddMemOp16(in instruction, operand);
					}
				}
				else
				{
					AddMemOp(in instruction, operand, num, vsibIndexRegLo, vsibIndexRegHi);
				}
				break;
			}
			default:
				ErrorMessage = $"Operand {operand}: Expected a register or memory operand, but opKind is {opKind}";
				break;
			}
		}

		private static int GetRegisterOpSize(in Instruction instruction)
		{
			if (instruction.Op0Kind == OpKind.Register)
			{
				Register op0Register = instruction.Op0Register;
				if (op0Register.IsGPR64())
				{
					return 64;
				}
				if (op0Register.IsGPR32())
				{
					return 32;
				}
				if (op0Register.IsGPR16())
				{
					return 16;
				}
			}
			return 0;
		}

		private bool TryConvertToDisp8N(in Instruction instruction, int displ, out sbyte compressedValue)
		{
			TryConvertToDisp8N tryConvertToDisp8N = handler.TryConvertToDisp8N;
			if (tryConvertToDisp8N != null)
			{
				return tryConvertToDisp8N(this, handler, in instruction, displ, out compressedValue);
			}
			if (-128 <= displ && displ <= 127)
			{
				compressedValue = (sbyte)displ;
				return true;
			}
			compressedValue = 0;
			return false;
		}

		private void AddMemOp16(in Instruction instruction, int operand)
		{
			if (bitness == 64)
			{
				ErrorMessage = $"Operand {operand}: 16-bit addressing can't be used by 64-bit code";
				return;
			}
			Register memoryBase = instruction.MemoryBase;
			Register memoryIndex = instruction.MemoryIndex;
			int num = instruction.MemoryDisplSize;
			if (memoryBase != Register.BX || memoryIndex != Register.SI)
			{
				if (memoryBase == Register.BX && memoryIndex == Register.DI)
				{
					ModRM |= 1;
				}
				else if (memoryBase == Register.BP && memoryIndex == Register.SI)
				{
					ModRM |= 2;
				}
				else if (memoryBase == Register.BP && memoryIndex == Register.DI)
				{
					ModRM |= 3;
				}
				else if (memoryBase == Register.SI && memoryIndex == Register.None)
				{
					ModRM |= 4;
				}
				else if (memoryBase == Register.DI && memoryIndex == Register.None)
				{
					ModRM |= 5;
				}
				else if (memoryBase == Register.BP && memoryIndex == Register.None)
				{
					ModRM |= 6;
				}
				else if (memoryBase == Register.BX && memoryIndex == Register.None)
				{
					ModRM |= 7;
				}
				else
				{
					if (memoryBase != Register.None || memoryIndex != Register.None)
					{
						ErrorMessage = $"Operand {operand}: Invalid 16-bit base + index registers: base={memoryBase}, index={memoryIndex}";
						return;
					}
					ModRM |= 6;
					DisplSize = DisplSize.Size2;
					if (instruction.MemoryDisplacement64 > 65535)
					{
						ErrorMessage = $"Operand {operand}: Displacement must fit in a ushort";
						return;
					}
					Displ = instruction.MemoryDisplacement32;
				}
			}
			if (memoryBase == Register.None && memoryIndex == Register.None)
			{
				return;
			}
			if ((long)instruction.MemoryDisplacement64 < -32768L || (long)instruction.MemoryDisplacement64 > 65535L)
			{
				ErrorMessage = $"Operand {operand}: Displacement must fit in a short or a ushort";
				return;
			}
			Displ = instruction.MemoryDisplacement32;
			if (num == 0 && memoryBase == Register.BP && memoryIndex == Register.None)
			{
				num = 1;
				if (Displ != 0)
				{
					ErrorMessage = $"Operand {operand}: Displacement must be 0 if displSize == 0";
					return;
				}
			}
			if (num == 1)
			{
				if (TryConvertToDisp8N(in instruction, (short)Displ, out var compressedValue))
				{
					Displ = (uint)compressedValue;
				}
				else
				{
					num = 2;
				}
			}
			switch (num)
			{
			case 0:
				if (Displ != 0)
				{
					ErrorMessage = $"Operand {operand}: Displacement must be 0 if displSize == 0";
				}
				break;
			case 1:
				if ((int)Displ < -128 || (int)Displ > 127)
				{
					ErrorMessage = $"Operand {operand}: Displacement must fit in an sbyte";
				}
				else
				{
					ModRM |= 64;
					DisplSize = DisplSize.Size1;
				}
				break;
			case 2:
				ModRM |= 128;
				DisplSize = DisplSize.Size2;
				break;
			default:
				ErrorMessage = $"Operand {operand}: Invalid displacement size: {num}, must be 0, 1, or 2";
				break;
			}
		}

		private void AddMemOp(in Instruction instruction, int operand, int addrSize, Register vsibIndexRegLo, Register vsibIndexRegHi)
		{
			if (bitness != 64 && addrSize == 64)
			{
				ErrorMessage = $"Operand {operand}: 64-bit addressing can only be used in 64-bit mode";
				return;
			}
			Register memoryBase = instruction.MemoryBase;
			Register memoryIndex = instruction.MemoryIndex;
			int num = instruction.MemoryDisplSize;
			Register register;
			Register register2;
			if (addrSize == 64)
			{
				register = Register.RAX;
				register2 = Register.R15;
			}
			else
			{
				register = Register.EAX;
				register2 = Register.R15D;
			}
			Register register3;
			Register regHi;
			if (vsibIndexRegLo != Register.None)
			{
				register3 = vsibIndexRegLo;
				regHi = vsibIndexRegHi;
			}
			else
			{
				register3 = register;
				regHi = register2;
			}
			if ((memoryBase != Register.None && memoryBase != Register.RIP && memoryBase != Register.EIP && !Verify(operand, memoryBase, register, register2)) || (memoryIndex != Register.None && !Verify(operand, memoryIndex, register3, regHi)))
			{
				return;
			}
			if (num != 0 && num != 1 && num != 4 && num != 8)
			{
				ErrorMessage = $"Operand {operand}: Invalid displ size: {num}, must be 0, 1, 4, 8";
				return;
			}
			if (memoryBase == Register.RIP || memoryBase == Register.EIP)
			{
				if (memoryIndex != Register.None)
				{
					ErrorMessage = $"Operand {operand}: RIP relative addressing can't use an index register";
					return;
				}
				if (instruction.InternalMemoryIndexScale != 0)
				{
					ErrorMessage = $"Operand {operand}: RIP relative addressing must use scale *1";
					return;
				}
				if (bitness != 64)
				{
					ErrorMessage = $"Operand {operand}: RIP/EIP relative addressing is only available in 64-bit mode";
					return;
				}
				if ((EncoderFlags & EncoderFlags.MustUseSib) != EncoderFlags.None)
				{
					ErrorMessage = $"Operand {operand}: RIP/EIP relative addressing isn't supported";
					return;
				}
				ModRM |= 5;
				ulong memoryDisplacement = instruction.MemoryDisplacement64;
				if (memoryBase == Register.RIP)
				{
					DisplSize = DisplSize.RipRelSize4_Target64;
					Displ = (uint)memoryDisplacement;
					DisplHi = (uint)(memoryDisplacement >> 32);
					return;
				}
				DisplSize = DisplSize.RipRelSize4_Target32;
				if (memoryDisplacement > uint.MaxValue)
				{
					ErrorMessage = $"Operand {operand}: Target address doesn't fit in 32 bits: 0x{memoryDisplacement:X}";
				}
				else
				{
					Displ = (uint)memoryDisplacement;
				}
				return;
			}
			int internalMemoryIndexScale = instruction.InternalMemoryIndexScale;
			Displ = instruction.MemoryDisplacement32;
			if (addrSize == 64)
			{
				if ((long)instruction.MemoryDisplacement64 < -2147483648L || (long)instruction.MemoryDisplacement64 > 2147483647L)
				{
					ErrorMessage = $"Operand {operand}: Displacement must fit in an int";
					return;
				}
			}
			else if ((long)instruction.MemoryDisplacement64 < -2147483648L || (long)instruction.MemoryDisplacement64 > 4294967295L)
			{
				ErrorMessage = $"Operand {operand}: Displacement must fit in an int or a uint";
				return;
			}
			if (memoryBase == Register.None && memoryIndex == Register.None)
			{
				if (vsibIndexRegLo != Register.None)
				{
					ErrorMessage = $"Operand {operand}: VSIB addressing can't use an offset-only address";
				}
				else if (bitness == 64 || internalMemoryIndexScale != 0 || (EncoderFlags & EncoderFlags.MustUseSib) != EncoderFlags.None)
				{
					ModRM |= 4;
					DisplSize = DisplSize.Size4;
					EncoderFlags |= EncoderFlags.Sib;
					Sib = (byte)(0x25 | (internalMemoryIndexScale << 6));
				}
				else
				{
					ModRM |= 5;
					DisplSize = DisplSize.Size4;
				}
				return;
			}
			int num2 = ((memoryBase == Register.None) ? (-1) : (memoryBase - register));
			int num3 = ((memoryIndex == Register.None) ? (-1) : (memoryIndex - register3));
			if (num == 0 && (num2 & 7) == 5)
			{
				num = 1;
				if (Displ != 0)
				{
					ErrorMessage = $"Operand {operand}: Displacement must be 0 if displSize == 0";
					return;
				}
			}
			if (num == 1)
			{
				if (TryConvertToDisp8N(in instruction, (int)Displ, out var compressedValue))
				{
					Displ = (uint)compressedValue;
				}
				else
				{
					num = addrSize / 8;
				}
			}
			if (memoryBase == Register.None)
			{
				DisplSize = DisplSize.Size4;
			}
			else if (num == 1)
			{
				if ((int)Displ < -128 || (int)Displ > 127)
				{
					ErrorMessage = $"Operand {operand}: Displacement must fit in an sbyte";
					return;
				}
				ModRM |= 64;
				DisplSize = DisplSize.Size1;
			}
			else if (num == addrSize / 8)
			{
				ModRM |= 128;
				DisplSize = DisplSize.Size4;
			}
			else
			{
				if (num != 0)
				{
					ErrorMessage = $"Operand {operand}: Invalid {"MemoryDisplSize"} value";
					return;
				}
				if (Displ != 0)
				{
					ErrorMessage = $"Operand {operand}: Displacement must be 0 if displSize == 0";
					return;
				}
			}
			if (memoryIndex == Register.None && (num2 & 7) != 4 && internalMemoryIndexScale == 0 && (EncoderFlags & EncoderFlags.MustUseSib) == 0)
			{
				ModRM |= (byte)(num2 & 7);
			}
			else
			{
				EncoderFlags |= EncoderFlags.Sib;
				Sib = (byte)(internalMemoryIndexScale << 6);
				ModRM |= 4;
				if (memoryIndex == Register.RSP || memoryIndex == Register.ESP)
				{
					ErrorMessage = $"Operand {operand}: ESP/RSP can't be used as an index register";
					return;
				}
				if (num2 < 0)
				{
					Sib |= 5;
				}
				else
				{
					Sib |= (byte)(num2 & 7);
				}
				if (num3 < 0)
				{
					Sib |= 32;
				}
				else
				{
					Sib |= (byte)((num3 & 7) << 3);
				}
			}
			if (num2 >= 0)
			{
				EncoderFlags |= (EncoderFlags)(num2 >> 3);
			}
			if (num3 >= 0)
			{
				EncoderFlags |= (EncoderFlags)((num3 >> 2) & 2);
				EncoderFlags |= (EncoderFlags)((num3 & 0x10) << 27);
			}
		}

		internal void WritePrefixes(in Instruction instruction, bool canWriteF3 = true)
		{
			Register segmentPrefix = instruction.SegmentPrefix;
			if (segmentPrefix != Register.None)
			{
				WriteByteInternal(SegmentOverrides[(int)(segmentPrefix - 71)]);
			}
			if ((EncoderFlags & EncoderFlags.PF0) != EncoderFlags.None || instruction.HasLockPrefix)
			{
				WriteByteInternal(240u);
			}
			if ((EncoderFlags & EncoderFlags.P66) != EncoderFlags.None)
			{
				WriteByteInternal(102u);
			}
			if ((EncoderFlags & EncoderFlags.P67) != EncoderFlags.None)
			{
				WriteByteInternal(103u);
			}
			if (canWriteF3 && instruction.HasRepePrefix)
			{
				WriteByteInternal(243u);
			}
			if (instruction.HasRepnePrefix)
			{
				WriteByteInternal(242u);
			}
		}

		private void WriteModRM()
		{
			if ((EncoderFlags & EncoderFlags.ModRM) != EncoderFlags.None)
			{
				WriteByteInternal(ModRM);
				if ((EncoderFlags & EncoderFlags.Sib) != EncoderFlags.None)
				{
					WriteByteInternal(Sib);
				}
			}
			displAddr = (uint)currentRip;
			switch (DisplSize)
			{
			case DisplSize.Size1:
				WriteByteInternal(Displ);
				break;
			case DisplSize.Size2:
			{
				uint num3 = Displ;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				break;
			}
			case DisplSize.Size4:
			{
				uint num3 = Displ;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				break;
			}
			case DisplSize.Size8:
			{
				uint num3 = Displ;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				num3 = DisplHi;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				break;
			}
			case DisplSize.RipRelSize4_Target32:
			{
				uint num4 = (uint)((int)currentRip + 4) + immSizes[(int)ImmSize];
				uint num3 = Displ - num4;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				break;
			}
			case DisplSize.RipRelSize4_Target64:
			{
				ulong num = currentRip + 4 + immSizes[(int)ImmSize];
				long num2 = (long)((((ulong)DisplHi << 32) | Displ) - num);
				if (num2 < int.MinValue || num2 > int.MaxValue)
				{
					ErrorMessage = $"RIP relative distance is too far away: NextIP: 0x{num:X16} target: 0x{DisplHi:X8}{Displ:X8}, diff = {num2}, diff must fit in an Int32";
				}
				uint num3 = (uint)num2;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				break;
			}
			default:
				throw new InvalidOperationException();
			case DisplSize.None:
				break;
			}
		}

		private void WriteImmediate()
		{
			immAddr = (uint)currentRip;
			switch (ImmSize)
			{
			case ImmSize.Size1:
			case ImmSize.SizeIbReg:
			case ImmSize.Size1OpCode:
				WriteByteInternal(Immediate);
				break;
			case ImmSize.Size2:
			{
				uint num3 = Immediate;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				break;
			}
			case ImmSize.Size4:
			{
				uint num3 = Immediate;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				break;
			}
			case ImmSize.Size8:
			{
				uint num3 = Immediate;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				num3 = ImmediateHi;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				break;
			}
			case ImmSize.Size2_1:
			{
				uint num3 = Immediate;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(ImmediateHi);
				break;
			}
			case ImmSize.Size1_1:
				WriteByteInternal(Immediate);
				WriteByteInternal(ImmediateHi);
				break;
			case ImmSize.Size2_2:
			{
				uint num3 = Immediate;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				num3 = ImmediateHi;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				break;
			}
			case ImmSize.Size4_2:
			{
				uint num3 = Immediate;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				num3 = ImmediateHi;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				break;
			}
			case ImmSize.RipRelSize1_Target16:
			{
				ushort num6 = (ushort)((int)currentRip + 1);
				short num7 = (short)((short)Immediate - (short)num6);
				if (num7 < -128 || num7 > 127)
				{
					ErrorMessage = $"Branch distance is too far away: NextIP: 0x{num6:X4} target: 0x{(ushort)Immediate:X4}, diff = {num7}, diff must fit in an Int8";
				}
				WriteByteInternal((uint)num7);
				break;
			}
			case ImmSize.RipRelSize1_Target32:
			{
				uint num4 = (uint)((int)currentRip + 1);
				int num5 = (int)(Immediate - num4);
				if (num5 < -128 || num5 > 127)
				{
					ErrorMessage = $"Branch distance is too far away: NextIP: 0x{num4:X8} target: 0x{Immediate:X8}, diff = {num5}, diff must fit in an Int8";
				}
				WriteByteInternal((uint)num5);
				break;
			}
			case ImmSize.RipRelSize1_Target64:
			{
				ulong num = currentRip + 1;
				long num2 = (long)((((ulong)ImmediateHi << 32) | Immediate) - num);
				if (num2 < -128 || num2 > 127)
				{
					ErrorMessage = $"Branch distance is too far away: NextIP: 0x{num:X16} target: 0x{ImmediateHi:X8}{Immediate:X8}, diff = {num2}, diff must fit in an Int8";
				}
				WriteByteInternal((uint)num2);
				break;
			}
			case ImmSize.RipRelSize2_Target16:
			{
				uint num4 = (uint)((int)currentRip + 2);
				uint num3 = Immediate - num4;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				break;
			}
			case ImmSize.RipRelSize2_Target32:
			{
				uint num4 = (uint)((int)currentRip + 2);
				int num5 = (int)(Immediate - num4);
				if (num5 < -32768 || num5 > 32767)
				{
					ErrorMessage = $"Branch distance is too far away: NextIP: 0x{num4:X8} target: 0x{Immediate:X8}, diff = {num5}, diff must fit in an Int16";
				}
				uint num3 = (uint)num5;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				break;
			}
			case ImmSize.RipRelSize2_Target64:
			{
				ulong num = currentRip + 2;
				long num2 = (long)((((ulong)ImmediateHi << 32) | Immediate) - num);
				if (num2 < -32768 || num2 > 32767)
				{
					ErrorMessage = $"Branch distance is too far away: NextIP: 0x{num:X16} target: 0x{ImmediateHi:X8}{Immediate:X8}, diff = {num2}, diff must fit in an Int16";
				}
				uint num3 = (uint)num2;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				break;
			}
			case ImmSize.RipRelSize4_Target32:
			{
				uint num4 = (uint)((int)currentRip + 4);
				uint num3 = Immediate - num4;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				break;
			}
			case ImmSize.RipRelSize4_Target64:
			{
				ulong num = currentRip + 4;
				long num2 = (long)((((ulong)ImmediateHi << 32) | Immediate) - num);
				if (num2 < int.MinValue || num2 > int.MaxValue)
				{
					ErrorMessage = $"Branch distance is too far away: NextIP: 0x{num:X16} target: 0x{ImmediateHi:X8}{Immediate:X8}, diff = {num2}, diff must fit in an Int32";
				}
				uint num3 = (uint)num2;
				WriteByteInternal(num3);
				WriteByteInternal(num3 >> 8);
				WriteByteInternal(num3 >> 16);
				WriteByteInternal(num3 >> 24);
				break;
			}
			default:
				throw new InvalidOperationException();
			case ImmSize.None:
				break;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void WriteByte(byte value)
		{
			WriteByteInternal(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void WriteByteInternal(uint value)
		{
			writer.WriteByte((byte)value);
			currentRip++;
		}

		public ConstantOffsets GetConstantOffsets()
		{
			ConstantOffsets result = default(ConstantOffsets);
			switch (DisplSize)
			{
			case DisplSize.Size1:
				result.DisplacementSize = 1;
				result.DisplacementOffset = (byte)(displAddr - eip);
				break;
			case DisplSize.Size2:
				result.DisplacementSize = 2;
				result.DisplacementOffset = (byte)(displAddr - eip);
				break;
			case DisplSize.Size4:
			case DisplSize.RipRelSize4_Target32:
			case DisplSize.RipRelSize4_Target64:
				result.DisplacementSize = 4;
				result.DisplacementOffset = (byte)(displAddr - eip);
				break;
			case DisplSize.Size8:
				result.DisplacementSize = 8;
				result.DisplacementOffset = (byte)(displAddr - eip);
				break;
			default:
				throw new InvalidOperationException();
			case DisplSize.None:
				break;
			}
			switch (ImmSize)
			{
			case ImmSize.Size1:
			case ImmSize.RipRelSize1_Target16:
			case ImmSize.RipRelSize1_Target32:
			case ImmSize.RipRelSize1_Target64:
				result.ImmediateSize = 1;
				result.ImmediateOffset = (byte)(immAddr - eip);
				break;
			case ImmSize.Size1_1:
				result.ImmediateSize = 1;
				result.ImmediateOffset = (byte)(immAddr - eip);
				result.ImmediateSize2 = 1;
				result.ImmediateOffset2 = (byte)(immAddr - eip + 1);
				break;
			case ImmSize.Size2:
			case ImmSize.RipRelSize2_Target16:
			case ImmSize.RipRelSize2_Target32:
			case ImmSize.RipRelSize2_Target64:
				result.ImmediateSize = 2;
				result.ImmediateOffset = (byte)(immAddr - eip);
				break;
			case ImmSize.Size2_1:
				result.ImmediateSize = 2;
				result.ImmediateOffset = (byte)(immAddr - eip);
				result.ImmediateSize2 = 1;
				result.ImmediateOffset2 = (byte)(immAddr - eip + 2);
				break;
			case ImmSize.Size2_2:
				result.ImmediateSize = 2;
				result.ImmediateOffset = (byte)(immAddr - eip);
				result.ImmediateSize2 = 2;
				result.ImmediateOffset2 = (byte)(immAddr - eip + 2);
				break;
			case ImmSize.Size4:
			case ImmSize.RipRelSize4_Target32:
			case ImmSize.RipRelSize4_Target64:
				result.ImmediateSize = 4;
				result.ImmediateOffset = (byte)(immAddr - eip);
				break;
			case ImmSize.Size4_2:
				result.ImmediateSize = 4;
				result.ImmediateOffset = (byte)(immAddr - eip);
				result.ImmediateSize2 = 2;
				result.ImmediateOffset2 = (byte)(immAddr - eip + 4);
				break;
			case ImmSize.Size8:
				result.ImmediateSize = 8;
				result.ImmediateOffset = (byte)(immAddr - eip);
				break;
			default:
				throw new InvalidOperationException();
			case ImmSize.None:
			case ImmSize.SizeIbReg:
			case ImmSize.Size1OpCode:
				break;
			}
			return result;
		}
	}
	[Serializable]
	public class EncoderException : Exception
	{
		public Instruction Instruction { get; }

		public EncoderException(string message, in Instruction instruction)
			: base(message)
		{
			Instruction = instruction;
		}

		protected EncoderException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	public enum EncodingKind
	{
		Legacy,
		VEX,
		EVEX,
		XOP,
		D3NOW,
		MVEX
	}
	internal static class HexUtils
	{
		public static byte[] ToByteArray(string hexData)
		{
			if (hexData == null)
			{
				throw new ArgumentNullException("hexData");
			}
			if (hexData.Length == 0)
			{
				return Array2.Empty<byte>();
			}
			int num = 0;
			for (int i = 0; i < hexData.Length; i++)
			{
				if (hexData[i] != ' ')
				{
					num++;
				}
			}
			byte[] array = new byte[num / 2];
			int num2 = 0;
			int j = 0;
			while (true)
			{
				if (j < hexData.Length && char.IsWhiteSpace(hexData[j]))
				{
					j++;
					continue;
				}
				if (j >= hexData.Length)
				{
					break;
				}
				int num3 = TryParseHexChar(hexData[j++]);
				if (num3 < 0)
				{
					throw new ArgumentOutOfRangeException("hexData");
				}
				for (; j < hexData.Length && char.IsWhiteSpace(hexData[j]); j++)
				{
				}
				if (j >= hexData.Length)
				{
					throw new ArgumentOutOfRangeException("hexData");
				}
				int num4 = TryParseHexChar(hexData[j++]);
				if (num4 < 0)
				{
					throw new ArgumentOutOfRangeException("hexData");
				}
				array[num2++] = (byte)((num3 << 4) | num4);
			}
			if (num2 != array.Length)
			{
				throw new InvalidOperationException();
			}
			return array;
		}

		private static int TryParseHexChar(char c)
		{
			if ('0' <= c && c <= '9')
			{
				return c - 48;
			}
			if ('A' <= c && c <= 'F')
			{
				return c - 65 + 10;
			}
			if ('a' <= c && c <= 'f')
			{
				return c - 97 + 10;
			}
			return -1;
		}
	}
	internal static class IcedConstants
	{
		internal const int MaxOpCount = 5;

		internal const int MaxInstructionLength = 15;

		internal const int RegisterBits = 8;

		internal const Register VMM_first = Register.ZMM0;

		internal const Register VMM_last = Register.ZMM31;

		internal const int VMM_count = 32;

		internal const Register XMM_last = Register.XMM31;

		internal const Register YMM_last = Register.YMM31;

		internal const Register ZMM_last = Register.ZMM31;

		internal const Register TMM_last = Register.TMM7;

		internal const int MaxCpuidFeatureInternalValues = 199;

		internal const MemorySize FirstBroadcastMemorySize = MemorySize.Broadcast32_Float16;

		internal const uint MvexStart = 4611u;

		internal const uint MvexLength = 207u;

		internal const int CC_a_EnumCount = 2;

		internal const int CC_ae_EnumCount = 3;

		internal const int CC_b_EnumCount = 3;

		internal const int CC_be_EnumCount = 2;

		internal const int CC_e_EnumCount = 2;

		internal const int CC_g_EnumCount = 2;

		internal const int CC_ge_EnumCount = 2;

		internal const int CC_l_EnumCount = 2;

		internal const int CC_le_EnumCount = 2;

		internal const int CC_ne_EnumCount = 2;

		internal const int CC_np_EnumCount = 2;

		internal const int CC_p_EnumCount = 2;

		internal const int CodeEnumCount = 4936;

		internal const int CodeSizeEnumCount = 4;

		internal const int ConditionCodeEnumCount = 17;

		internal const int CpuidFeatureEnumCount = 178;

		internal const int DecoderErrorEnumCount = 3;

		internal const int DecoratorKindEnumCount = 6;

		internal const int EncodingKindEnumCount = 6;

		internal const int FlowControlEnumCount = 10;

		internal const int FormatterSyntaxEnumCount = 4;

		internal const int FormatterTextKindEnumCount = 16;

		internal const int MandatoryPrefixEnumCount = 5;

		internal const int MemorySizeEnumCount = 162;

		internal const int MemorySizeOptionsEnumCount = 4;

		internal const int MnemonicEnumCount = 1894;

		internal const int MvexConvFnEnumCount = 13;

		internal const int MvexEHBitEnumCount = 3;

		internal const int MvexRegMemConvEnumCount = 17;

		internal const int MvexTupleTypeLutKindEnumCount = 14;

		internal const int NumberBaseEnumCount = 4;

		internal const int NumberKindEnumCount = 8;

		internal const int OpAccessEnumCount = 8;

		internal const int OpCodeOperandKindEnumCount = 109;

		internal const int OpCodeTableKindEnumCount = 9;

		internal const int OpKindEnumCount = 25;

		internal const int PrefixKindEnumCount = 18;

		internal const int RegisterEnumCount = 256;

		internal const int RelocKindEnumCount = 1;

		internal const int RepPrefixKindEnumCount = 3;

		internal const int RoundingControlEnumCount = 5;

		internal const int TupleTypeEnumCount = 19;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsMvex(Code code)
		{
			return false;
		}
	}
	public static class IcedFeatures
	{
		public static bool HasGasFormatter => false;

		public static bool HasIntelFormatter => false;

		public static bool HasMasmFormatter => false;

		public static bool HasNasmFormatter => false;

		public static bool HasFastFormatter => false;

		public static bool HasDecoder => true;

		public static bool HasEncoder => true;

		public static bool HasBlockEncoder => true;

		public static bool HasOpCodeInfo => false;

		public static bool HasInstructionInfo => false;

		public static void Initialize()
		{
			RuntimeHelpers.RunClassConstructor(typeof(Decoder).TypeHandle);
		}
	}
	public enum RepPrefixKind
	{
		None,
		Repe,
		Repne
	}
	public struct Instruction : IEquatable<Instruction>
	{
		[Flags]
		private enum InstrFlags1 : uint
		{
			SegmentPrefixMask = 7u,
			SegmentPrefixShift = 5u,
			DataLengthMask = 0xFu,
			DataLengthShift = 8u,
			RoundingControlMask = 7u,
			RoundingControlShift = 0xCu,
			OpMaskMask = 7u,
			OpMaskShift = 0xFu,
			CodeSizeMask = 3u,
			CodeSizeShift = 0x12u,
			Broadcast = 0x4000000u,
			SuppressAllExceptions = 0x8000000u,
			ZeroingMasking = 0x10000000u,
			RepePrefix = 0x20000000u,
			RepnePrefix = 0x40000000u,
			LockPrefix = 0x80000000u,
			EqualsIgnoreMask = 0xC0000u
		}

		[Flags]
		private enum MvexInstrFlags : uint
		{
			MvexRegMemConvShift = 0x10u,
			MvexRegMemConvMask = 0x1Fu,
			EvictionHint = 0x80000000u
		}

		internal const int TOTAL_SIZE = 40;

		private ulong nextRip;

		private ulong memDispl;

		private uint flags1;

		private uint immediate;

		private ushort code;

		private byte memBaseReg;

		private byte memIndexReg;

		private byte reg0;

		private byte reg1;

		private byte reg2;

		private byte reg3;

		private byte opKind0;

		private byte opKind1;

		private byte opKind2;

		private byte opKind3;

		private byte scale;

		private byte displSize;

		private byte len;

		private byte pad;

		public ushort IP16
		{
			readonly get
			{
				return (ushort)((int)nextRip - Length);
			}
			set
			{
				nextRip = (uint)(value + Length);
			}
		}

		public uint IP32
		{
			readonly get
			{
				return (uint)((int)nextRip - Length);
			}
			set
			{
				nextRip = value + (uint)Length;
			}
		}

		public ulong IP
		{
			readonly get
			{
				return nextRip - (uint)Length;
			}
			set
			{
				nextRip = value + (uint)Length;
			}
		}

		public ushort NextIP16
		{
			readonly get
			{
				return (ushort)nextRip;
			}
			set
			{
				nextRip = value;
			}
		}

		public uint NextIP32
		{
			readonly get
			{
				return (uint)nextRip;
			}
			set
			{
				nextRip = value;
			}
		}

		public ulong NextIP
		{
			readonly get
			{
				return nextRip;
			}
			set
			{
				nextRip = value;
			}
		}

		public CodeSize CodeSize
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (CodeSize)((flags1 >> 18) & 3);
			}
			set
			{
				flags1 = (flags1 & 0xFFF3FFFFu) | (uint)((int)(value & CodeSize.Code64) << 18);
			}
		}

		internal CodeSize InternalCodeSize
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				flags1 |= (uint)((int)value << 18);
			}
		}

		public readonly bool IsInvalid
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return code == 0;
			}
		}

		public Code Code
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (Code)code;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				if ((uint)value >= 4936u)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException_value();
				}
				code = (ushort)value;
			}
		}

		public readonly Mnemonic Mnemonic
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return Code.Mnemonic();
			}
		}

		public readonly int OpCount
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return InstructionOpCounts.OpCount[code];
			}
		}

		public int Length
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return len;
			}
			set
			{
				len = (byte)value;
			}
		}

		internal readonly bool Internal_HasRepeOrRepnePrefix
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (flags1 & 0x60000000) != 0;
			}
		}

		internal readonly uint HasAnyOf_Lock_Rep_Repne_Prefix
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return flags1 & 0xE0000000u;
			}
		}

		public bool HasXacquirePrefix
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				if ((flags1 & 0x40000000) != 0)
				{
					return IsXacquireInstr();
				}
				return false;
			}
			set
			{
				if (value)
				{
					flags1 |= 1073741824u;
				}
				else
				{
					flags1 &= 3221225471u;
				}
			}
		}

		public bool HasXreleasePrefix
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				if ((flags1 & 0x20000000) != 0)
				{
					return IsXreleaseInstr();
				}
				return false;
			}
			set
			{
				if (value)
				{
					flags1 |= 536870912u;
				}
				else
				{
					flags1 &= 3758096383u;
				}
			}
		}

		public bool HasRepPrefix
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (flags1 & 0x20000000) != 0;
			}
			set
			{
				if (value)
				{
					flags1 |= 536870912u;
				}
				else
				{
					flags1 &= 3758096383u;
				}
			}
		}

		public bool HasRepePrefix
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (flags1 & 0x20000000) != 0;
			}
			set
			{
				if (value)
				{
					flags1 |= 536870912u;
				}
				else
				{
					flags1 &= 3758096383u;
				}
			}
		}

		public bool HasRepnePrefix
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (flags1 & 0x40000000) != 0;
			}
			set
			{
				if (value)
				{
					flags1 |= 1073741824u;
				}
				else
				{
					flags1 &= 3221225471u;
				}
			}
		}

		public bool HasLockPrefix
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (flags1 & 0x80000000u) != 0;
			}
			set
			{
				if (value)
				{
					flags1 |= 2147483648u;
				}
				else
				{
					flags1 &= 2147483647u;
				}
			}
		}

		public OpKind Op0Kind
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (OpKind)opKind0;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				opKind0 = (byte)value;
			}
		}

		internal readonly bool Internal_Op0IsNotReg_or_Op1IsNotReg
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (opKind0 | opKind1) != 0;
			}
		}

		public OpKind Op1Kind
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (OpKind)opKind1;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				opKind1 = (byte)value;
			}
		}

		public OpKind Op2Kind
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (OpKind)opKind2;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				opKind2 = (byte)value;
			}
		}

		public OpKind Op3Kind
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (OpKind)opKind3;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				opKind3 = (byte)value;
			}
		}

		public OpKind Op4Kind
		{
			readonly get
			{
				return OpKind.Immediate8;
			}
			set
			{
				if (value != OpKind.Immediate8)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException_value();
				}
			}
		}

		public readonly bool HasSegmentPrefix
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ((flags1 >> 5) & 7) - 1 < 6;
			}
		}

		public Register SegmentPrefix
		{
			readonly get
			{
				uint num = ((flags1 >> 5) & 7) - 1;
				if (num >= 6)
				{
					return Register.None;
				}
				return (Register)(71 + num);
			}
			set
			{
				uint num = (uint)((value != Register.None) ? ((value - 71 + 1) & Register.DH) : Register.None);
				flags1 = (flags1 & 0xFFFFFF1Fu) | (num << 5);
			}
		}

		public readonly Register MemorySegment
		{
			get
			{
				Register segmentPrefix = SegmentPrefix;
				if (segmentPrefix != Register.None)
				{
					return segmentPrefix;
				}
				Register memoryBase = MemoryBase;
				if (memoryBase == Register.BP || memoryBase == Register.EBP || memoryBase == Register.ESP || memoryBase == Register.RBP || memoryBase == Register.RSP)
				{
					return Register.SS;
				}
				return Register.DS;
			}
		}

		public int MemoryDisplSize
		{
			readonly get
			{
				return displSize switch
				{
					0 => 0, 
					1 => 1, 
					2 => 2, 
					3 => 4, 
					_ => 8, 
				};
			}
			set
			{
				displSize = value switch
				{
					0 => 0, 
					1 => 1, 
					2 => 2, 
					4 => 3, 
					_ => 4, 
				};
			}
		}

		public bool IsBroadcast
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (flags1 & 0x4000000) != 0;
			}
			set
			{
				if (value)
				{
					flags1 |= 67108864u;
				}
				else
				{
					flags1 &= 4227858431u;
				}
			}
		}

		public readonly MemorySize MemorySize
		{
			get
			{
				int index = (int)Code;
				if (IsBroadcast)
				{
					return (MemorySize)InstructionMemorySizes.SizesBcst[index];
				}
				return (MemorySize)InstructionMemorySizes.SizesNormal[index];
			}
		}

		public int MemoryIndexScale
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return 1 << (int)scale;
			}
			set
			{
				switch (value)
				{
				case 1:
					scale = 0;
					break;
				case 2:
					scale = 1;
					break;
				case 4:
					scale = 2;
					break;
				default:
					scale = 3;
					break;
				}
			}
		}

		internal int InternalMemoryIndexScale
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return scale;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				scale = (byte)value;
			}
		}

		public uint MemoryDisplacement32
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (uint)memDispl;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				memDispl = value;
			}
		}

		public ulong MemoryDisplacement64
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return memDispl;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				memDispl = value;
			}
		}

		public byte Immediate8
		{
			readonly get
			{
				return (byte)immediate;
			}
			set
			{
				immediate = value;
			}
		}

		internal uint InternalImmediate8
		{
			set
			{
				immediate = value;
			}
		}

		public byte Immediate8_2nd
		{
			readonly get
			{
				return (byte)memDispl;
			}
			set
			{
				memDispl = value;
			}
		}

		internal uint InternalImmediate8_2nd
		{
			set
			{
				memDispl = value;
			}
		}

		public ushort Immediate16
		{
			readonly get
			{
				return (ushort)immediate;
			}
			set
			{
				immediate = value;
			}
		}

		internal uint InternalImmediate16
		{
			set
			{
				immediate = value;
			}
		}

		public uint Immediate32
		{
			readonly get
			{
				return immediate;
			}
			set
			{
				immediate = value;
			}
		}

		public ulong Immediate64
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (memDispl << 32) | immediate;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				immediate = (uint)value;
				memDispl = (uint)(value >> 32);
			}
		}

		internal uint InternalImmediate64_lo
		{
			set
			{
				immediate = value;
			}
		}

		internal uint InternalImmediate64_hi
		{
			set
			{
				memDispl = value;
			}
		}

		public short Immediate8to16
		{
			readonly get
			{
				return (sbyte)immediate;
			}
			set
			{
				immediate = (uint)(sbyte)value;
			}
		}

		public int Immediate8to32
		{
			readonly get
			{
				return (sbyte)immediate;
			}
			set
			{
				immediate = (uint)(sbyte)value;
			}
		}

		public long Immediate8to64
		{
			readonly get
			{
				return (sbyte)immediate;
			}
			set
			{
				immediate = (uint)(sbyte)value;
			}
		}

		public long Immediate32to64
		{
			readonly get
			{
				return (int)immediate;
			}
			set
			{
				immediate = (uint)value;
			}
		}

		public ushort NearBranch16
		{
			readonly get
			{
				return (ushort)memDispl;
			}
			set
			{
				memDispl = value;
			}
		}

		internal uint InternalNearBranch16
		{
			set
			{
				memDispl = value;
			}
		}

		public uint NearBranch32
		{
			readonly get
			{
				return (uint)memDispl;
			}
			set
			{
				memDispl = value;
			}
		}

		public ulong NearBranch64
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return memDispl;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				memDispl = value;
			}
		}

		public readonly ulong NearBranchTarget => Op0Kind switch
		{
			OpKind.NearBranch16 => NearBranch16, 
			OpKind.NearBranch32 => NearBranch32, 
			OpKind.NearBranch64 => NearBranch64, 
			_ => 0uL, 
		};

		public ushort FarBranch16
		{
			readonly get
			{
				return (ushort)immediate;
			}
			set
			{
				immediate = value;
			}
		}

		internal uint InternalFarBranch16
		{
			set
			{
				immediate = value;
			}
		}

		public uint FarBranch32
		{
			readonly get
			{
				return immediate;
			}
			set
			{
				immediate = value;
			}
		}

		public ushort FarBranchSelector
		{
			readonly get
			{
				return (ushort)memDispl;
			}
			set
			{
				memDispl = value;
			}
		}

		internal uint InternalFarBranchSelector
		{
			set
			{
				memDispl = value;
			}
		}

		public Register MemoryBase
		{
			readonly get
			{
				return (Register)memBaseReg;
			}
			set
			{
				memBaseReg = (byte)value;
			}
		}

		internal Register InternalMemoryBase
		{
			set
			{
				memBaseReg = (byte)value;
			}
		}

		public Register MemoryIndex
		{
			readonly get
			{
				return (Register)memIndexReg;
			}
			set
			{
				memIndexReg = (byte)value;
			}
		}

		internal Register InternalMemoryIndex
		{
			set
			{
				memIndexReg = (byte)value;
			}
		}

		public Register Op0Register
		{
			readonly get
			{
				return (Register)reg0;
			}
			set
			{
				reg0 = (byte)value;
			}
		}

		internal Register InternalOp0Register
		{
			set
			{
				reg0 = (byte)value;
			}
		}

		public Register Op1Register
		{
			readonly get
			{
				return (Register)reg1;
			}
			set
			{
				reg1 = (byte)value;
			}
		}

		internal Register InternalOp1Register
		{
			set
			{
				reg1 = (byte)value;
			}
		}

		public Register Op2Register
		{
			readonly get
			{
				return (Register)reg2;
			}
			set
			{
				reg2 = (byte)value;
			}
		}

		internal Register InternalOp2Register
		{
			set
			{
				reg2 = (byte)value;
			}
		}

		public Register Op3Register
		{
			readonly get
			{
				return (Register)reg3;
			}
			set
			{
				reg3 = (byte)value;
			}
		}

		internal Register InternalOp3Register
		{
			set
			{
				reg3 = (byte)value;
			}
		}

		public Register Op4Register
		{
			readonly get
			{
				return Register.None;
			}
			set
			{
				if (value != Register.None)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException_value();
				}
			}
		}

		public Register OpMask
		{
			readonly get
			{
				int num = (int)((flags1 >> 15) & 7);
				if (num != 0)
				{
					return (Register)(num + 173);
				}
				return Register.None;
			}
			set
			{
				uint num = (uint)((value != Register.None) ? ((value - 173) & Register.DH) : Register.None);
				flags1 = (flags1 & 0xFFFC7FFFu) | (num << 15);
			}
		}

		internal uint InternalOpMask
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (flags1 >> 15) & 7;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				flags1 |= value << 15;
			}
		}

		public readonly bool HasOpMask
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (flags1 & 0x38000) != 0;
			}
		}

		internal readonly bool HasOpMask_or_ZeroingMasking
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (flags1 & 0x10038000) != 0;
			}
		}

		public bool ZeroingMasking
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (flags1 & 0x10000000) != 0;
			}
			set
			{
				if (value)
				{
					flags1 |= 268435456u;
				}
				else
				{
					flags1 &= 4026531839u;
				}
			}
		}

		public bool MergingMasking
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (flags1 & 0x10000000) == 0;
			}
			set
			{
				if (value)
				{
					flags1 &= 4026531839u;
				}
				else
				{
					flags1 |= 268435456u;
				}
			}
		}

		public RoundingControl RoundingControl
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (RoundingControl)((flags1 >> 12) & 7);
			}
			set
			{
				flags1 = (flags1 & 0xFFFF8FFFu) | (uint)((int)value << 12);
			}
		}

		internal uint InternalRoundingControl
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				flags1 |= value << 12;
			}
		}

		internal readonly bool HasRoundingControlOrSae
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (flags1 & 0x8007000) != 0;
			}
		}

		public int DeclareDataCount
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (int)(((flags1 >> 8) & 0xF) + 1);
			}
			set
			{
				flags1 = (flags1 & 0xFFFFF0FFu) | (uint)(((value - 1) & 0xF) << 8);
			}
		}

		internal uint InternalDeclareDataCount
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				flags1 |= value - 1 << 8;
			}
		}

		public readonly bool IsVsib
		{
			get
			{
				bool vsib;
				return TryGetVsib64(out vsib);
			}
		}

		public readonly bool IsVsib32
		{
			get
			{
				if (TryGetVsib64(out var vsib))
				{
					return !vsib;
				}
				return false;
			}
		}

		public readonly bool IsVsib64
		{
			get
			{
				bool vsib;
				return TryGetVsib64(out vsib) && vsib;
			}
		}

		public bool SuppressAllExceptions
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			readonly get
			{
				return (flags1 & 0x8000000) != 0;
			}
			set
			{
				if (value)
				{
					flags1 |= 134217728u;
				}
				else
				{
					flags1 &= 4160749567u;
				}
			}
		}

		public readonly bool IsIPRelativeMemoryOperand
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (MemoryBase != Register.RIP)
				{
					return MemoryBase == Register.EIP;
				}
				return true;
			}
		}

		public readonly ulong IPRelativeMemoryAddress
		{
			get
			{
				if (MemoryBase != Register.EIP)
				{
					return MemoryDisplacement64;
				}
				return MemoryDisplacement32;
			}
		}

		private static void InitializeSignedImmediate(ref Instruction instruction, int operand, long immediate)
		{
			OpKind immediateOpKind = GetImmediateOpKind(instruction.Code, operand);
			instruction.SetOpKind(operand, immediateOpKind);
			switch (immediateOpKind)
			{
			case OpKind.Immediate8:
				if (-128 > immediate || immediate > 255)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate8 = (byte)immediate;
				break;
			case OpKind.Immediate8_2nd:
				if (-128 > immediate || immediate > 255)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate8_2nd = (byte)immediate;
				break;
			case OpKind.Immediate8to16:
				if (-128 > immediate || immediate > 127)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate8 = (byte)immediate;
				break;
			case OpKind.Immediate8to32:
				if (-128 > immediate || immediate > 127)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate8 = (byte)immediate;
				break;
			case OpKind.Immediate8to64:
				if (-128 > immediate || immediate > 127)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate8 = (byte)immediate;
				break;
			case OpKind.Immediate16:
				if (-32768 > immediate || immediate > 65535)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate16 = (ushort)immediate;
				break;
			case OpKind.Immediate32:
				if (int.MinValue > immediate || immediate > uint.MaxValue)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.Immediate32 = (uint)immediate;
				break;
			case OpKind.Immediate32to64:
				if (int.MinValue > immediate || immediate > int.MaxValue)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.Immediate32 = (uint)immediate;
				break;
			case OpKind.Immediate64:
				instruction.Immediate64 = (ulong)immediate;
				break;
			default:
				throw new ArgumentOutOfRangeException("instruction");
			}
		}

		private static void InitializeUnsignedImmediate(ref Instruction instruction, int operand, ulong immediate)
		{
			OpKind immediateOpKind = GetImmediateOpKind(instruction.Code, operand);
			instruction.SetOpKind(operand, immediateOpKind);
			switch (immediateOpKind)
			{
			case OpKind.Immediate8:
				if (immediate > 255)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate8 = (byte)immediate;
				break;
			case OpKind.Immediate8_2nd:
				if (immediate > 255)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate8_2nd = (byte)immediate;
				break;
			case OpKind.Immediate8to16:
				if (immediate > 127 && (65408 > immediate || immediate > 65535))
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate8 = (byte)immediate;
				break;
			case OpKind.Immediate8to32:
				if (immediate > 127 && (4294967168u > immediate || immediate > uint.MaxValue))
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate8 = (byte)immediate;
				break;
			case OpKind.Immediate8to64:
				if (immediate + 128 > 255)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate8 = (byte)immediate;
				break;
			case OpKind.Immediate16:
				if (immediate > 65535)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.InternalImmediate16 = (ushort)immediate;
				break;
			case OpKind.Immediate32:
				if (immediate > uint.MaxValue)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.Immediate32 = (uint)immediate;
				break;
			case OpKind.Immediate32to64:
				if (immediate + 2147483648u > uint.MaxValue)
				{
					throw new ArgumentOutOfRangeException("immediate");
				}
				instruction.Immediate32 = (uint)immediate;
				break;
			case OpKind.Immediate64:
				instruction.Immediate64 = immediate;
				break;
			default:
				throw new ArgumentOutOfRangeException("instruction");
			}
		}

		private static OpKind GetImmediateOpKind(Code code, int operand)
		{
			Iced.Intel.EncoderInternal.OpCodeHandler[] handlers = OpCodeHandlers.Handlers;
			if ((uint)code >= (uint)handlers.Length)
			{
				throw new ArgumentOutOfRangeException("code");
			}
			Op[] operands = handlers[(int)code].Operands;
			if ((uint)operand >= (uint)operands.Length)
			{
				throw new ArgumentOutOfRangeException("operand", $"{code} doesn't have at least {operand + 1} operands");
			}
			OpKind opKind = operands[operand].GetImmediateOpKind();
			if (opKind == OpKind.Immediate8 && operand > 0 && operand + 1 == operands.Length)
			{
				OpKind immediateOpKind = operands[operand - 1].GetImmediateOpKind();
				if (immediateOpKind == OpKind.Immediate8 || immediateOpKind == OpKind.Immediate16)
				{
					opKind = OpKind.Immediate8_2nd;
				}
			}
			if (opKind == (OpKind)(-1))
			{
				throw new ArgumentException($"{code}'s op{operand} isn't an immediate operand");
			}
			return opKind;
		}

		private static OpKind GetNearBranchOpKind(Code code, int operand)
		{
			Iced.Intel.EncoderInternal.OpCodeHandler[] handlers = OpCodeHandlers.Handlers;
			if ((uint)code >= (uint)handlers.Length)
			{
				throw new ArgumentOutOfRangeException("code");
			}
			Op[] operands = handlers[(int)code].Operands;
			if ((uint)operand >= (uint)operands.Length)
			{
				throw new ArgumentOutOfRangeException("operand", $"{code} doesn't have at least {operand + 1} operands");
			}
			OpKind nearBranchOpKind = operands[operand].GetNearBranchOpKind();
			if (nearBranchOpKind == (OpKind)(-1))
			{
				throw new ArgumentException($"{code}'s op{operand} isn't a near branch operand");
			}
			return nearBranchOpKind;
		}

		private static OpKind GetFarBranchOpKind(Code code, int operand)
		{
			Iced.Intel.EncoderInternal.OpCodeHandler[] handlers = OpCodeHandlers.Handlers;
			if ((uint)code >= (uint)handlers.Length)
			{
				throw new ArgumentOutOfRangeException("code");
			}
			Op[] operands = handlers[(int)code].Operands;
			if ((uint)operand >= (uint)operands.Length)
			{
				throw new ArgumentOutOfRangeException("operand", $"{code} doesn't have at least {operand + 1} operands");
			}
			OpKind farBranchOpKind = operands[operand].GetFarBranchOpKind();
			if (farBranchOpKind == (OpKind)(-1))
			{
				throw new ArgumentException($"{code}'s op{operand} isn't a far branch operand");
			}
			return farBranchOpKind;
		}

		private static Instruction CreateString_Reg_SegRSI(Code code, int addressSize, Register register, Register segmentPrefix, RepPrefixKind repPrefix)
		{
			Instruction result = new Instruction
			{
				Code = code
			};
			switch (repPrefix)
			{
			case RepPrefixKind.Repe:
				result.InternalSetHasRepePrefix();
				break;
			case RepPrefixKind.Repne:
				result.InternalSetHasRepnePrefix();
				break;
			}
			result.Op0Register = register;
			switch (addressSize)
			{
			case 64:
				result.Op1Kind = OpKind.MemorySegRSI;
				break;
			case 32:
				result.Op1Kind = OpKind.MemorySegESI;
				break;
			case 16:
				result.Op1Kind = OpKind.MemorySegSI;
				break;
			default:
				throw new ArgumentOutOfRangeException("addressSize");
			}
			result.SegmentPrefix = segmentPrefix;
			return result;
		}

		private static Instruction CreateString_Reg_ESRDI(Code code, int addressSize, Register register, RepPrefixKind repPrefix)
		{
			Instruction result = new Instruction
			{
				Code = code
			};
			switch (repPrefix)
			{
			case RepPrefixKind.Repe:
				result.InternalSetHasRepePrefix();
				break;
			case RepPrefixKind.Repne:
				result.InternalSetHasRepnePrefix();
				break;
			}
			result.Op0Register = register;
			switch (addressSize)
			{
			case 64:
				result.Op1Kind = OpKind.MemoryESRDI;
				break;
			case 32:
				result.Op1Kind = OpKind.MemoryESEDI;
				break;
			case 16:
				result.Op1Kind = OpKind.MemoryESDI;
				break;
			default:
				throw new ArgumentOutOfRangeException("addressSize");
			}
			return result;
		}

		private static Instruction CreateString_ESRDI_Reg(Code code, int addressSize, Register register, RepPrefixKind repPrefix)
		{
			Instruction result = new Instruction
			{
				Code = code
			};
			switch (repPrefix)
			{
			case RepPrefixKind.Repe:
				result.InternalSetHasRepePrefix();
				break;
			case RepPrefixKind.Repne:
				result.InternalSetHasRepnePrefix();
				break;
			}
			switch (addressSize)
			{
			case 64:
				result.Op0Kind = OpKind.MemoryESRDI;
				break;
			case 32:
				result.Op0Kind = OpKind.MemoryESEDI;
				break;
			case 16:
				result.Op0Kind = OpKind.MemoryESDI;
				break;
			default:
				throw new ArgumentOutOfRangeException("addressSize");
			}
			result.Op1Register = register;
			return result;
		}

		private static Instruction CreateString_SegRSI_ESRDI(Code code, int addressSize, Register segmentPrefix, RepPrefixKind repPrefix)
		{
			Instruction result = new Instruction
			{
				Code = code
			};
			switch (repPrefix)
			{
			case RepPrefixKind.Repe:
				result.InternalSetHasRepePrefix();
				break;
			case RepPrefixKind.Repne:
				result.InternalSetHasRepnePrefix();
				break;
			}
			switch (addressSize)
			{
			case 64:
				result.Op0Kind = OpKind.MemorySegRSI;
				result.Op1Kind = OpKind.MemoryESRDI;
				break;
			case 32:
				result.Op0Kind = OpKind.MemorySegESI;
				result.Op1Kind = OpKind.MemoryESEDI;
				break;
			case 16:
				result.Op0Kind = OpKind.MemorySegSI;
				result.Op1Kind = OpKind.MemoryESDI;
				break;
			default:
				throw new ArgumentOutOfRangeException("addressSize");
			}
			result.SegmentPrefix = segmentPrefix;
			return result;
		}

		private static Instruction CreateString_ESRDI_SegRSI(Code code, int addressSize, Register segmentPrefix, RepPrefixKind repPrefix)
		{
			Instruction result = new Instruction
			{
				Code = code
			};
			switch (repPrefix)
			{
			case RepPrefixKind.Repe:
				result.InternalSetHasRepePrefix();
				break;
			case RepPrefixKind.Repne:
				result.InternalSetHasRepnePrefix();
				break;
			}
			switch (addressSize)
			{
			case 64:
				result.Op0Kind = OpKind.MemoryESRDI;
				result.Op1Kind = OpKind.MemorySegRSI;
				break;
			case 32:
				result.Op0Kind = OpKind.MemoryESEDI;
				result.Op1Kind = OpKind.MemorySegESI;
				break;
			case 16:
				result.Op0Kind = OpKind.MemoryESDI;
				result.Op1Kind = OpKind.MemorySegSI;
				break;
			default:
				throw new ArgumentOutOfRangeException("addressSize");
			}
			result.SegmentPrefix = segmentPrefix;
			return result;
		}

		private static Instruction CreateMaskmov(Code code, int addressSize, Register register1, Register register2, Register segmentPrefix)
		{
			Instruction result = new Instruction
			{
				Code = code
			};
			switch (addressSize)
			{
			case 64:
				result.Op0Kind = OpKind.MemorySegRDI;
				break;
			case 32:
				result.Op0Kind = OpKind.MemorySegEDI;
				break;
			case 16:
				result.Op0Kind = OpKind.MemorySegDI;
				break;
			default:
				throw new ArgumentOutOfRangeException("addressSize");
			}
			result.Op1Register = register1;
			result.Op2Register = register2;
			result.SegmentPrefix = segmentPrefix;
			return result;
		}

		private static void InitMemoryOperand(ref Instruction instruction, in MemoryOperand memory)
		{
			instruction.InternalMemoryBase = memory.Base;
			instruction.InternalMemoryIndex = memory.Index;
			instruction.MemoryIndexScale = memory.Scale;
			instruction.MemoryDisplSize = memory.DisplSize;
			instruction.MemoryDisplacement64 = (ulong)memory.Displacement;
			instruction.IsBroadcast = memory.IsBroadcast;
			instruction.SegmentPrefix = memory.SegmentPrefix;
		}

		public static Instruction Create(Code code)
		{
			return new Instruction
			{
				Code = code
			};
		}

		public static Instruction Create(Code code, Register register)
		{
			return new Instruction
			{
				Code = code,
				Op0Register = register
			};
		}

		public static Instruction Create(Code code, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code
			};
			InitializeSignedImmediate(ref instruction, 0, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code
			};
			InitializeUnsignedImmediate(ref instruction, 0, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, in MemoryOperand memory)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2)
		{
			return new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2
			};
		}

		public static Instruction Create(Code code, Register register, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register
			};
			InitializeSignedImmediate(ref instruction, 1, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register
			};
			InitializeUnsignedImmediate(ref instruction, 1, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register, long immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register
			};
			InitializeSignedImmediate(ref instruction, 1, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register, ulong immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register
			};
			InitializeUnsignedImmediate(ref instruction, 1, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register, in MemoryOperand memory)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register,
				Op1Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			return instruction;
		}

		public static Instruction Create(Code code, int immediate, Register register)
		{
			Instruction instruction = new Instruction
			{
				Code = code
			};
			InitializeSignedImmediate(ref instruction, 0, immediate);
			instruction.Op1Register = register;
			return instruction;
		}

		public static Instruction Create(Code code, uint immediate, Register register)
		{
			Instruction instruction = new Instruction
			{
				Code = code
			};
			InitializeUnsignedImmediate(ref instruction, 0, immediate);
			instruction.Op1Register = register;
			return instruction;
		}

		public static Instruction Create(Code code, int immediate1, int immediate2)
		{
			Instruction instruction = new Instruction
			{
				Code = code
			};
			InitializeSignedImmediate(ref instruction, 0, immediate1);
			InitializeSignedImmediate(ref instruction, 1, immediate2);
			return instruction;
		}

		public static Instruction Create(Code code, uint immediate1, uint immediate2)
		{
			Instruction instruction = new Instruction
			{
				Code = code
			};
			InitializeUnsignedImmediate(ref instruction, 0, immediate1);
			InitializeUnsignedImmediate(ref instruction, 1, immediate2);
			return instruction;
		}

		public static Instruction Create(Code code, in MemoryOperand memory, Register register)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			instruction.Op1Register = register;
			return instruction;
		}

		public static Instruction Create(Code code, in MemoryOperand memory, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			InitializeSignedImmediate(ref instruction, 1, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, in MemoryOperand memory, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			InitializeUnsignedImmediate(ref instruction, 1, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, Register register3)
		{
			return new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Register = register3
			};
		}

		public static Instruction Create(Code code, Register register1, Register register2, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2
			};
			InitializeSignedImmediate(ref instruction, 2, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2
			};
			InitializeUnsignedImmediate(ref instruction, 2, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, in MemoryOperand memory)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			return instruction;
		}

		public static Instruction Create(Code code, Register register, int immediate1, int immediate2)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register
			};
			InitializeSignedImmediate(ref instruction, 1, immediate1);
			InitializeSignedImmediate(ref instruction, 2, immediate2);
			return instruction;
		}

		public static Instruction Create(Code code, Register register, uint immediate1, uint immediate2)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register
			};
			InitializeUnsignedImmediate(ref instruction, 1, immediate1);
			InitializeUnsignedImmediate(ref instruction, 2, immediate2);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, in MemoryOperand memory, Register register2)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			instruction.Op2Register = register2;
			return instruction;
		}

		public static Instruction Create(Code code, Register register, in MemoryOperand memory, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register,
				Op1Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			InitializeSignedImmediate(ref instruction, 2, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register, in MemoryOperand memory, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register,
				Op1Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			InitializeUnsignedImmediate(ref instruction, 2, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, in MemoryOperand memory, Register register1, Register register2)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			instruction.Op1Register = register1;
			instruction.Op2Register = register2;
			return instruction;
		}

		public static Instruction Create(Code code, in MemoryOperand memory, Register register, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			instruction.Op1Register = register;
			InitializeSignedImmediate(ref instruction, 2, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, in MemoryOperand memory, Register register, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			instruction.Op1Register = register;
			InitializeUnsignedImmediate(ref instruction, 2, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, Register register3, Register register4)
		{
			return new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Register = register3,
				Op3Register = register4
			};
		}

		public static Instruction Create(Code code, Register register1, Register register2, Register register3, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Register = register3
			};
			InitializeSignedImmediate(ref instruction, 3, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, Register register3, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Register = register3
			};
			InitializeUnsignedImmediate(ref instruction, 3, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, Register register3, in MemoryOperand memory)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Register = register3,
				Op3Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, int immediate1, int immediate2)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2
			};
			InitializeSignedImmediate(ref instruction, 2, immediate1);
			InitializeSignedImmediate(ref instruction, 3, immediate2);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, uint immediate1, uint immediate2)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2
			};
			InitializeUnsignedImmediate(ref instruction, 2, immediate1);
			InitializeUnsignedImmediate(ref instruction, 3, immediate2);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, in MemoryOperand memory, Register register3)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			instruction.Op3Register = register3;
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, in MemoryOperand memory, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			InitializeSignedImmediate(ref instruction, 3, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, in MemoryOperand memory, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			InitializeUnsignedImmediate(ref instruction, 3, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, Register register3, Register register4, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Register = register3,
				Op3Register = register4
			};
			InitializeSignedImmediate(ref instruction, 4, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, Register register3, Register register4, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Register = register3,
				Op3Register = register4
			};
			InitializeUnsignedImmediate(ref instruction, 4, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, Register register3, in MemoryOperand memory, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Register = register3,
				Op3Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			InitializeSignedImmediate(ref instruction, 4, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, Register register3, in MemoryOperand memory, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Register = register3,
				Op3Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			InitializeUnsignedImmediate(ref instruction, 4, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, in MemoryOperand memory, Register register3, int immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			instruction.Op3Register = register3;
			InitializeSignedImmediate(ref instruction, 4, immediate);
			return instruction;
		}

		public static Instruction Create(Code code, Register register1, Register register2, in MemoryOperand memory, Register register3, uint immediate)
		{
			Instruction instruction = new Instruction
			{
				Code = code,
				Op0Register = register1,
				Op1Register = register2,
				Op2Kind = OpKind.Memory
			};
			InitMemoryOperand(ref instruction, in memory);
			instruction.Op3Register = register3;
			InitializeUnsignedImmediate(ref instruction, 4, immediate);
			return instruction;
		}

		public static Instruction CreateBranch(Code code, ulong target)
		{
			return new Instruction
			{
				Code = code,
				Op0Kind = GetNearBranchOpKind(code, 0),
				NearBranch64 = target
			};
		}

		public static Instruction CreateBranch(Code code, ushort selector, uint offset)
		{
			return new Instruction
			{
				Code = code,
				Op0Kind = GetFarBranchOpKind(code, 0),
				FarBranchSelector = selector,
				FarBranch32 = offset
			};
		}

		public static Instruction CreateXbegin(int bitness, ulong target)
		{
			Instruction result = default(Instruction);
			switch (bitness)
			{
			case 16:
				result.Code = Code.Xbegin_rel16;
				result.Op0Kind = OpKind.NearBranch32;
				result.NearBranch32 = (uint)target;
				break;
			case 32:
				result.Code = Code.Xbegin_rel32;
				result.Op0Kind = OpKind.NearBranch32;
				result.NearBranch32 = (uint)target;
				break;
			case 64:
				result.Code = Code.Xbegin_rel32;
				result.Op0Kind = OpKind.NearBranch64;
				result.NearBranch64 = target;
				break;
			default:
				throw new ArgumentOutOfRangeException("bitness");
			}
			return result;
		}

		public static Instruction CreateOutsb(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_SegRSI(Code.Outsb_DX_m8, addressSize, Register.DX, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepOutsb(int addressSize)
		{
			return CreateString_Reg_SegRSI(Code.Outsb_DX_m8, addressSize, Register.DX, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateOutsw(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_SegRSI(Code.Outsw_DX_m16, addressSize, Register.DX, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepOutsw(int addressSize)
		{
			return CreateString_Reg_SegRSI(Code.Outsw_DX_m16, addressSize, Register.DX, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateOutsd(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_SegRSI(Code.Outsd_DX_m32, addressSize, Register.DX, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepOutsd(int addressSize)
		{
			return CreateString_Reg_SegRSI(Code.Outsd_DX_m32, addressSize, Register.DX, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateLodsb(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_SegRSI(Code.Lodsb_AL_m8, addressSize, Register.AL, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepLodsb(int addressSize)
		{
			return CreateString_Reg_SegRSI(Code.Lodsb_AL_m8, addressSize, Register.AL, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateLodsw(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_SegRSI(Code.Lodsw_AX_m16, addressSize, Register.AX, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepLodsw(int addressSize)
		{
			return CreateString_Reg_SegRSI(Code.Lodsw_AX_m16, addressSize, Register.AX, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateLodsd(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_SegRSI(Code.Lodsd_EAX_m32, addressSize, Register.EAX, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepLodsd(int addressSize)
		{
			return CreateString_Reg_SegRSI(Code.Lodsd_EAX_m32, addressSize, Register.EAX, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateLodsq(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_SegRSI(Code.Lodsq_RAX_m64, addressSize, Register.RAX, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepLodsq(int addressSize)
		{
			return CreateString_Reg_SegRSI(Code.Lodsq_RAX_m64, addressSize, Register.RAX, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateScasb(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_ESRDI(Code.Scasb_AL_m8, addressSize, Register.AL, repPrefix);
		}

		public static Instruction CreateRepeScasb(int addressSize)
		{
			return CreateString_Reg_ESRDI(Code.Scasb_AL_m8, addressSize, Register.AL, RepPrefixKind.Repe);
		}

		public static Instruction CreateRepneScasb(int addressSize)
		{
			return CreateString_Reg_ESRDI(Code.Scasb_AL_m8, addressSize, Register.AL, RepPrefixKind.Repne);
		}

		public static Instruction CreateScasw(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_ESRDI(Code.Scasw_AX_m16, addressSize, Register.AX, repPrefix);
		}

		public static Instruction CreateRepeScasw(int addressSize)
		{
			return CreateString_Reg_ESRDI(Code.Scasw_AX_m16, addressSize, Register.AX, RepPrefixKind.Repe);
		}

		public static Instruction CreateRepneScasw(int addressSize)
		{
			return CreateString_Reg_ESRDI(Code.Scasw_AX_m16, addressSize, Register.AX, RepPrefixKind.Repne);
		}

		public static Instruction CreateScasd(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_ESRDI(Code.Scasd_EAX_m32, addressSize, Register.EAX, repPrefix);
		}

		public static Instruction CreateRepeScasd(int addressSize)
		{
			return CreateString_Reg_ESRDI(Code.Scasd_EAX_m32, addressSize, Register.EAX, RepPrefixKind.Repe);
		}

		public static Instruction CreateRepneScasd(int addressSize)
		{
			return CreateString_Reg_ESRDI(Code.Scasd_EAX_m32, addressSize, Register.EAX, RepPrefixKind.Repne);
		}

		public static Instruction CreateScasq(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_Reg_ESRDI(Code.Scasq_RAX_m64, addressSize, Register.RAX, repPrefix);
		}

		public static Instruction CreateRepeScasq(int addressSize)
		{
			return CreateString_Reg_ESRDI(Code.Scasq_RAX_m64, addressSize, Register.RAX, RepPrefixKind.Repe);
		}

		public static Instruction CreateRepneScasq(int addressSize)
		{
			return CreateString_Reg_ESRDI(Code.Scasq_RAX_m64, addressSize, Register.RAX, RepPrefixKind.Repne);
		}

		public static Instruction CreateInsb(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_Reg(Code.Insb_m8_DX, addressSize, Register.DX, repPrefix);
		}

		public static Instruction CreateRepInsb(int addressSize)
		{
			return CreateString_ESRDI_Reg(Code.Insb_m8_DX, addressSize, Register.DX, RepPrefixKind.Repe);
		}

		public static Instruction CreateInsw(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_Reg(Code.Insw_m16_DX, addressSize, Register.DX, repPrefix);
		}

		public static Instruction CreateRepInsw(int addressSize)
		{
			return CreateString_ESRDI_Reg(Code.Insw_m16_DX, addressSize, Register.DX, RepPrefixKind.Repe);
		}

		public static Instruction CreateInsd(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_Reg(Code.Insd_m32_DX, addressSize, Register.DX, repPrefix);
		}

		public static Instruction CreateRepInsd(int addressSize)
		{
			return CreateString_ESRDI_Reg(Code.Insd_m32_DX, addressSize, Register.DX, RepPrefixKind.Repe);
		}

		public static Instruction CreateStosb(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_Reg(Code.Stosb_m8_AL, addressSize, Register.AL, repPrefix);
		}

		public static Instruction CreateRepStosb(int addressSize)
		{
			return CreateString_ESRDI_Reg(Code.Stosb_m8_AL, addressSize, Register.AL, RepPrefixKind.Repe);
		}

		public static Instruction CreateStosw(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_Reg(Code.Stosw_m16_AX, addressSize, Register.AX, repPrefix);
		}

		public static Instruction CreateRepStosw(int addressSize)
		{
			return CreateString_ESRDI_Reg(Code.Stosw_m16_AX, addressSize, Register.AX, RepPrefixKind.Repe);
		}

		public static Instruction CreateStosd(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_Reg(Code.Stosd_m32_EAX, addressSize, Register.EAX, repPrefix);
		}

		public static Instruction CreateRepStosd(int addressSize)
		{
			return CreateString_ESRDI_Reg(Code.Stosd_m32_EAX, addressSize, Register.EAX, RepPrefixKind.Repe);
		}

		public static Instruction CreateStosq(int addressSize, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_Reg(Code.Stosq_m64_RAX, addressSize, Register.RAX, repPrefix);
		}

		public static Instruction CreateRepStosq(int addressSize)
		{
			return CreateString_ESRDI_Reg(Code.Stosq_m64_RAX, addressSize, Register.RAX, RepPrefixKind.Repe);
		}

		public static Instruction CreateCmpsb(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsb_m8_m8, addressSize, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepeCmpsb(int addressSize)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsb_m8_m8, addressSize, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateRepneCmpsb(int addressSize)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsb_m8_m8, addressSize, Register.None, RepPrefixKind.Repne);
		}

		public static Instruction CreateCmpsw(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsw_m16_m16, addressSize, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepeCmpsw(int addressSize)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsw_m16_m16, addressSize, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateRepneCmpsw(int addressSize)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsw_m16_m16, addressSize, Register.None, RepPrefixKind.Repne);
		}

		public static Instruction CreateCmpsd(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsd_m32_m32, addressSize, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepeCmpsd(int addressSize)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsd_m32_m32, addressSize, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateRepneCmpsd(int addressSize)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsd_m32_m32, addressSize, Register.None, RepPrefixKind.Repne);
		}

		public static Instruction CreateCmpsq(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsq_m64_m64, addressSize, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepeCmpsq(int addressSize)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsq_m64_m64, addressSize, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateRepneCmpsq(int addressSize)
		{
			return CreateString_SegRSI_ESRDI(Code.Cmpsq_m64_m64, addressSize, Register.None, RepPrefixKind.Repne);
		}

		public static Instruction CreateMovsb(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_SegRSI(Code.Movsb_m8_m8, addressSize, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepMovsb(int addressSize)
		{
			return CreateString_ESRDI_SegRSI(Code.Movsb_m8_m8, addressSize, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateMovsw(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_SegRSI(Code.Movsw_m16_m16, addressSize, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepMovsw(int addressSize)
		{
			return CreateString_ESRDI_SegRSI(Code.Movsw_m16_m16, addressSize, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateMovsd(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_SegRSI(Code.Movsd_m32_m32, addressSize, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepMovsd(int addressSize)
		{
			return CreateString_ESRDI_SegRSI(Code.Movsd_m32_m32, addressSize, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateMovsq(int addressSize, Register segmentPrefix = Register.None, RepPrefixKind repPrefix = RepPrefixKind.None)
		{
			return CreateString_ESRDI_SegRSI(Code.Movsq_m64_m64, addressSize, segmentPrefix, repPrefix);
		}

		public static Instruction CreateRepMovsq(int addressSize)
		{
			return CreateString_ESRDI_SegRSI(Code.Movsq_m64_m64, addressSize, Register.None, RepPrefixKind.Repe);
		}

		public static Instruction CreateMaskmovq(int addressSize, Register register1, Register register2, Register segmentPrefix = Register.None)
		{
			return CreateMaskmov(Code.Maskmovq_rDI_mm_mm, addressSize, register1, register2, segmentPrefix);
		}

		public static Instruction CreateMaskmovdqu(int addressSize, Register register1, Register register2, Register segmentPrefix = Register.None)
		{
			return CreateMaskmov(Code.Maskmovdqu_rDI_xmm_xmm, addressSize, register1, register2, segmentPrefix);
		}

		public static Instruction CreateVmaskmovdqu(int addressSize, Register register1, Register register2, Register segmentPrefix = Register.None)
		{
			return CreateMaskmov(Code.VEX_Vmaskmovdqu_rDI_xmm_xmm, addressSize, register1, register2, segmentPrefix);
		}

		public static Instruction CreateDeclareByte(byte b0)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 1u;
			result.SetDeclareByteValue(0, b0);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 2u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 3u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 4u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 5u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 6u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5, byte b6)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 7u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			result.SetDeclareByteValue(6, b6);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 8u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			result.SetDeclareByteValue(6, b6);
			result.SetDeclareByteValue(7, b7);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 9u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			result.SetDeclareByteValue(6, b6);
			result.SetDeclareByteValue(7, b7);
			result.SetDeclareByteValue(8, b8);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8, byte b9)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 10u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			result.SetDeclareByteValue(6, b6);
			result.SetDeclareByteValue(7, b7);
			result.SetDeclareByteValue(8, b8);
			result.SetDeclareByteValue(9, b9);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8, byte b9, byte b10)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 11u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			result.SetDeclareByteValue(6, b6);
			result.SetDeclareByteValue(7, b7);
			result.SetDeclareByteValue(8, b8);
			result.SetDeclareByteValue(9, b9);
			result.SetDeclareByteValue(10, b10);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8, byte b9, byte b10, byte b11)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 12u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			result.SetDeclareByteValue(6, b6);
			result.SetDeclareByteValue(7, b7);
			result.SetDeclareByteValue(8, b8);
			result.SetDeclareByteValue(9, b9);
			result.SetDeclareByteValue(10, b10);
			result.SetDeclareByteValue(11, b11);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8, byte b9, byte b10, byte b11, byte b12)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 13u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			result.SetDeclareByteValue(6, b6);
			result.SetDeclareByteValue(7, b7);
			result.SetDeclareByteValue(8, b8);
			result.SetDeclareByteValue(9, b9);
			result.SetDeclareByteValue(10, b10);
			result.SetDeclareByteValue(11, b11);
			result.SetDeclareByteValue(12, b12);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8, byte b9, byte b10, byte b11, byte b12, byte b13)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 14u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			result.SetDeclareByteValue(6, b6);
			result.SetDeclareByteValue(7, b7);
			result.SetDeclareByteValue(8, b8);
			result.SetDeclareByteValue(9, b9);
			result.SetDeclareByteValue(10, b10);
			result.SetDeclareByteValue(11, b11);
			result.SetDeclareByteValue(12, b12);
			result.SetDeclareByteValue(13, b13);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8, byte b9, byte b10, byte b11, byte b12, byte b13, byte b14)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 15u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			result.SetDeclareByteValue(6, b6);
			result.SetDeclareByteValue(7, b7);
			result.SetDeclareByteValue(8, b8);
			result.SetDeclareByteValue(9, b9);
			result.SetDeclareByteValue(10, b10);
			result.SetDeclareByteValue(11, b11);
			result.SetDeclareByteValue(12, b12);
			result.SetDeclareByteValue(13, b13);
			result.SetDeclareByteValue(14, b14);
			return result;
		}

		public static Instruction CreateDeclareByte(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5, byte b6, byte b7, byte b8, byte b9, byte b10, byte b11, byte b12, byte b13, byte b14, byte b15)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareByte;
			result.InternalDeclareDataCount = 16u;
			result.SetDeclareByteValue(0, b0);
			result.SetDeclareByteValue(1, b1);
			result.SetDeclareByteValue(2, b2);
			result.SetDeclareByteValue(3, b3);
			result.SetDeclareByteValue(4, b4);
			result.SetDeclareByteValue(5, b5);
			result.SetDeclareByteValue(6, b6);
			result.SetDeclareByteValue(7, b7);
			result.SetDeclareByteValue(8, b8);
			result.SetDeclareByteValue(9, b9);
			result.SetDeclareByteValue(10, b10);
			result.SetDeclareByteValue(11, b11);
			result.SetDeclareByteValue(12, b12);
			result.SetDeclareByteValue(13, b13);
			result.SetDeclareByteValue(14, b14);
			result.SetDeclareByteValue(15, b15);
			return result;
		}

		public static Instruction CreateDeclareByte(ReadOnlySpan<byte> data)
		{
			if ((uint)(data.Length - 1) > 15u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_data();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareByte,
				InternalDeclareDataCount = (uint)data.Length
			};
			for (int i = 0; i < data.Length; i++)
			{
				result.SetDeclareByteValue(i, data[i]);
			}
			return result;
		}

		public static Instruction CreateDeclareByte(byte[] data)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			return CreateDeclareByte(data, 0, data.Length);
		}

		public static Instruction CreateDeclareByte(byte[] data, int index, int length)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			if ((uint)(length - 1) > 15u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_length();
			}
			if ((ulong)((long)(uint)index + (long)(uint)length) > (ulong)(uint)data.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareByte,
				InternalDeclareDataCount = (uint)length
			};
			for (int i = 0; i < length; i++)
			{
				result.SetDeclareByteValue(i, data[index + i]);
			}
			return result;
		}

		public static Instruction CreateDeclareWord(ushort w0)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareWord;
			result.InternalDeclareDataCount = 1u;
			result.SetDeclareWordValue(0, w0);
			return result;
		}

		public static Instruction CreateDeclareWord(ushort w0, ushort w1)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareWord;
			result.InternalDeclareDataCount = 2u;
			result.SetDeclareWordValue(0, w0);
			result.SetDeclareWordValue(1, w1);
			return result;
		}

		public static Instruction CreateDeclareWord(ushort w0, ushort w1, ushort w2)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareWord;
			result.InternalDeclareDataCount = 3u;
			result.SetDeclareWordValue(0, w0);
			result.SetDeclareWordValue(1, w1);
			result.SetDeclareWordValue(2, w2);
			return result;
		}

		public static Instruction CreateDeclareWord(ushort w0, ushort w1, ushort w2, ushort w3)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareWord;
			result.InternalDeclareDataCount = 4u;
			result.SetDeclareWordValue(0, w0);
			result.SetDeclareWordValue(1, w1);
			result.SetDeclareWordValue(2, w2);
			result.SetDeclareWordValue(3, w3);
			return result;
		}

		public static Instruction CreateDeclareWord(ushort w0, ushort w1, ushort w2, ushort w3, ushort w4)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareWord;
			result.InternalDeclareDataCount = 5u;
			result.SetDeclareWordValue(0, w0);
			result.SetDeclareWordValue(1, w1);
			result.SetDeclareWordValue(2, w2);
			result.SetDeclareWordValue(3, w3);
			result.SetDeclareWordValue(4, w4);
			return result;
		}

		public static Instruction CreateDeclareWord(ushort w0, ushort w1, ushort w2, ushort w3, ushort w4, ushort w5)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareWord;
			result.InternalDeclareDataCount = 6u;
			result.SetDeclareWordValue(0, w0);
			result.SetDeclareWordValue(1, w1);
			result.SetDeclareWordValue(2, w2);
			result.SetDeclareWordValue(3, w3);
			result.SetDeclareWordValue(4, w4);
			result.SetDeclareWordValue(5, w5);
			return result;
		}

		public static Instruction CreateDeclareWord(ushort w0, ushort w1, ushort w2, ushort w3, ushort w4, ushort w5, ushort w6)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareWord;
			result.InternalDeclareDataCount = 7u;
			result.SetDeclareWordValue(0, w0);
			result.SetDeclareWordValue(1, w1);
			result.SetDeclareWordValue(2, w2);
			result.SetDeclareWordValue(3, w3);
			result.SetDeclareWordValue(4, w4);
			result.SetDeclareWordValue(5, w5);
			result.SetDeclareWordValue(6, w6);
			return result;
		}

		public static Instruction CreateDeclareWord(ushort w0, ushort w1, ushort w2, ushort w3, ushort w4, ushort w5, ushort w6, ushort w7)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareWord;
			result.InternalDeclareDataCount = 8u;
			result.SetDeclareWordValue(0, w0);
			result.SetDeclareWordValue(1, w1);
			result.SetDeclareWordValue(2, w2);
			result.SetDeclareWordValue(3, w3);
			result.SetDeclareWordValue(4, w4);
			result.SetDeclareWordValue(5, w5);
			result.SetDeclareWordValue(6, w6);
			result.SetDeclareWordValue(7, w7);
			return result;
		}

		public static Instruction CreateDeclareWord(ReadOnlySpan<byte> data)
		{
			if ((uint)(data.Length - 1) > 15u || (data.Length & 1) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_data();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareWord,
				InternalDeclareDataCount = (uint)data.Length / 2u
			};
			for (int i = 0; i < data.Length; i += 2)
			{
				uint num = (uint)(data[i] | (data[i + 1] << 8));
				result.SetDeclareWordValue(i / 2, (ushort)num);
			}
			return result;
		}

		public static Instruction CreateDeclareWord(byte[] data)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			return CreateDeclareWord(data, 0, data.Length);
		}

		public static Instruction CreateDeclareWord(byte[] data, int index, int length)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			if ((uint)(length - 1) > 15u || (length & 1) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_length();
			}
			if ((ulong)((long)(uint)index + (long)(uint)length) > (ulong)(uint)data.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareWord,
				InternalDeclareDataCount = (uint)length / 2u
			};
			for (int i = 0; i < length; i += 2)
			{
				uint num = (uint)(data[index + i] | (data[index + i + 1] << 8));
				result.SetDeclareWordValue(i / 2, (ushort)num);
			}
			return result;
		}

		public static Instruction CreateDeclareWord(ReadOnlySpan<ushort> data)
		{
			if ((uint)(data.Length - 1) > 7u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_data();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareWord,
				InternalDeclareDataCount = (uint)data.Length
			};
			for (int i = 0; i < data.Length; i++)
			{
				result.SetDeclareWordValue(i, data[i]);
			}
			return result;
		}

		public static Instruction CreateDeclareWord(ushort[] data)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			return CreateDeclareWord(data, 0, data.Length);
		}

		public static Instruction CreateDeclareWord(ushort[] data, int index, int length)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			if ((uint)(length - 1) > 7u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_length();
			}
			if ((ulong)((long)(uint)index + (long)(uint)length) > (ulong)(uint)data.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareWord,
				InternalDeclareDataCount = (uint)length
			};
			for (int i = 0; i < length; i++)
			{
				result.SetDeclareWordValue(i, data[index + i]);
			}
			return result;
		}

		public static Instruction CreateDeclareDword(uint d0)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareDword;
			result.InternalDeclareDataCount = 1u;
			result.SetDeclareDwordValue(0, d0);
			return result;
		}

		public static Instruction CreateDeclareDword(uint d0, uint d1)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareDword;
			result.InternalDeclareDataCount = 2u;
			result.SetDeclareDwordValue(0, d0);
			result.SetDeclareDwordValue(1, d1);
			return result;
		}

		public static Instruction CreateDeclareDword(uint d0, uint d1, uint d2)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareDword;
			result.InternalDeclareDataCount = 3u;
			result.SetDeclareDwordValue(0, d0);
			result.SetDeclareDwordValue(1, d1);
			result.SetDeclareDwordValue(2, d2);
			return result;
		}

		public static Instruction CreateDeclareDword(uint d0, uint d1, uint d2, uint d3)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareDword;
			result.InternalDeclareDataCount = 4u;
			result.SetDeclareDwordValue(0, d0);
			result.SetDeclareDwordValue(1, d1);
			result.SetDeclareDwordValue(2, d2);
			result.SetDeclareDwordValue(3, d3);
			return result;
		}

		public static Instruction CreateDeclareDword(ReadOnlySpan<byte> data)
		{
			if ((uint)(data.Length - 1) > 15u || (data.Length & 3) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_data();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareDword,
				InternalDeclareDataCount = (uint)data.Length / 4u
			};
			for (int i = 0; i < data.Length; i += 4)
			{
				uint value = (uint)(data[i] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3] << 24));
				result.SetDeclareDwordValue(i / 4, value);
			}
			return result;
		}

		public static Instruction CreateDeclareDword(byte[] data)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			return CreateDeclareDword(data, 0, data.Length);
		}

		public static Instruction CreateDeclareDword(byte[] data, int index, int length)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			if ((uint)(length - 1) > 15u || (length & 3) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_length();
			}
			if ((ulong)((long)(uint)index + (long)(uint)length) > (ulong)(uint)data.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareDword,
				InternalDeclareDataCount = (uint)length / 4u
			};
			for (int i = 0; i < length; i += 4)
			{
				uint value = (uint)(data[index + i] | (data[index + i + 1] << 8) | (data[index + i + 2] << 16) | (data[index + i + 3] << 24));
				result.SetDeclareDwordValue(i / 4, value);
			}
			return result;
		}

		public static Instruction CreateDeclareDword(ReadOnlySpan<uint> data)
		{
			if ((uint)(data.Length - 1) > 3u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_data();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareDword,
				InternalDeclareDataCount = (uint)data.Length
			};
			for (int i = 0; i < data.Length; i++)
			{
				result.SetDeclareDwordValue(i, data[i]);
			}
			return result;
		}

		public static Instruction CreateDeclareDword(uint[] data)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			return CreateDeclareDword(data, 0, data.Length);
		}

		public static Instruction CreateDeclareDword(uint[] data, int index, int length)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			if ((uint)(length - 1) > 3u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_length();
			}
			if ((ulong)((long)(uint)index + (long)(uint)length) > (ulong)(uint)data.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareDword,
				InternalDeclareDataCount = (uint)length
			};
			for (int i = 0; i < length; i++)
			{
				result.SetDeclareDwordValue(i, data[index + i]);
			}
			return result;
		}

		public static Instruction CreateDeclareQword(ulong q0)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareQword;
			result.InternalDeclareDataCount = 1u;
			result.SetDeclareQwordValue(0, q0);
			return result;
		}

		public static Instruction CreateDeclareQword(ulong q0, ulong q1)
		{
			Instruction result = default(Instruction);
			result.Code = Code.DeclareQword;
			result.InternalDeclareDataCount = 2u;
			result.SetDeclareQwordValue(0, q0);
			result.SetDeclareQwordValue(1, q1);
			return result;
		}

		public static Instruction CreateDeclareQword(ReadOnlySpan<byte> data)
		{
			if ((uint)(data.Length - 1) > 15u || (data.Length & 7) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_data();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareQword,
				InternalDeclareDataCount = (uint)data.Length / 8u
			};
			for (int i = 0; i < data.Length; i += 8)
			{
				uint num = (uint)(data[i] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3] << 24));
				uint num2 = (uint)(data[i + 4] | (data[i + 5] << 8) | (data[i + 6] << 16) | (data[i + 7] << 24));
				result.SetDeclareQwordValue(i / 8, num | ((ulong)num2 << 32));
			}
			return result;
		}

		public static Instruction CreateDeclareQword(byte[] data)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			return CreateDeclareQword(data, 0, data.Length);
		}

		public static Instruction CreateDeclareQword(byte[] data, int index, int length)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			if ((uint)(length - 1) > 15u || (length & 7) != 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_length();
			}
			if ((ulong)((long)(uint)index + (long)(uint)length) > (ulong)(uint)data.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareQword,
				InternalDeclareDataCount = (uint)length / 8u
			};
			for (int i = 0; i < length; i += 8)
			{
				uint num = (uint)(data[index + i] | (data[index + i + 1] << 8) | (data[index + i + 2] << 16) | (data[index + i + 3] << 24));
				uint num2 = (uint)(data[index + i + 4] | (data[index + i + 5] << 8) | (data[index + i + 6] << 16) | (data[index + i + 7] << 24));
				result.SetDeclareQwordValue(i / 8, num | ((ulong)num2 << 32));
			}
			return result;
		}

		public static Instruction CreateDeclareQword(ReadOnlySpan<ulong> data)
		{
			if ((uint)(data.Length - 1) > 1u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_data();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareQword,
				InternalDeclareDataCount = (uint)data.Length
			};
			for (int i = 0; i < data.Length; i++)
			{
				result.SetDeclareQwordValue(i, data[i]);
			}
			return result;
		}

		public static Instruction CreateDeclareQword(ulong[] data)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			return CreateDeclareQword(data, 0, data.Length);
		}

		public static Instruction CreateDeclareQword(ulong[] data, int index, int length)
		{
			if (data == null)
			{
				ThrowHelper.ThrowArgumentNullException_data();
			}
			if ((uint)(length - 1) > 1u)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_length();
			}
			if ((ulong)((long)(uint)index + (long)(uint)length) > (ulong)(uint)data.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			Instruction result = new Instruction
			{
				Code = Code.DeclareQword,
				InternalDeclareDataCount = (uint)length
			};
			for (int i = 0; i < length; i++)
			{
				result.SetDeclareQwordValue(i, data[index + i]);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(in Instruction left, in Instruction right)
		{
			return EqualsInternal(in left, in right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator !=(in Instruction left, in Instruction right)
		{
			return !EqualsInternal(in left, in right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public readonly bool Equals(in Instruction other)
		{
			return EqualsInternal(in this, in other);
		}

		readonly bool IEquatable<Instruction>.Equals(Instruction other)
		{
			return EqualsInternal(in this, in other);
		}

		private static bool EqualsInternal(in Instruction a, in Instruction b)
		{
			if (a.memDispl == b.memDispl && ((a.flags1 ^ b.flags1) & 0xFFF3FFFFu) == 0 && a.immediate == b.immediate && a.code == b.code && a.memBaseReg == b.memBaseReg && a.memIndexReg == b.memIndexReg && a.reg0 == b.reg0 && a.reg1 == b.reg1 && a.reg2 == b.reg2 && a.reg3 == b.reg3 && a.opKind0 == b.opKind0 && a.opKind1 == b.opKind1 && a.opKind2 == b.opKind2 && a.opKind3 == b.opKind3 && a.scale == b.scale && a.displSize == b.displSize)
			{
				return a.pad == b.pad;
			}
			return false;
		}

		public override readonly int GetHashCode()
		{
			return (int)((uint)((int)memDispl ^ (int)(memDispl >> 32)) ^ (flags1 & 0xFFF3FFFFu) ^ immediate ^ (uint)(code << 8) ^ (uint)(memBaseReg << 16) ^ (uint)(memIndexReg << 24) ^ reg3 ^ (uint)(reg2 << 8) ^ (uint)(reg1 << 16) ^ (uint)(reg0 << 24) ^ opKind3 ^ (uint)(opKind2 << 8) ^ (uint)(opKind1 << 16) ^ (uint)(opKind0 << 24) ^ scale ^ (uint)(displSize << 8)) ^ (pad << 16);
		}

		public override readonly bool Equals(object? obj)
		{
			if (obj is Instruction b)
			{
				return EqualsInternal(in this, in b);
			}
			return false;
		}

		public static bool EqualsAllBits(in Instruction a, in Instruction b)
		{
			if (a.nextRip == b.nextRip && a.memDispl == b.memDispl && a.flags1 == b.flags1 && a.immediate == b.immediate && a.code == b.code && a.memBaseReg == b.memBaseReg && a.memIndexReg == b.memIndexReg && a.reg0 == b.reg0 && a.reg1 == b.reg1 && a.reg2 == b.reg2 && a.reg3 == b.reg3 && a.opKind0 == b.opKind0 && a.opKind1 == b.opKind1 && a.opKind2 == b.opKind2 && a.opKind3 == b.opKind3 && a.scale == b.scale && a.displSize == b.displSize && a.len == b.len)
			{
				return a.pad == b.pad;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalSetCodeNoCheck(Code code)
		{
			this.code = (ushort)code;
		}

		private readonly bool IsXacquireInstr()
		{
			if (Op0Kind != OpKind.Memory)
			{
				return false;
			}
			if (HasLockPrefix)
			{
				return Code != Code.Cmpxchg16b_m128;
			}
			return Mnemonic == Mnemonic.Xchg;
		}

		private readonly bool IsXreleaseInstr()
		{
			if (Op0Kind != OpKind.Memory)
			{
				return false;
			}
			if (HasLockPrefix)
			{
				return Code != Code.Cmpxchg16b_m128;
			}
			Code code = Code;
			if ((uint)(code - 275) <= 7u || code == Code.Mov_rm8_imm8 || (uint)(code - 403) <= 2u)
			{
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalSetHasXacquirePrefix()
		{
			flags1 |= 1073741824u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalSetHasXreleasePrefix()
		{
			flags1 |= 536870912u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalSetHasRepePrefix()
		{
			flags1 = (flags1 & 0xBFFFFFFFu) | 0x20000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalClearHasRepePrefix()
		{
			flags1 &= 3758096383u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalClearHasRepeRepnePrefix()
		{
			flags1 &= 2684354559u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalSetHasRepnePrefix()
		{
			flags1 = (flags1 & 0xDFFFFFFFu) | 0x40000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalClearHasRepnePrefix()
		{
			flags1 &= 3221225471u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalSetHasLockPrefix()
		{
			flags1 |= 2147483648u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalClearHasLockPrefix()
		{
			flags1 &= 2147483647u;
		}

		public readonly OpKind GetOpKind(int operand)
		{
			switch (operand)
			{
			case 0:
				return Op0Kind;
			case 1:
				return Op1Kind;
			case 2:
				return Op2Kind;
			case 3:
				return Op3Kind;
			case 4:
				return Op4Kind;
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_operand();
				return OpKind.Register;
			}
		}

		public readonly bool HasOpKind(OpKind opKind)
		{
			for (int i = 0; i < OpCount; i++)
			{
				if (GetOpKind(i) == opKind)
				{
					return true;
				}
			}
			return false;
		}

		public void SetOpKind(int operand, OpKind opKind)
		{
			switch (operand)
			{
			case 0:
				Op0Kind = opKind;
				break;
			case 1:
				Op1Kind = opKind;
				break;
			case 2:
				Op2Kind = opKind;
				break;
			case 3:
				Op3Kind = opKind;
				break;
			case 4:
				Op4Kind = opKind;
				break;
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_operand();
				break;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalSetMemoryDisplSize(uint scale)
		{
			displSize = (byte)scale;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalSetIsBroadcast()
		{
			flags1 |= 67108864u;
		}

		public readonly ulong GetImmediate(int operand)
		{
			return GetOpKind(operand) switch
			{
				OpKind.Immediate8 => Immediate8, 
				OpKind.Immediate8_2nd => Immediate8_2nd, 
				OpKind.Immediate16 => Immediate16, 
				OpKind.Immediate32 => Immediate32, 
				OpKind.Immediate64 => Immediate64, 
				OpKind.Immediate8to16 => (ulong)Immediate8to16, 
				OpKind.Immediate8to32 => (ulong)Immediate8to32, 
				OpKind.Immediate8to64 => (ulong)Immediate8to64, 
				OpKind.Immediate32to64 => (ulong)Immediate32to64, 
				_ => throw new ArgumentException($"Op{operand} isn't an immediate operand", "operand"), 
			};
		}

		public void SetImmediate(int operand, int immediate)
		{
			SetImmediate(operand, (ulong)immediate);
		}

		public void SetImmediate(int operand, uint immediate)
		{
			SetImmediate(operand, (ulong)immediate);
		}

		public void SetImmediate(int operand, long immediate)
		{
			SetImmediate(operand, (ulong)immediate);
		}

		public void SetImmediate(int operand, ulong immediate)
		{
			switch (GetOpKind(operand))
			{
			case OpKind.Immediate8:
				Immediate8 = (byte)immediate;
				return;
			case OpKind.Immediate8to16:
				Immediate8to16 = (short)immediate;
				return;
			case OpKind.Immediate8to32:
				Immediate8to32 = (int)immediate;
				return;
			case OpKind.Immediate8to64:
				Immediate8to64 = (long)immediate;
				return;
			case OpKind.Immediate8_2nd:
				Immediate8_2nd = (byte)immediate;
				return;
			case OpKind.Immediate16:
				Immediate16 = (ushort)immediate;
				return;
			case OpKind.Immediate32to64:
				Immediate32to64 = (long)immediate;
				return;
			case OpKind.Immediate32:
				Immediate32 = (uint)immediate;
				return;
			case OpKind.Immediate64:
				Immediate64 = immediate;
				return;
			}
			throw new ArgumentException($"Op{operand} isn't an immediate operand", "operand");
		}

		public readonly Register GetOpRegister(int operand)
		{
			switch (operand)
			{
			case 0:
				return Op0Register;
			case 1:
				return Op1Register;
			case 2:
				return Op2Register;
			case 3:
				return Op3Register;
			case 4:
				return Op4Register;
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_operand();
				return Register.None;
			}
		}

		public void SetOpRegister(int operand, Register register)
		{
			switch (operand)
			{
			case 0:
				Op0Register = register;
				break;
			case 1:
				Op1Register = register;
				break;
			case 2:
				Op2Register = register;
				break;
			case 3:
				Op3Register = register;
				break;
			case 4:
				Op4Register = register;
				break;
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_operand();
				break;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalSetZeroingMasking()
		{
			flags1 |= 268435456u;
		}

		public void SetDeclareByteValue(int index, sbyte value)
		{
			SetDeclareByteValue(index, (byte)value);
		}

		public void SetDeclareByteValue(int index, byte value)
		{
			switch (index)
			{
			case 0:
				reg0 = value;
				break;
			case 1:
				reg1 = value;
				break;
			case 2:
				reg2 = value;
				break;
			case 3:
				reg3 = value;
				break;
			case 4:
				immediate = (immediate & 0xFFFFFF00u) | value;
				break;
			case 5:
				immediate = (immediate & 0xFFFF00FFu) | (uint)(value << 8);
				break;
			case 6:
				immediate = (immediate & 0xFF00FFFFu) | (uint)(value << 16);
				break;
			case 7:
				immediate = (immediate & 0xFFFFFF) | (uint)(value << 24);
				break;
			case 8:
				memDispl = (memDispl & 0xFFFFFFFFFFFFFF00uL) | value;
				break;
			case 9:
				memDispl = (memDispl & 0xFFFFFFFFFFFF00FFuL) | ((ulong)value << 8);
				break;
			case 10:
				memDispl = (memDispl & 0xFFFFFFFFFF00FFFFuL) | ((ulong)value << 16);
				break;
			case 11:
				memDispl = (memDispl & 0xFFFFFFFF00FFFFFFuL) | ((ulong)value << 24);
				break;
			case 12:
				memDispl = (memDispl & 0xFFFFFF00FFFFFFFFuL) | ((ulong)value << 32);
				break;
			case 13:
				memDispl = (memDispl & 0xFFFF00FFFFFFFFFFuL) | ((ulong)value << 40);
				break;
			case 14:
				memDispl = (memDispl & 0xFF00FFFFFFFFFFFFuL) | ((ulong)value << 48);
				break;
			case 15:
				memDispl = (memDispl & 0xFFFFFFFFFFFFFFL) | ((ulong)value << 56);
				break;
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
				break;
			}
		}

		public readonly byte GetDeclareByteValue(int index)
		{
			switch (index)
			{
			case 0:
				return reg0;
			case 1:
				return reg1;
			case 2:
				return reg2;
			case 3:
				return reg3;
			case 4:
				return (byte)immediate;
			case 5:
				return (byte)(immediate >> 8);
			case 6:
				return (byte)(immediate >> 16);
			case 7:
				return (byte)(immediate >> 24);
			case 8:
				return (byte)memDispl;
			case 9:
				return (byte)((uint)memDispl >> 8);
			case 10:
				return (byte)((uint)memDispl >> 16);
			case 11:
				return (byte)((uint)memDispl >> 24);
			case 12:
				return (byte)(memDispl >> 32);
			case 13:
				return (byte)(memDispl >> 40);
			case 14:
				return (byte)(memDispl >> 48);
			case 15:
				return (byte)(memDispl >> 56);
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
				return 0;
			}
		}

		public void SetDeclareWordValue(int index, short value)
		{
			SetDeclareWordValue(index, (ushort)value);
		}

		public void SetDeclareWordValue(int index, ushort value)
		{
			switch (index)
			{
			case 0:
				reg0 = (byte)value;
				reg1 = (byte)(value >> 8);
				break;
			case 1:
				reg2 = (byte)value;
				reg3 = (byte)(value >> 8);
				break;
			case 2:
				immediate = (immediate & 0xFFFF0000u) | value;
				break;
			case 3:
				immediate = (uint)((ushort)immediate | (value << 16));
				break;
			case 4:
				memDispl = (memDispl & 0xFFFFFFFFFFFF0000uL) | value;
				break;
			case 5:
				memDispl = (memDispl & 0xFFFFFFFF0000FFFFuL) | ((ulong)value << 16);
				break;
			case 6:
				memDispl = (memDispl & 0xFFFF0000FFFFFFFFuL) | ((ulong)value << 32);
				break;
			case 7:
				memDispl = (memDispl & 0xFFFFFFFFFFFFL) | ((ulong)value << 48);
				break;
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
				break;
			}
		}

		public readonly ushort GetDeclareWordValue(int index)
		{
			switch (index)
			{
			case 0:
				return (ushort)(reg0 | (reg1 << 8));
			case 1:
				return (ushort)(reg2 | (reg3 << 8));
			case 2:
				return (ushort)immediate;
			case 3:
				return (ushort)(immediate >> 16);
			case 4:
				return (ushort)memDispl;
			case 5:
				return (ushort)((uint)memDispl >> 16);
			case 6:
				return (ushort)(memDispl >> 32);
			case 7:
				return (ushort)(memDispl >> 48);
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
				return 0;
			}
		}

		public void SetDeclareDwordValue(int index, int value)
		{
			SetDeclareDwordValue(index, (uint)value);
		}

		public void SetDeclareDwordValue(int index, uint value)
		{
			switch (index)
			{
			case 0:
				reg0 = (byte)value;
				reg1 = (byte)(value >> 8);
				reg2 = (byte)(value >> 16);
				reg3 = (byte)(value >> 24);
				break;
			case 1:
				immediate = value;
				break;
			case 2:
				memDispl = (memDispl & 0xFFFFFFFF00000000uL) | value;
				break;
			case 3:
				memDispl = (memDispl & 0xFFFFFFFFu) | ((ulong)value << 32);
				break;
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
				break;
			}
		}

		public readonly uint GetDeclareDwordValue(int index)
		{
			switch (index)
			{
			case 0:
				return (uint)(reg0 | (reg1 << 8) | (reg2 << 16) | (reg3 << 24));
			case 1:
				return immediate;
			case 2:
				return (uint)memDispl;
			case 3:
				return (uint)(memDispl >> 32);
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
				return 0u;
			}
		}

		public void SetDeclareQwordValue(int index, long value)
		{
			SetDeclareQwordValue(index, (ulong)value);
		}

		public void SetDeclareQwordValue(int index, ulong value)
		{
			switch (index)
			{
			case 0:
			{
				uint num = (uint)value;
				reg0 = (byte)num;
				reg1 = (byte)(num >> 8);
				reg2 = (byte)(num >> 16);
				reg3 = (byte)(num >> 24);
				immediate = (uint)(value >> 32);
				break;
			}
			case 1:
				memDispl = value;
				break;
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
				break;
			}
		}

		public readonly ulong GetDeclareQwordValue(int index)
		{
			switch (index)
			{
			case 0:
				return (ulong)reg0 | (ulong)(uint)(reg1 << 8) | (uint)(reg2 << 16) | (uint)(reg3 << 24) | ((ulong)immediate << 32);
			case 1:
				return memDispl;
			default:
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
				return 0uL;
			}
		}

		public readonly bool TryGetVsib64(out bool vsib64)
		{
			switch (Code)
			{
			case Code.VEX_Vpgatherdd_xmm_vm32x_xmm:
			case Code.VEX_Vpgatherdd_ymm_vm32y_ymm:
			case Code.VEX_Vpgatherdq_xmm_vm32x_xmm:
			case Code.VEX_Vpgatherdq_ymm_vm32x_ymm:
			case Code.EVEX_Vpgatherdd_xmm_k1_vm32x:
			case Code.EVEX_Vpgatherdd_ymm_k1_vm32y:
			case Code.EVEX_Vpgatherdd_zmm_k1_vm32z:
			case Code.EVEX_Vpgatherdq_xmm_k1_vm32x:
			case Code.EVEX_Vpgatherdq_ymm_k1_vm32x:
			case Code.EVEX_Vpgatherdq_zmm_k1_vm32y:
			case Code.VEX_Vgatherdps_xmm_vm32x_xmm:
			case Code.VEX_Vgatherdps_ymm_vm32y_ymm:
			case Code.VEX_Vgatherdpd_xmm_vm32x_xmm:
			case Code.VEX_Vgatherdpd_ymm_vm32x_ymm:
			case Code.EVEX_Vgatherdps_xmm_k1_vm32x:
			case Code.EVEX_Vgatherdps_ymm_k1_vm32y:
			case Code.EVEX_Vgatherdps_zmm_k1_vm32z:
			case Code.EVEX_Vgatherdpd_xmm_k1_vm32x:
			case Code.EVEX_Vgatherdpd_ymm_k1_vm32x:
			case Code.EVEX_Vgatherdpd_zmm_k1_vm32y:
			case Code.EVEX_Vpscatterdd_vm32x_k1_xmm:
			case Code.EVEX_Vpscatterdd_vm32y_k1_ymm:
			case Code.EVEX_Vpscatterdd_vm32z_k1_zmm:
			case Code.EVEX_Vpscatterdq_vm32x_k1_xmm:
			case Code.EVEX_Vpscatterdq_vm32x_k1_ymm:
			case Code.EVEX_Vpscatterdq_vm32y_k1_zmm:
			case Code.EVEX_Vscatterdps_vm32x_k1_xmm:
			case Code.EVEX_Vscatterdps_vm32y_k1_ymm:
			case Code.EVEX_Vscatterdps_vm32z_k1_zmm:
			case Code.EVEX_Vscatterdpd_vm32x_k1_xmm:
			case Code.EVEX_Vscatterdpd_vm32x_k1_ymm:
			case Code.EVEX_Vscatterdpd_vm32y_k1_zmm:
			case Code.EVEX_Vgatherpf0dps_vm32z_k1:
			case Code.EVEX_Vgatherpf0dpd_vm32y_k1:
			case Code.EVEX_Vgatherpf1dps_vm32z_k1:
			case Code.EVEX_Vgatherpf1dpd_vm32y_k1:
			case Code.EVEX_Vscatterpf0dps_vm32z_k1:
			case Code.EVEX_Vscatterpf0dpd_vm32y_k1:
			case Code.EVEX_Vscatterpf1dps_vm32z_k1:
			case Code.EVEX_Vscatterpf1dpd_vm32y_k1:
			case Code.MVEX_Vpgatherdd_zmm_k1_mvt:
			case Code.MVEX_Vpgatherdq_zmm_k1_mvt:
			case Code.MVEX_Vgatherdps_zmm_k1_mvt:
			case Code.MVEX_Vgatherdpd_zmm_k1_mvt:
			case Code.MVEX_Vpscatterdd_mvt_k1_zmm:
			case Code.MVEX_Vpscatterdq_mvt_k1_zmm:
			case Code.MVEX_Vscatterdps_mvt_k1_zmm:
			case Code.MVEX_Vscatterdpd_mvt_k1_zmm:
			case Code.MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_B0:
			case Code.MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_B2:
			case Code.MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_C0:
			case Code.MVEX_Vgatherpf0hintdps_mvt_k1:
			case Code.MVEX_Vgatherpf0hintdpd_mvt_k1:
			case Code.MVEX_Vgatherpf0dps_mvt_k1:
			case Code.MVEX_Vgatherpf1dps_mvt_k1:
			case Code.MVEX_Vscatterpf0hintdps_mvt_k1:
			case Code.MVEX_Vscatterpf0hintdpd_mvt_k1:
			case Code.MVEX_Vscatterpf0dps_mvt_k1:
			case Code.MVEX_Vscatterpf1dps_mvt_k1:
				vsib64 = false;
				return true;
			case Code.VEX_Vpgatherqd_xmm_vm64x_xmm:
			case Code.VEX_Vpgatherqd_xmm_vm64y_xmm:
			case Code.VEX_Vpgatherqq_xmm_vm64x_xmm:
			case Code.VEX_Vpgatherqq_ymm_vm64y_ymm:
			case Code.EVEX_Vpgatherqd_xmm_k1_vm64x:
			case Code.EVEX_Vpgatherqd_xmm_k1_vm64y:
			case Code.EVEX_Vpgatherqd_ymm_k1_vm64z:
			case Code.EVEX_Vpgatherqq_xmm_k1_vm64x:
			case Code.EVEX_Vpgatherqq_ymm_k1_vm64y:
			case Code.EVEX_Vpgatherqq_zmm_k1_vm64z:
			case Code.VEX_Vgatherqps_xmm_vm64x_xmm:
			case Code.VEX_Vgatherqps_xmm_vm64y_xmm:
			case Code.VEX_Vgatherqpd_xmm_vm64x_xmm:
			case Code.VEX_Vgatherqpd_ymm_vm64y_ymm:
			case Code.EVEX_Vgatherqps_xmm_k1_vm64x:
			case Code.EVEX_Vgatherqps_xmm_k1_vm64y:
			case Code.EVEX_Vgatherqps_ymm_k1_vm64z:
			case Code.EVEX_Vgatherqpd_xmm_k1_vm64x:
			case Code.EVEX_Vgatherqpd_ymm_k1_vm64y:
			case Code.EVEX_Vgatherqpd_zmm_k1_vm64z:
			case Code.EVEX_Vpscatterqd_vm64x_k1_xmm:
			case Code.EVEX_Vpscatterqd_vm64y_k1_xmm:
			case Code.EVEX_Vpscatterqd_vm64z_k1_ymm:
			case Code.EVEX_Vpscatterqq_vm64x_k1_xmm:
			case Code.EVEX_Vpscatterqq_vm64y_k1_ymm:
			case Code.EVEX_Vpscatterqq_vm64z_k1_zmm:
			case Code.EVEX_Vscatterqps_vm64x_k1_xmm:
			case Code.EVEX_Vscatterqps_vm64y_k1_xmm:
			case Code.EVEX_Vscatterqps_vm64z_k1_ymm:
			case Code.EVEX_Vscatterqpd_vm64x_k1_xmm:
			case Code.EVEX_Vscatterqpd_vm64y_k1_ymm:
			case Code.EVEX_Vscatterqpd_vm64z_k1_zmm:
			case Code.EVEX_Vgatherpf0qps_vm64z_k1:
			case Code.EVEX_Vgatherpf0qpd_vm64z_k1:
			case Code.EVEX_Vgatherpf1qps_vm64z_k1:
			case Code.EVEX_Vgatherpf1qpd_vm64z_k1:
			case Code.EVEX_Vscatterpf0qps_vm64z_k1:
			case Code.EVEX_Vscatterpf0qpd_vm64z_k1:
			case Code.EVEX_Vscatterpf1qps_vm64z_k1:
			case Code.EVEX_Vscatterpf1qpd_vm64z_k1:
				vsib64 = true;
				return true;
			default:
				vsib64 = false;
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void InternalSetSuppressAllExceptions()
		{
			flags1 |= 134217728u;
		}

		public override readonly string ToString()
		{
			return base.ToString() ?? string.Empty;
		}

		public readonly ulong GetVirtualAddress(int operand, int elementIndex, VAGetRegisterValue getRegisterValue)
		{
			if (getRegisterValue == null)
			{
				throw new ArgumentNullException("getRegisterValue");
			}
			VARegisterValueProviderDelegateImpl registerValueProvider = new VARegisterValueProviderDelegateImpl(getRegisterValue);
			if (TryGetVirtualAddress(operand, elementIndex, registerValueProvider, out var result))
			{
				return result;
			}
			return 0uL;
		}

		public readonly ulong GetVirtualAddress(int operand, int elementIndex, IVARegisterValueProvider registerValueProvider)
		{
			if (registerValueProvider == null)
			{
				throw new ArgumentNullException("registerValueProvider");
			}
			VARegisterValueProviderAdapter registerValueProvider2 = new VARegisterValueProviderAdapter(registerValueProvider);
			if (TryGetVirtualAddress(operand, elementIndex, registerValueProvider2, out var result))
			{
				return result;
			}
			return 0uL;
		}

		public readonly bool TryGetVirtualAddress(int operand, int elementIndex, out ulong result, VATryGetRegisterValue getRegisterValue)
		{
			if (getRegisterValue == null)
			{
				throw new ArgumentNullException("getRegisterValue");
			}
			VATryGetRegisterValueDelegateImpl registerValueProvider = new VATryGetRegisterValueDelegateImpl(getRegisterValue);
			return TryGetVirtualAddress(operand, elementIndex, registerValueProvider, out result);
		}

		public readonly bool TryGetVirtualAddress(int operand, int elementIndex, IVATryGetRegisterValueProvider registerValueProvider, out ulong result)
		{
			if (registerValueProvider == null)
			{
				throw new ArgumentNullException("registerValueProvider");
			}
			ulong value2;
			ulong value;
			switch (GetOpKind(operand))
			{
			case OpKind.Register:
			case OpKind.NearBranch16:
			case OpKind.NearBranch32:
			case OpKind.NearBranch64:
			case OpKind.FarBranch16:
			case OpKind.FarBranch32:
			case OpKind.Immediate8:
			case OpKind.Immediate8_2nd:
			case OpKind.Immediate16:
			case OpKind.Immediate32:
			case OpKind.Immediate64:
			case OpKind.Immediate8to16:
			case OpKind.Immediate8to32:
			case OpKind.Immediate8to64:
			case OpKind.Immediate32to64:
				result = 0uL;
				return true;
			case OpKind.MemorySegSI:
				if (registerValueProvider.TryGetRegisterValue(MemorySegment, 0, 0, out value2) && registerValueProvider.TryGetRegisterValue(Register.SI, 0, 0, out value))
				{
					result = value2 + (ushort)value;
					return true;
				}
				break;
			case OpKind.MemorySegESI:
				if (registerValueProvider.TryGetRegisterValue(MemorySegment, 0, 0, out value2) && registerValueProvider.TryGetRegisterValue(Register.ESI, 0, 0, out value))
				{
					result = value2 + (uint)value;
					return true;
				}
				break;
			case OpKind.MemorySegRSI:
				if (registerValueProvider.TryGetRegisterValue(MemorySegment, 0, 0, out value2) && registerValueProvider.TryGetRegisterValue(Register.RSI, 0, 0, out value))
				{
					result = value2 + value;
					return true;
				}
				break;
			case OpKind.MemorySegDI:
				if (registerValueProvider.TryGetRegisterValue(MemorySegment, 0, 0, out value2) && registerValueProvider.TryGetRegisterValue(Register.DI, 0, 0, out value))
				{
					result = value2 + (ushort)value;
					return true;
				}
				break;
			case OpKind.MemorySegEDI:
				if (registerValueProvider.TryGetRegisterValue(MemorySegment, 0, 0, out value2) && registerValueProvider.TryGetRegisterValue(Register.EDI, 0, 0, out value))
				{
					result = value2 + (uint)value;
					return true;
				}
				break;
			case OpKind.MemorySegRDI:
				if (registerValueProvider.TryGetRegisterValue(MemorySegment, 0, 0, out value2) && registerValueProvider.TryGetRegisterValue(Register.RDI, 0, 0, out value))
				{
					result = value2 + value;
					return true;
				}
				break;
			case OpKind.MemoryESDI:
				if (registerValueProvider.TryGetRegisterValue(Register.ES, 0, 0, out value2) && registerValueProvider.TryGetRegisterValue(Register.DI, 0, 0, out value))
				{
					result = value2 + (ushort)value;
					return true;
				}
				break;
			case OpKind.MemoryESEDI:
				if (registerValueProvider.TryGetRegisterValue(Register.ES, 0, 0, out value2) && registerValueProvider.TryGetRegisterValue(Register.EDI, 0, 0, out value))
				{
					result = value2 + (uint)value;
					return true;
				}
				break;
			case OpKind.MemoryESRDI:
				if (registerValueProvider.TryGetRegisterValue(Register.ES, 0, 0, out value2) && registerValueProvider.TryGetRegisterValue(Register.RDI, 0, 0, out value))
				{
					result = value2 + value;
					return true;
				}
				break;
			case OpKind.Memory:
			{
				Register memoryBase = MemoryBase;
				Register memoryIndex = MemoryIndex;
				int addressSizeInBytes = InstructionUtils.GetAddressSizeInBytes(memoryBase, memoryIndex, MemoryDisplSize, CodeSize);
				ulong num = MemoryDisplacement64;
				ulong num2 = addressSizeInBytes switch
				{
					8 => ulong.MaxValue, 
					4 => 4294967295uL, 
					_ => 65535uL, 
				};
				if (memoryBase != Register.None && memoryBase != Register.RIP && memoryBase != Register.EIP)
				{
					if (!registerValueProvider.TryGetRegisterValue(memoryBase, 0, 0, out value))
					{
						break;
					}
					num += value;
				}
				Code code = Code;
				if (memoryIndex != Register.None && !code.IgnoresIndex() && !code.IsTileStrideIndex())
				{
					if (TryGetVsib64(out var vsib))
					{
						bool flag;
						if (vsib)
						{
							flag = registerValueProvider.TryGetRegisterValue(memoryIndex, elementIndex, 8, out value);
						}
						else
						{
							flag = registerValueProvider.TryGetRegisterValue(memoryIndex, elementIndex, 4, out value);
							value = (ulong)(int)value;
						}
						if (!flag)
						{
							break;
						}
						num += value << InternalMemoryIndexScale;
					}
					else
					{
						if (!registerValueProvider.TryGetRegisterValue(memoryIndex, 0, 0, out value))
						{
							break;
						}
						num += value << InternalMemoryIndexScale;
					}
				}
				num &= num2;
				if (!code.IgnoresSegment())
				{
					if (!registerValueProvider.TryGetRegisterValue(MemorySegment, 0, 0, out value2))
					{
						break;
					}
					num += value2;
				}
				result = num;
				return true;
			}
			default:
				throw new InvalidOperationException();
			}
			result = 0uL;
			return false;
		}
	}
	public delegate ulong VAGetRegisterValue(Register register, int elementIndex, int elementSize);
	public interface IVARegisterValueProvider
	{
		ulong GetRegisterValue(Register register, int elementIndex, int elementSize);
	}
	public delegate bool VATryGetRegisterValue(Register register, int elementIndex, int elementSize, out ulong value);
	public interface IVATryGetRegisterValueProvider
	{
		bool TryGetRegisterValue(Register register, int elementIndex, int elementSize, out ulong value);
	}
	internal sealed class VARegisterValueProviderDelegateImpl : IVATryGetRegisterValueProvider
	{
		private readonly VAGetRegisterValue getRegisterValue;

		public VARegisterValueProviderDelegateImpl(VAGetRegisterValue getRegisterValue)
		{
			this.getRegisterValue = getRegisterValue ?? throw new ArgumentNullException("getRegisterValue");
		}

		public bool TryGetRegisterValue(Register register, int elementIndex, int elementSize, out ulong value)
		{
			value = getRegisterValue(register, elementIndex, elementSize);
			return true;
		}
	}
	internal sealed class VARegisterValueProviderAdapter : IVATryGetRegisterValueProvider
	{
		private readonly IVARegisterValueProvider provider;

		public VARegisterValueProviderAdapter(IVARegisterValueProvider provider)
		{
			this.provider = provider;
		}

		public bool TryGetRegisterValue(Register register, int elementIndex, int elementSize, out ulong value)
		{
			value = provider.GetRegisterValue(register, elementIndex, elementSize);
			return true;
		}
	}
	internal sealed class VATryGetRegisterValueDelegateImpl : IVATryGetRegisterValueProvider
	{
		private readonly VATryGetRegisterValue getRegisterValue;

		public VATryGetRegisterValueDelegateImpl(VATryGetRegisterValue getRegisterValue)
		{
			this.getRegisterValue = getRegisterValue;
		}

		public bool TryGetRegisterValue(Register register, int elementIndex, int elementSize, out ulong value)
		{
			return getRegisterValue(register, elementIndex, elementSize, out value);
		}
	}
	public static class InstructionInfoExtensions
	{
		public static Code NegateConditionCode(this Code code)
		{
			uint num;
			if ((num = (uint)(code - 1854)) <= 47 || (num = (uint)(code - 159)) <= 47 || (num = (uint)(code - 1169)) <= 47)
			{
				if (((num / 3) & 1) != 0)
				{
					return code - 3;
				}
				return code + 3;
			}
			num = (uint)(code - 1902);
			if (num <= 15)
			{
				return (Code)((num ^ 1) + 1902);
			}
			num = (uint)(code - 657);
			if (num <= 13)
			{
				return (Code)(657 + (num + 7) % 14);
			}
			if ((num = (uint)(code - 4879)) <= 31)
			{
				if ((num & 2) != 0)
				{
					return code - 2;
				}
				return code + 2;
			}
			return code;
		}

		public static Code ToShortBranch(this Code code)
		{
			uint num = (uint)(code - 1854);
			if (num <= 47)
			{
				return (Code)(num + 159);
			}
			num = (uint)(code - 694);
			if (num <= 2)
			{
				return (Code)(num + 699);
			}
			return code;
		}

		public static Code ToNearBranch(this Code code)
		{
			uint num = (uint)(code - 159);
			if (num <= 47)
			{
				return (Code)(num + 1854);
			}
			num = (uint)(code - 699);
			if (num <= 2)
			{
				return (Code)(num + 694);
			}
			return code;
		}
	}
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(InstructionListDebugView))]
	[EditorBrowsable(EditorBrowsableState.Never)]
	public sealed class InstructionList : IList<Instruction>, ICollection<Instruction>, IEnumerable<Instruction>, IEnumerable, IReadOnlyList<Instruction>, IReadOnlyCollection<Instruction>, IList, ICollection
	{
		public struct Enumerator : IEnumerator<Instruction>, IEnumerator, IDisposable
		{
			private readonly InstructionList list;

			private int index;

			public ref Instruction Current => ref list.elements[index];

			Instruction IEnumerator<Instruction>.Current => list.elements[index];

			object IEnumerator.Current => list.elements[index];

			internal Enumerator(InstructionList list)
			{
				this.list = list;
				index = -1;
			}

			public bool MoveNext()
			{
				index++;
				return index < list.count;
			}

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

			public void Dispose()
			{
			}
		}

		private Instruction[] elements;

		private int count;

		public int Count => count;

		int ICollection<Instruction>.Count => count;

		int ICollection.Count => count;

		int IReadOnlyCollection<Instruction>.Count => count;

		public int Capacity => elements.Length;

		bool ICollection<Instruction>.IsReadOnly => false;

		bool IList.IsReadOnly => false;

		bool IList.IsFixedSize => false;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => this;

		public ref Instruction this[int index] => ref elements[index];

		Instruction IList<Instruction>.this[int index]
		{
			get
			{
				return elements[index];
			}
			set
			{
				elements[index] = value;
			}
		}

		Instruction IReadOnlyList<Instruction>.this[int index] => elements[index];

		object? IList.this[int index]
		{
			get
			{
				return elements[index];
			}
			set
			{
				if (value == null)
				{
					ThrowHelper.ThrowArgumentNullException_value();
				}
				if (!(value is Instruction))
				{
					ThrowHelper.ThrowArgumentException();
				}
				elements[index] = (Instruction)value;
			}
		}

		public InstructionList()
		{
			elements = Array2.Empty<Instruction>();
		}

		public InstructionList(int capacity)
		{
			if (capacity < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_capacity();
			}
			elements = ((capacity == 0) ? Array2.Empty<Instruction>() : new Instruction[capacity]);
		}

		public InstructionList(InstructionList list)
		{
			if (list == null)
			{
				ThrowHelper.ThrowArgumentNullException_list();
			}
			int num = list.count;
			if (num == 0)
			{
				elements = Array2.Empty<Instruction>();
				return;
			}
			Instruction[] destinationArray = (elements = new Instruction[num]);
			count = num;
			Array.Copy(list.elements, 0, destinationArray, 0, num);
		}

		public InstructionList(IEnumerable<Instruction> collection)
		{
			if (collection == null)
			{
				ThrowHelper.ThrowArgumentNullException_collection();
			}
			if (collection is ICollection<Instruction> { Count: var num } collection2)
			{
				if (num == 0)
				{
					elements = Array2.Empty<Instruction>();
					return;
				}
				collection2.CopyTo(elements = new Instruction[num], 0);
				count = num;
				return;
			}
			elements = Array2.Empty<Instruction>();
			foreach (Instruction item in collection)
			{
				Add(item);
			}
		}

		private void SetMinCapacity(int minCapacity)
		{
			Instruction[] array = elements;
			uint num = (uint)array.Length;
			if (minCapacity > (int)num)
			{
				uint num2 = num * 2;
				if (num2 < 4)
				{
					num2 = 4u;
				}
				if (num2 < (uint)minCapacity)
				{
					num2 = (uint)minCapacity;
				}
				if (num2 > 2146435071)
				{
					num2 = 2146435071u;
				}
				Instruction[] destinationArray = new Instruction[num2];
				Array.Copy(array, 0, destinationArray, 0, count);
				elements = destinationArray;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref Instruction AllocUninitializedElement()
		{
			int num = count;
			Instruction[] array = elements;
			if (num == array.Length)
			{
				SetMinCapacity(num + 1);
				array = elements;
			}
			count = num + 1;
			return ref array[num];
		}

		private void MakeRoom(int index, int extraLength)
		{
			SetMinCapacity(count + extraLength);
			int num = count - index;
			if (num != 0)
			{
				Instruction[] array = elements;
				Array.Copy(array, index, array, index + extraLength, num);
			}
		}

		public void Insert(int index, in Instruction instruction)
		{
			int num = count;
			if ((uint)index > (uint)num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			MakeRoom(index, 1);
			elements[index] = instruction;
			count = num + 1;
		}

		void IList<Instruction>.Insert(int index, Instruction instruction)
		{
			Insert(index, in instruction);
		}

		void IList.Insert(int index, object value)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException_value();
			}
			if (!(value is Instruction))
			{
				ThrowHelper.ThrowArgumentException();
			}
			Insert(index, (Instruction)value);
		}

		public void RemoveAt(int index)
		{
			int num = count;
			if ((uint)index >= (uint)num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			int num2 = (count = num - 1) - index;
			if (num2 != 0)
			{
				Instruction[] array = elements;
				Array.Copy(array, index + 1, array, index, num2);
			}
		}

		void IList<Instruction>.RemoveAt(int index)
		{
			RemoveAt(index);
		}

		void IList.RemoveAt(int index)
		{
			RemoveAt(index);
		}

		public void AddRange(IEnumerable<Instruction> collection)
		{
			InsertRange(count, collection);
		}

		public void InsertRange(int index, IEnumerable<Instruction> collection)
		{
			if ((uint)index > (uint)count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			if (collection == null)
			{
				ThrowHelper.ThrowArgumentNullException_collection();
			}
			if (collection is InstructionList { count: var num } instructionList)
			{
				if (num != 0)
				{
					MakeRoom(index, num);
					count += num;
					Array.Copy(instructionList.elements, 0, elements, index, num);
				}
				return;
			}
			if (collection is IList<Instruction> { Count: var num2 } list)
			{
				if (num2 != 0)
				{
					MakeRoom(index, num2);
					count += num2;
					Instruction[] array = elements;
					for (int i = 0; i < num2; i++)
					{
						array[index + i] = list[i];
					}
				}
				return;
			}
			if (collection is IReadOnlyList<Instruction> { Count: var num3 } readOnlyList)
			{
				if (num3 != 0)
				{
					MakeRoom(index, num3);
					count += num3;
					Instruction[] array2 = elements;
					for (int j = 0; j < num3; j++)
					{
						array2[index + j] = readOnlyList[j];
					}
				}
				return;
			}
			foreach (Instruction item in collection)
			{
				Instruction instruction = item;
				Insert(index++, in instruction);
			}
		}

		public void RemoveRange(int index, int count)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_count();
			}
			if ((uint)(index + count) > (uint)this.count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_count();
			}
			int num = this.count;
			int num2 = (this.count = num - count) - index;
			if (num2 != 0)
			{
				Instruction[] array = elements;
				Array.Copy(array, index + count, array, index, num2);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Add(in Instruction instruction)
		{
			int num = count;
			Instruction[] array = elements;
			if (num == array.Length)
			{
				SetMinCapacity(num + 1);
				array = elements;
			}
			array[num] = instruction;
			count = num + 1;
		}

		void ICollection<Instruction>.Add(Instruction instruction)
		{
			Add(in instruction);
		}

		int IList.Add(object value)
		{
			if (value == null)
			{
				ThrowHelper.ThrowArgumentNullException_value();
			}
			if (!(value is Instruction))
			{
				ThrowHelper.ThrowArgumentException();
			}
			Add((Instruction)value);
			return count - 1;
		}

		public void Clear()
		{
			count = 0;
		}

		void ICollection<Instruction>.Clear()
		{
			Clear();
		}

		void IList.Clear()
		{
			Clear();
		}

		public bool Contains(in Instruction instruction)
		{
			return IndexOf(in instruction) >= 0;
		}

		bool ICollection<Instruction>.Contains(Instruction instruction)
		{
			return Contains(in instruction);
		}

		bool IList.Contains(object value)
		{
			if (value is Instruction instruction)
			{
				return Contains(in instruction);
			}
			return false;
		}

		public int IndexOf(in Instruction instruction)
		{
			Instruction[] array = elements;
			int num = count;
			for (int i = 0; i < num; i++)
			{
				if (array[i] == instruction)
				{
					return i;
				}
			}
			return -1;
		}

		int IList<Instruction>.IndexOf(Instruction instruction)
		{
			return IndexOf(in instruction);
		}

		int IList.IndexOf(object value)
		{
			if (value is Instruction instruction)
			{
				return IndexOf(in instruction);
			}
			return -1;
		}

		public int IndexOf(in Instruction instruction, int index)
		{
			int num = count;
			if ((uint)index > (uint)num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			Instruction[] array = elements;
			for (int i = index; i < num; i++)
			{
				if (array[i] == instruction)
				{
					return i;
				}
			}
			return -1;
		}

		public int IndexOf(in Instruction instruction, int index, int count)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_count();
			}
			int num = index + count;
			if ((uint)num > (uint)this.count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_count();
			}
			Instruction[] array = elements;
			for (int i = index; i < num; i++)
			{
				if (array[i] == instruction)
				{
					return i;
				}
			}
			return -1;
		}

		public int LastIndexOf(in Instruction instruction)
		{
			for (int num = count - 1; num >= 0; num--)
			{
				if (elements[num] == instruction)
				{
					return num;
				}
			}
			return -1;
		}

		public int LastIndexOf(in Instruction instruction, int index)
		{
			int num = count;
			if ((uint)index > (uint)num)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			Instruction[] array = elements;
			for (int num2 = num - 1; num2 >= index; num2--)
			{
				if (array[num2] == instruction)
				{
					return num2;
				}
			}
			return -1;
		}

		public int LastIndexOf(in Instruction instruction, int index, int count)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_count();
			}
			int num = index + count;
			if ((uint)num > (uint)this.count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_count();
			}
			Instruction[] array = elements;
			for (int num2 = num - 1; num2 >= index; num2--)
			{
				if (array[num2] == instruction)
				{
					return num2;
				}
			}
			return -1;
		}

		public bool Remove(in Instruction instruction)
		{
			int num = IndexOf(in instruction);
			if (num >= 0)
			{
				RemoveAt(num);
			}
			return num >= 0;
		}

		bool ICollection<Instruction>.Remove(Instruction instruction)
		{
			return Remove(in instruction);
		}

		void IList.Remove(object value)
		{
			if (value is Instruction instruction)
			{
				Remove(in instruction);
			}
		}

		public void CopyTo(Instruction[] array)
		{
			CopyTo(array, 0);
		}

		public void CopyTo(Instruction[] array, int arrayIndex)
		{
			Array.Copy(elements, 0, array, arrayIndex, count);
		}

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

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException_array();
			}
			else if (array is Instruction[] array2)
			{
				CopyTo(array2, index);
			}
			else
			{
				ThrowHelper.ThrowArgumentException();
			}
		}

		public void CopyTo(int index, Instruction[] array, int arrayIndex, int count)
		{
			Array.Copy(elements, index, array, arrayIndex, count);
		}

		public InstructionList GetRange(int index, int count)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			if (count < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_count();
			}
			if ((uint)(index + count) > (uint)this.count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_count();
			}
			InstructionList instructionList = new InstructionList(count);
			Array.Copy(elements, index, instructionList.elements, 0, count);
			instructionList.count = count;
			return instructionList;
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator<Instruction> IEnumerable<Instruction>.GetEnumerator()
		{
			return new Enumerator(this);
		}

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

		public ReadOnlyCollection<Instruction> AsReadOnly()
		{
			return new ReadOnlyCollection<Instruction>(this);
		}

		public Instruction[] ToArray()
		{
			int num = count;
			if (num == 0)
			{
				return Array2.Empty<Instruction>();
			}
			Instruction[] array = new Instruction[num];
			Array.Copy(elements, 0, array, 0, array.Length);
			return array;
		}
	}
	internal sealed class InstructionListDebugView
	{
		private readonly InstructionList list;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public Instruction[] Items => list.ToArray();

		public InstructionListDebugView(InstructionList list)
		{
			this.list = list ?? throw new ArgumentNullException("list");
		}
	}
	internal static class InstructionMemorySizes
	{
		internal static ReadOnlySpan<byte> SizesNormal => new byte[4936]
		{
			0, 0, 0, 0, 0, 1, 2, 3, 5, 1,
			2, 3, 5, 0, 0, 0, 0, 0, 0, 0,
			0, 1, 2, 3, 5, 1, 2, 3, 5, 0,
			0, 0, 0, 0, 0, 0, 1, 2, 3, 5,
			1, 2, 3, 5, 0, 0, 0, 0, 0, 0,
			0, 0, 1, 2, 3, 5, 1, 2, 3, 5,
			0, 0, 0, 0, 0, 0, 0, 0, 1, 2,
			3, 5, 1, 2, 3, 5, 0, 0, 0, 0,
			0, 1, 2, 3, 5, 1, 2, 3, 5, 0,
			0, 0, 0, 0, 1, 2, 3, 5, 1, 2,
			3, 5, 0, 0, 0, 0, 0, 1, 2, 3,
			5, 1, 2, 3, 5, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 22, 23, 2, 2, 10, 11,
			11, 0, 0, 0, 10, 11, 12, 0, 0, 0,
			10, 11, 12, 1, 2, 3, 1, 2, 3, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
			1, 1, 1, 1, 1, 2, 3, 5, 2, 3,
			5, 2, 3, 5, 2, 3, 5, 2, 3, 5,
			2, 3, 5, 2, 3, 5, 2, 3, 5, 1,
			1, 1, 1, 1, 1, 1, 1, 2, 3, 5,
			2, 3, 5, 2, 3, 5, 2, 3, 5, 2,
			3, 5, 2, 3, 5, 2, 3, 5, 2, 3,
			5, 1, 2, 3, 5, 1, 2, 3, 5, 1,
			2, 3, 5, 1, 2, 3, 5, 2, 2, 2,
			0, 0, 0, 2, 2, 2, 2, 3, 5, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 1, 2, 3, 5, 1, 2, 3,
			5, 1, 2, 3, 5, 1, 2, 3, 5, 0,
			0, 0, 0, 1, 2, 3, 5, 1, 2, 3,
			5, 1, 2, 3, 5, 0, 0, 0, 0, 1,
			1, 1, 1, 1, 1, 1, 9, 2, 3, 5,
			2, 3, 5, 2, 3, 5, 2, 3, 5, 2,
			3, 5, 2, 3, 5, 2, 3, 5, 10, 11,
			12, 0, 0, 0, 0, 0, 0, 16, 17, 16,
			17, 1, 0, 2, 3, 5, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
			1, 1, 1, 9, 2, 3, 5, 2, 3, 5,
			2, 3, 5, 2, 3, 5, 2, 3, 5, 2,
			3, 5, 2, 3, 5, 10, 11, 12, 1, 1,
			1, 1, 1, 1, 1, 9, 2, 3, 5, 2,
			3, 5, 2, 3, 5, 2, 3, 5, 2, 3,
			5, 2, 3, 5, 2, 3, 5, 10, 11, 12,
			0, 0, 0, 1, 29, 29, 29, 29, 29, 29,
			29, 29, 0, 0, 0, 0, 0, 0, 0, 0,
			29, 29, 29, 34, 35, 2, 34, 34, 35, 35,
			2, 2, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 11, 11, 11, 11, 11, 11, 11,
			11, 0, 0, 0, 0, 0, 11, 11, 11, 11,
			31, 31, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 30,
			30, 30, 30, 30, 30, 30, 30, 0, 0, 0,
			0, 0, 0, 0, 0, 30, 12, 30, 30, 36,
			37, 36, 36, 37, 37, 2, 2, 0, 0, 0,
			0, 0, 0, 10, 10, 10, 10, 10, 10, 10,
			10, 0, 0, 0, 0, 0, 0, 0, 0, 10,
			10, 10, 10, 42, 12, 42, 12, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 1, 1, 1, 9, 1, 9, 1, 9, 2,
			3, 5, 2, 3, 5, 2, 3, 5, 10, 11,
			12, 2, 3, 5, 10, 11, 12, 2, 3, 5,
			10, 11, 12, 0, 0, 0, 0, 0, 0, 1,
			1, 2, 3, 5, 2, 3, 5, 19, 20, 21,
			16, 17, 18, 19, 20, 21, 16, 17, 18, 2,
			3, 5, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			19, 20, 26, 26, 27, 26, 26, 27, 26, 26,
			27, 26, 26, 27, 2, 2, 2, 5, 2, 2,
			2, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 2, 2, 2, 2, 2, 2, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			2, 3, 5, 1, 1, 1, 0, 1, 2, 3,
			1, 2, 3, 74, 74, 91, 74, 91, 108, 75,
			75, 92, 75, 92, 109, 29, 0, 29, 0, 29,
			30, 0, 30, 0, 30, 74, 74, 91, 74, 91,
			108, 75, 75, 92, 75, 92, 109, 29, 0, 29,
			0, 29, 30, 0, 30, 0, 30, 0, 63, 0,
			63, 0, 63, 30, 30, 30, 74, 74, 91, 74,
			91, 108, 30, 30, 92, 30, 92, 109, 63, 63,
			63, 30, 30, 30, 74, 74, 91, 74, 91, 108,
			75, 75, 92, 75, 92, 109, 74, 74, 91, 74,
			91, 108, 75, 75, 92, 75, 92, 109, 0, 0,
			0, 63, 63, 63, 30, 30, 30, 74, 74, 91,
			74, 91, 108, 63, 63, 63, 30, 30, 30, 2,
			3, 5, 2, 3, 5, 2, 3, 5, 2, 3,
			5, 2, 3, 5, 2, 3, 5, 2, 3, 5,
			2, 3, 5, 1, 1, 1, 1, 0, 24, 25,
			3, 5, 3, 5, 0, 24, 25, 3, 5, 3,
			5, 1, 0, 0, 0, 0, 2, 3, 5, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 74,
			74, 91, 74, 91, 108, 75, 75, 92, 75, 92,
			109, 74, 74, 91, 74, 91, 108, 75, 75, 92,
			75, 92, 109, 61, 61, 11, 12, 11, 12, 11,
			12, 11, 12, 11, 12, 11, 12, 74, 74, 91,
			74, 91, 108, 75, 75, 92, 75, 92, 109, 29,
			30, 63, 75, 29, 29, 29, 29, 29, 29, 30,
			30, 30, 30, 30, 30, 63, 75, 29, 29, 29,
			29, 29, 29, 30, 30, 30, 30, 30, 30, 29,
			29, 29, 30, 30, 30, 29, 30, 29, 30, 29,
			30, 0, 0, 0, 0, 0, 0, 0, 0, 2,
			3, 5, 2, 3, 5, 2, 3, 5, 2, 3,
			5, 2, 3, 5, 2, 3, 5, 2, 3, 5,
			2, 3, 5, 2, 3, 5, 2, 3, 5, 2,
			3, 5, 2, 3, 5, 2, 3, 5, 2, 3,
			5, 2, 3, 5, 2, 3, 5, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			74, 74, 91, 74, 91, 108, 75, 75, 92, 75,
			92, 109, 29, 29, 29, 30, 30, 30, 74, 74,
			91, 29, 29, 74, 74, 91, 29, 29, 74, 74,
			91, 74, 91, 108, 75, 75, 92, 75, 92, 109,
			74, 74, 91, 74, 91, 108, 75, 75, 92, 75,
			92, 109, 74, 74, 91, 74, 91, 108, 75, 75,
			92, 75, 92, 109, 74, 74, 91, 74, 91, 108,
			75, 75, 92, 75, 92, 109, 74, 74, 91, 74,
			91, 108, 75, 75, 92, 75, 92, 109, 29, 29,
			29, 30, 30, 30, 74, 74, 91, 74, 91, 108,
			75, 75, 92, 75, 92, 109, 29, 29, 29, 30,
			30, 30, 63, 63, 74, 63, 74, 91, 75, 75,
			92, 75, 92, 109, 29, 29, 29, 30, 30, 30,
			69, 69, 84, 69, 84, 102, 72, 87, 105, 74,
			74, 91, 74, 91, 108, 74, 74, 91, 74, 91,
			108, 74, 74, 91, 74, 91, 108, 75, 75, 92,
			75, 92, 109, 29, 29, 29, 30, 30, 30, 74,
			74, 91, 74, 91, 108, 75, 75, 92, 75, 92,
			109, 29, 29, 29, 30, 30, 30, 74, 74, 91,
			74, 91, 108, 75, 75, 92, 75, 92, 109, 29,
			29, 29, 30, 30, 30, 74, 74, 91, 74, 91,
			108, 75, 75, 92, 75, 92, 109, 29, 29, 29,
			30, 30, 30, 50, 64, 64, 79, 64, 79, 97,
			52, 66, 66, 81, 66, 81, 99, 11, 68, 68,
			83, 68, 83, 101, 59, 67, 67, 82, 67, 82,
			100, 57, 65, 65, 80, 65, 80, 98, 59, 67,
			67, 82, 67, 82, 100, 61, 69, 69, 84, 69,
			84, 102, 59, 67, 67, 82, 67, 82, 100, 56,
			64, 64, 79, 64, 79, 97, 58, 66, 66, 81,
			66, 81, 99, 60, 68, 68, 83, 68, 83, 101,
			61, 69, 69, 84, 69, 84, 102, 71, 71, 86,
			71, 86, 104, 71, 71, 86, 71, 86, 104, 3,
			5, 3, 5, 3, 5, 3, 5, 5, 68, 68,
			83, 68, 83, 101, 71, 86, 104, 68, 68, 83,
			68, 83, 101, 71, 86, 104, 64, 79, 97, 66,
			81, 99, 58, 68, 68, 83, 68, 83, 101, 66,
			66, 81, 66, 81, 99, 66, 66, 81, 66, 81,
			99, 0, 0, 0, 0, 66, 81, 99, 0, 0,
			0, 0, 67, 82, 100, 0, 0, 0, 0, 66,
			81, 99, 68, 83, 101, 71, 86, 104, 68, 83,
			101, 71, 86, 104, 0, 0, 0, 0, 68, 83,
			101, 0, 0, 0, 0, 69, 84, 102, 72, 87,
			105, 0, 0, 0, 0, 68, 83, 101, 0, 0,
			0, 0, 71, 86, 104, 0, 0, 0, 6, 88,
			106, 0, 0, 0, 0, 71, 86, 104, 0, 0,
			0, 6, 88, 106, 56, 64, 64, 79, 64, 79,
			97, 58, 66, 66, 81, 66, 81, 99, 60, 68,
			68, 83, 68, 83, 101, 0, 0, 0, 3, 5,
			74, 91, 108, 75, 92, 109, 0, 63, 74, 91,
			75, 92, 109, 29, 29, 0, 30, 30, 3, 5,
			74, 91, 108, 75, 92, 109, 0, 63, 74, 91,
			75, 92, 109, 29, 29, 0, 30, 30, 63, 74,
			91, 75, 92, 109, 60, 68, 83, 71, 86, 104,
			68, 83, 101, 71, 86, 104, 63, 74, 91, 75,
			92, 109, 3, 5, 3, 5, 75, 75, 92, 74,
			74, 91, 75, 75, 92, 74, 74, 91, 3, 5,
			3, 5, 3, 5, 3, 5, 5, 5, 5, 5,
			68, 68, 83, 68, 83, 101, 71, 86, 104, 68,
			68, 83, 68, 83, 101, 71, 86, 104, 64, 79,
			97, 66, 81, 99, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 2, 5,
			1, 3, 2, 5, 1, 3, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
			3, 5, 2, 3, 5, 2, 3, 5, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 2, 3, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 2, 3, 1,
			2, 3, 0, 0, 0, 0, 0, 0, 0, 2,
			3, 5, 2, 3, 5, 2, 3, 5, 38, 39,
			0, 0, 38, 39, 0, 0, 3, 0, 0, 3,
			3, 0, 0, 3, 40, 41, 3, 5, 40, 41,
			0, 0, 40, 41, 1, 0, 0, 5, 0, 0,
			0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			10, 11, 12, 1, 2, 3, 5, 16, 17, 18,
			2, 3, 5, 16, 17, 18, 16, 17, 18, 1,
			1, 1, 2, 2, 2, 0, 0, 2, 3, 5,
			2, 3, 5, 2, 3, 5, 2, 3, 5, 2,
			3, 5, 2, 3, 5, 2, 3, 5, 2, 3,
			5, 2, 3, 5, 2, 3, 5, 2, 3, 5,
			9, 9, 9, 10, 10, 10, 1, 2, 3, 5,
			74, 74, 91, 74, 91, 108, 75, 75, 92, 75,
			92, 109, 29, 29, 29, 30, 30, 30, 3, 5,
			2, 2, 2, 2, 2, 2, 2, 2, 0, 0,
			0, 0, 0, 0, 0, 0, 74, 74, 91, 74,
			91, 108, 75, 75, 92, 75, 92, 109, 5, 6,
			40, 41, 40, 41, 40, 41, 5, 5, 5, 0,
			0, 0, 5, 0, 0, 0, 0, 0, 0, 0,
			0, 75, 75, 92, 74, 74, 91, 58, 66, 66,
			66, 66, 66, 66, 60, 68, 68, 68, 68, 68,
			68, 5, 71, 71, 71, 71, 71, 71, 5, 71,
			71, 86, 71, 86, 104, 59, 67, 67, 82, 67,
			82, 100, 5, 5, 5, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 56, 64, 64, 79, 64,
			79, 97, 58, 66, 66, 81, 66, 81, 99, 56,
			64, 64, 79, 64, 79, 97, 5, 6, 6, 88,
			68, 83, 101, 71, 86, 104, 56, 64, 64, 79,
			64, 79, 97, 58, 66, 66, 81, 66, 81, 99,
			56, 64, 64, 79, 64, 79, 97, 5, 6, 6,
			88, 68, 83, 101, 71, 86, 104, 56, 64, 64,
			79, 64, 79, 97, 59, 67, 67, 67, 67, 67,
			67, 61, 69, 69, 69, 69, 69, 69, 72, 72,
			72, 58, 66, 66, 81, 66, 81, 99, 58, 66,
			66, 81, 66, 81, 99, 59, 67, 67, 82, 67,
			82, 100, 75, 75, 92, 75, 92, 109, 61, 61,
			69, 61, 69, 84, 72, 87, 105, 75, 75, 92,
			75, 92, 109, 60, 68, 68, 83, 68, 83, 101,
			57, 65, 65, 80, 65, 80, 98, 59, 67, 67,
			82, 67, 82, 100, 59, 67, 67, 82, 67, 82,
			100, 5, 6, 6, 88, 68, 83, 101, 71, 86,
			104, 57, 65, 65, 80, 65, 80, 98, 59, 67,
			67, 82, 67, 82, 100, 59, 67, 67, 82, 67,
			82, 100, 5, 6, 6, 88, 68, 83, 101, 71,
			86, 104, 6, 6, 7, 58, 66, 66, 66, 66,
			66, 66, 60, 68, 68, 68, 68, 68, 68, 5,
			71, 71, 71, 71, 71, 71, 60, 68, 68, 83,
			68, 83, 101, 59, 67, 67, 82, 67, 82, 100,
			56, 64, 64, 79, 64, 79, 97, 5, 6, 6,
			56, 64, 64, 79, 64, 79, 97, 58, 66, 66,
			81, 66, 81, 99, 60, 68, 68, 83, 68, 83,
			101, 12, 71, 71, 86, 71, 86, 104, 56, 64,
			64, 79, 64, 79, 97, 58, 66, 66, 81, 66,
			81, 99, 60, 68, 68, 83, 68, 83, 101, 2,
			3, 5, 56, 64, 64, 79, 64, 79, 97, 58,
			66, 66, 81, 60, 68, 68, 83, 59, 67, 67,
			82, 57, 65, 65, 80, 65, 80, 98, 58, 66,
			66, 81, 60, 68, 68, 83, 59, 67, 67, 82,
			57, 65, 65, 80, 59, 67, 67, 82, 61, 69,
			69, 84, 59, 67, 67, 82, 67, 82, 100, 74,
			91, 74, 91, 108, 75, 92, 75, 92, 109, 74,
			91, 75, 92, 64, 66, 81, 99, 56, 64, 79,
			66, 81, 99, 50, 56, 64, 66, 81, 99, 48,
			50, 56, 62, 73, 62, 73, 90, 58, 66, 81,
			74, 68, 83, 101, 71, 86, 104, 52, 58, 66,
			75, 68, 83, 101, 71, 86, 104, 60, 68, 83,
			91, 91, 108, 92, 109, 6, 6, 7, 29, 29,
			29, 29, 29, 30, 63, 63, 30, 30, 32, 74,
			74, 75, 75, 91, 92, 57, 65, 65, 80, 65,
			80, 98, 59, 67, 67, 82, 67, 82, 100, 61,
			69, 69, 84, 69, 84, 102, 72, 87, 105, 57,
			57, 65, 57, 65, 80, 57, 65, 80, 51, 51,
			57, 51, 57, 65, 51, 57, 65, 49, 49, 51,
			49, 51, 57, 49, 51, 57, 59, 59, 67, 59,
			67, 82, 59, 67, 82, 53, 53, 59, 53, 59,
			67, 53, 59, 67, 61, 61, 69, 61, 69, 84,
			61, 69, 84, 64, 79, 97, 66, 81, 99, 64,
			79, 97, 66, 81, 99, 68, 83, 101, 71, 86,
			104, 68, 83, 101, 71, 86, 104, 69, 69, 84,
			69, 84, 102, 0, 0, 0, 0, 0, 0, 71,
			71, 86, 71, 86, 104, 0, 0, 0, 0, 0,
			0, 6, 6, 7, 6, 7, 8, 0, 0, 0,
			69, 69, 84, 69, 84, 102, 74, 91, 74, 91,
			108, 75, 92, 109, 75, 92, 29, 30, 74, 91,
			75, 92, 56, 56, 64, 56, 64, 79, 56, 64,
			79, 50, 50, 56, 50, 56, 64, 50, 56, 64,
			48, 48, 50, 48, 50, 56, 48, 50, 56, 58,
			58, 66, 58, 66, 81, 58, 66, 81, 52, 52,
			58, 52, 58, 66, 52, 58, 66, 60, 60, 68,
			60, 68, 83, 60, 68, 83, 83, 83, 101, 86,
			104, 72, 72, 87, 72, 87, 105, 65, 65, 80,
			65, 80, 98, 0, 0, 0, 0, 0, 0, 69,
			69, 84, 69, 84, 102, 72, 87, 105, 0, 0,
			0, 0, 0, 0, 66, 66, 81, 66, 81, 99,
			0, 0, 0, 68, 68, 83, 68, 83, 101, 71,
			86, 104, 65, 65, 80, 65, 80, 98, 69, 69,
			84, 69, 84, 102, 72, 87, 105, 66, 66, 81,
			66, 81, 99, 68, 68, 83, 68, 83, 101, 71,
			86, 104, 69, 69, 84, 69, 84, 102, 72, 87,
			105, 66, 66, 74, 91, 108, 75, 92, 109, 29,
			30, 68, 83, 101, 71, 86, 104, 68, 83, 71,
			86, 68, 83, 101, 71, 86, 104, 68, 83, 68,
			83, 101, 71, 86, 104, 68, 83, 71, 86, 68,
			83, 101, 71, 86, 104, 74, 91, 108, 75, 92,
			109, 29, 30, 74, 91, 108, 75, 92, 109, 29,
			30, 65, 80, 98, 65, 80, 98, 67, 82, 100,
			78, 96, 111, 67, 67, 82, 100, 67, 64, 79,
			97, 66, 81, 99, 68, 83, 101, 71, 86, 104,
			11, 11, 11, 11, 11, 12, 12, 60, 60, 60,
			12, 12, 12, 13, 68, 68, 71, 71, 83, 86,
			64, 79, 97, 66, 81, 99, 64, 79, 97, 66,
			81, 99, 68, 83, 101, 71, 86, 104, 74, 91,
			108, 75, 92, 109, 64, 79, 97, 66, 81, 99,
			68, 83, 101, 71, 86, 104, 66, 81, 99, 68,
			83, 101, 71, 86, 104, 66, 81, 99, 74, 91,
			108, 74, 91, 108, 68, 83, 101, 71, 86, 104,
			64, 79, 97, 66, 81, 99, 68, 83, 101, 71,
			86, 104, 74, 91, 108, 75, 92, 109, 9, 9,
			9, 9, 9, 10, 10, 10, 10, 10, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			64, 79, 97, 66, 81, 99, 68, 83, 101, 71,
			86, 104, 74, 91, 108, 75, 92, 109, 6, 6,
			6, 6, 6, 6, 71, 86, 104, 74, 91, 108,
			75, 92, 109, 68, 83, 101, 71, 86, 104, 74,
			91, 108, 75, 92, 109, 68, 83, 101, 71, 86,
			104, 68, 83, 71, 86, 64, 79, 97, 66, 81,
			99, 68, 83, 71, 86, 64, 79, 97, 11, 11,
			12, 12, 11, 11, 11, 12, 12, 12, 11, 11,
			12, 12, 11, 11, 11, 12, 12, 12, 29, 29,
			30, 30, 29, 29, 29, 30, 30, 30, 29, 29,
			30, 30, 29, 29, 29, 30, 30, 30, 74, 91,
			75, 92, 74, 91, 108, 75, 92, 109, 74, 91,
			75, 92, 74, 91, 108, 75, 92, 109, 74, 91,
			75, 92, 74, 91, 108, 75, 92, 109, 29, 30,
			29, 30, 74, 91, 75, 92, 74, 91, 108, 75,
			92, 109, 74, 29, 30, 29, 30, 74, 74, 91,
			75, 92, 74, 91, 108, 75, 92, 109, 29, 30,
			29, 30, 74, 91, 75, 92, 74, 91, 108, 75,
			92, 109, 29, 30, 29, 30, 11, 11, 11, 12,
			12, 12, 11, 11, 11, 12, 12, 12, 29, 29,
			29, 30, 30, 30, 29, 29, 29, 30, 30, 30,
			74, 91, 75, 92, 74, 91, 108, 75, 92, 109,
			74, 91, 75, 92, 74, 91, 108, 75, 92, 109,
			74, 91, 75, 92, 74, 91, 108, 75, 92, 109,
			29, 30, 29, 30, 74, 91, 75, 92, 74, 91,
			108, 75, 92, 109, 74, 29, 30, 29, 30, 74,
			74, 91, 75, 92, 74, 91, 108, 75, 92, 109,
			29, 30, 29, 30, 74, 91, 75, 92, 74, 91,
			108, 75, 92, 109, 29, 30, 29, 30, 70, 85,
			103, 70, 85, 103, 74, 91, 75, 92, 74, 91,
			108, 75, 92, 109, 74, 91, 75, 92, 74, 91,
			108, 75, 92, 109, 74, 91, 75, 92, 74, 91,
			108, 75, 92, 109, 29, 30, 29, 30, 74, 91,
			75, 92, 74, 91, 108, 75, 92, 109, 29, 30,
			29, 30, 74, 91, 75, 92, 74, 91, 108, 75,
			92, 109, 29, 30, 29, 30, 74, 91, 75, 92,
			74, 91, 108, 75, 92, 109, 29, 30, 29, 30,
			68, 83, 101, 71, 86, 104, 29, 30, 29, 30,
			29, 30, 29, 30, 29, 30, 29, 30, 29, 30,
			29, 30, 68, 108, 109, 68, 68, 108, 109, 68,
			29, 30, 68, 108, 109, 68, 29, 30, 64, 64,
			79, 64, 79, 97, 6, 6, 6, 6, 88, 6,
			88, 106, 6, 6, 88, 6, 88, 106, 6, 6,
			88, 6, 88, 106, 6, 6, 88, 6, 88, 106,
			2, 3, 5, 1, 1, 2, 3, 5, 2, 3,
			5, 3, 5, 3, 5, 3, 5, 3, 5, 3,
			5, 3, 5, 3, 5, 3, 5, 3, 5, 3,
			5, 3, 5, 3, 5, 3, 5, 3, 5, 11,
			12, 3, 5, 8, 8, 8, 8, 8, 8, 8,
			8, 8, 3, 5, 86, 86, 104, 92, 92, 109,
			68, 83, 68, 83, 101, 71, 86, 104, 74, 91,
			74, 91, 108, 75, 92, 75, 92, 109, 93, 74,
			74, 91, 74, 91, 108, 75, 75, 92, 75, 92,
			109, 29, 29, 29, 30, 30, 30, 74, 74, 91,
			75, 75, 92, 66, 66, 81, 56, 64, 64, 79,
			64, 79, 97, 1, 1, 1, 1, 1, 1, 2,
			2, 2, 2, 2, 2, 3, 5, 3, 5, 3,
			5, 29, 29, 29, 29, 29, 29, 32, 74, 74,
			75, 75, 32, 74, 74, 75, 75, 91, 92, 91,
			92, 62, 73, 62, 73, 90, 68, 83, 101, 71,
			86, 104, 69, 84, 102, 72, 87, 105, 1, 1,
			1, 1, 1, 1, 29, 29, 29, 3, 5, 3,
			5, 3, 5, 91, 108, 92, 109, 68, 83, 101,
			71, 86, 104, 74, 91, 108, 75, 92, 109, 29,
			30, 0, 0, 0, 0, 0, 0, 0, 0, 13,
			68, 68, 71, 71, 13, 68, 68, 71, 71, 83,
			86, 83, 86, 64, 79, 97, 66, 81, 99, 65,
			80, 98, 67, 82, 100, 74, 74, 91, 75, 75,
			64, 64, 79, 64, 79, 97, 83, 101, 86, 104,
			71, 71, 86, 71, 86, 104, 88, 74, 91, 74,
			91, 75, 92, 75, 92, 74, 91, 75, 92, 64,
			79, 74, 91, 108, 75, 92, 109, 29, 30, 74,
			91, 108, 75, 92, 109, 29, 30, 74, 91, 108,
			75, 92, 109, 29, 30, 74, 91, 74, 91, 75,
			92, 75, 92, 74, 91, 74, 91, 75, 92, 75,
			92, 64, 64, 64, 64, 64, 64, 64, 64, 64,
			64, 64, 64, 74, 91, 108, 75, 92, 109, 29,
			30, 74, 91, 74, 91, 75, 92, 75, 92, 29,
			29, 30, 30, 74, 91, 74, 91, 75, 92, 75,
			92, 29, 29, 30, 30, 66, 81, 99, 68, 83,
			101, 71, 86, 104, 66, 81, 99, 68, 83, 101,
			71, 86, 104, 74, 91, 74, 91, 75, 92, 75,
			92, 29, 29, 30, 30, 74, 91, 74, 91, 75,
			92, 75, 92, 29, 29, 30, 30, 68, 64, 64,
			79, 64, 79, 97, 64, 64, 79, 64, 79, 97,
			6, 6, 3, 5, 67, 67, 69, 69, 69, 67,
			67, 69, 69, 69, 6, 7, 6, 7, 64, 64,
			67, 67, 64, 66, 68, 71, 65, 67, 69, 72,
			64, 66, 68, 71, 3, 5, 3, 5, 3, 5,
			3, 5, 3, 5, 3, 5, 3, 5, 3, 5,
			3, 5, 0, 0, 0, 0, 74, 91, 75, 92,
			29, 30, 64, 64, 66, 66, 68, 68, 71, 71,
			64, 64, 66, 66, 68, 68, 71, 71, 65, 65,
			67, 67, 69, 69, 72, 72, 65, 65, 65, 67,
			67, 69, 64, 64, 64, 66, 66, 68, 65, 67,
			69, 3, 5, 3, 3, 3, 3, 59, 61, 63,
			63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
			63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
			59, 60, 56, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
			1, 0, 0, 0, 43, 0, 43, 0, 44, 44,
			44, 0, 0, 0, 0, 0, 0, 0, 3, 3,
			0, 0, 0, 45, 45, 45, 45, 45, 45, 0,
			0, 0, 0, 0, 0, 56, 59, 58, 56, 59,
			56, 59, 56, 57, 57, 59, 58, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 46, 46, 47, 47, 0, 46, 46,
			47, 47, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 65, 80, 65, 80, 67, 82,
			67, 82, 0, 0, 0, 0, 0, 0, 2, 2,
			2, 0, 0, 73, 90, 107, 28, 73, 90, 107,
			28, 28, 69, 84, 102, 75, 92, 109, 62, 73,
			90, 54, 62, 73, 62, 73, 90, 54, 62, 73,
			62, 73, 90, 54, 62, 73, 73, 90, 107, 73,
			90, 107, 74, 91, 108, 72, 87, 105, 30, 28,
			28, 28, 28, 28, 28, 11, 12, 29, 62, 73,
			90, 54, 62, 73, 62, 73, 90, 54, 62, 73,
			73, 90, 107, 73, 90, 107, 28, 28, 28, 28,
			68, 83, 101, 71, 86, 104, 3, 5, 66, 81,
			99, 67, 82, 100, 73, 90, 107, 28, 77, 95,
			110, 77, 95, 110, 54, 54, 77, 95, 110, 77,
			95, 110, 54, 54, 73, 90, 107, 73, 90, 107,
			73, 90, 107, 73, 90, 107, 73, 90, 107, 73,
			90, 107, 73, 90, 107, 73, 90, 107, 73, 90,
			107, 73, 90, 107, 73, 90, 107, 73, 90, 107,
			28, 28, 28, 28, 28, 28, 73, 90, 107, 73,
			90, 107, 73, 90, 107, 73, 90, 107, 73, 90,
			107, 73, 90, 107, 28, 28, 28, 28, 28, 28,
			73, 90, 107, 28, 73, 90, 107, 28, 73, 90,
			107, 28, 73, 90, 107, 28, 73, 90, 107, 28,
			28, 28, 0, 0, 2, 2, 2, 2, 73, 90,
			107, 28, 73, 90, 107, 28, 73, 90, 107, 28,
			73, 90, 107, 28, 73, 90, 107, 28, 73, 90,
			107, 28, 73, 90, 107, 28, 73, 90, 107, 28,
			28, 0, 0, 0, 0, 1, 1, 1, 1, 1,
			1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 1, 1, 0, 0, 0, 0,
			0, 0, 0, 0, 3, 5, 3, 5, 3, 5,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
			3, 5, 3, 5, 3, 5, 3, 5, 64, 79,
			65, 80, 65, 80, 64, 79, 65, 80, 65, 80,
			0, 74, 91, 73, 90, 73, 90, 76, 94, 76,
			94, 28, 28, 33, 33, 70, 85, 70, 85, 3,
			5, 3, 5, 3, 5, 3, 5, 3, 5, 3,
			5, 3, 5, 3, 5, 3, 5, 3, 5, 3,
			5, 3, 5, 3, 5, 3, 5, 3, 5, 3,
			5, 0, 0, 0, 0, 0, 0, 66, 81, 66,
			81, 67, 82, 66, 81, 66, 81, 67, 82, 68,
			68, 68, 83, 68, 83, 68
		};

		internal static ReadOnlySpan<byte> SizesBcst => new byte[4936]
		{
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 125, 140, 155,
			0, 0, 0, 126, 141, 156, 0, 0, 0, 125,
			140, 155, 0, 0, 0, 126, 141, 156, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 125, 140, 155, 0, 0, 0, 126,
			141, 156, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 125, 140, 155, 0, 0, 0, 126, 141, 156,
			0, 0, 0, 125, 140, 155, 0, 0, 0, 126,
			141, 156, 0, 0, 0, 125, 140, 155, 0, 0,
			0, 126, 141, 156, 0, 0, 0, 125, 140, 155,
			0, 0, 0, 126, 141, 156, 0, 0, 0, 125,
			140, 155, 0, 0, 0, 126, 141, 156, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 125, 140, 155,
			0, 0, 0, 126, 141, 156, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 116, 125, 140, 0, 0,
			0, 126, 141, 156, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 120, 135, 150, 123, 138, 153, 0,
			0, 0, 125, 140, 155, 0, 0, 0, 125, 140,
			155, 0, 0, 0, 125, 140, 155, 0, 0, 0,
			126, 141, 156, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 125, 140, 155, 0, 0, 0, 126, 141,
			156, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			125, 140, 155, 0, 0, 0, 126, 141, 156, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 125, 140,
			155, 0, 0, 0, 126, 141, 156, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 119, 134, 149, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 120,
			135, 150, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 119, 134, 149,
			0, 0, 0, 0, 120, 135, 150, 0, 0, 0,
			122, 137, 152, 0, 0, 0, 122, 137, 152, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 119, 134, 149, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 119, 134, 149, 122, 137, 152, 119, 134,
			149, 122, 137, 152, 0, 0, 0, 0, 119, 134,
			149, 0, 0, 0, 0, 120, 135, 150, 123, 138,
			153, 0, 0, 0, 0, 119, 134, 149, 0, 0,
			0, 0, 122, 137, 152, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 122, 137, 152, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 119, 134, 149, 0, 0, 0, 0, 0,
			125, 140, 155, 126, 141, 156, 0, 116, 125, 140,
			126, 141, 156, 0, 0, 0, 0, 0, 0, 0,
			125, 140, 155, 126, 141, 156, 0, 116, 125, 140,
			126, 141, 156, 0, 0, 0, 0, 0, 116, 125,
			140, 126, 141, 156, 113, 119, 134, 122, 137, 152,
			119, 134, 149, 122, 137, 152, 116, 125, 140, 126,
			141, 156, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 125, 140, 155, 0, 0, 0, 126,
			141, 156, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 125,
			140, 155, 0, 0, 0, 126, 141, 156, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 122, 137, 152, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			119, 134, 149, 122, 137, 152, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 119, 134, 149, 122, 137, 152, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 126, 141, 156, 0, 0,
			0, 114, 120, 135, 123, 138, 153, 0, 0, 0,
			126, 141, 156, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 119, 134, 149, 122, 137,
			152, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 119, 134, 149, 122,
			137, 152, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			129, 144, 159, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 119, 134,
			149, 0, 0, 0, 0, 122, 137, 152, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 119, 134, 149, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 125, 140, 155, 0, 0, 126, 141, 156, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 119, 134, 149, 122, 137, 152, 0, 0, 0,
			0, 119, 134, 149, 122, 137, 152, 0, 0, 0,
			0, 140, 155, 141, 156, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 120, 135, 150, 123, 138, 153, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 119, 134, 149, 122, 137,
			152, 119, 134, 149, 122, 137, 152, 0, 0, 0,
			128, 143, 160, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 122, 137, 152, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 120, 135, 150, 0, 0, 125, 140,
			155, 126, 141, 156, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 134, 149, 137,
			152, 0, 0, 0, 123, 138, 153, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 120, 135, 150, 123, 138, 153, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 119, 134, 149, 122,
			137, 152, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 120, 135, 150, 123, 138, 153, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 119, 134, 149, 122,
			137, 152, 0, 0, 0, 120, 135, 150, 123, 138,
			153, 0, 0, 125, 140, 155, 126, 141, 156, 0,
			0, 119, 134, 149, 122, 137, 152, 0, 0, 0,
			0, 119, 134, 149, 122, 137, 152, 0, 0, 119,
			134, 149, 122, 137, 152, 0, 0, 0, 0, 119,
			134, 149, 122, 137, 152, 125, 140, 155, 126, 141,
			156, 0, 0, 125, 140, 155, 126, 141, 156, 0,
			0, 119, 134, 149, 119, 134, 149, 127, 142, 158,
			131, 146, 161, 0, 127, 142, 158, 0, 0, 0,
			0, 0, 0, 0, 119, 134, 149, 122, 137, 152,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 119, 134, 149, 122, 137, 152, 125, 140,
			155, 126, 141, 156, 0, 0, 0, 0, 0, 0,
			119, 134, 149, 122, 137, 152, 0, 0, 0, 119,
			134, 149, 122, 137, 152, 0, 0, 0, 125, 140,
			155, 125, 140, 155, 119, 134, 149, 122, 137, 152,
			0, 0, 0, 0, 0, 0, 119, 134, 149, 122,
			137, 152, 125, 140, 155, 126, 141, 156, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 119, 134, 149, 122,
			137, 152, 125, 140, 155, 126, 141, 156, 0, 0,
			0, 0, 0, 0, 122, 137, 152, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 125, 140, 155, 126, 141, 156, 0, 0,
			0, 0, 125, 140, 155, 126, 141, 156, 0, 0,
			0, 0, 125, 140, 155, 126, 141, 156, 0, 0,
			0, 0, 0, 0, 0, 0, 125, 140, 155, 126,
			141, 156, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 125, 140, 155, 126, 141, 156, 0, 0,
			0, 0, 0, 0, 0, 0, 125, 140, 155, 126,
			141, 156, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 125, 140, 155, 126, 141, 156,
			0, 0, 0, 0, 125, 140, 155, 126, 141, 156,
			0, 0, 0, 0, 125, 140, 155, 126, 141, 156,
			0, 0, 0, 0, 0, 0, 0, 0, 125, 140,
			155, 126, 141, 156, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 125, 140, 155, 126, 141, 156,
			0, 0, 0, 0, 0, 0, 0, 0, 125, 140,
			155, 126, 141, 156, 0, 0, 0, 0, 121, 136,
			151, 121, 136, 151, 0, 0, 0, 0, 125, 140,
			155, 126, 141, 156, 0, 0, 0, 0, 125, 140,
			155, 126, 141, 156, 0, 0, 0, 0, 125, 140,
			155, 126, 141, 156, 0, 0, 0, 0, 0, 0,
			0, 0, 125, 140, 155, 126, 141, 156, 0, 0,
			0, 0, 0, 0, 0, 0, 125, 140, 155, 126,
			141, 156, 0, 0, 0, 0, 0, 0, 0, 0,
			125, 140, 155, 126, 141, 156, 0, 0, 0, 0,
			119, 134, 149, 122, 137, 152, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 155, 156, 0, 0, 155, 156, 0,
			0, 0, 0, 155, 156, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 137, 152, 0, 141, 156,
			0, 0, 119, 134, 149, 122, 137, 152, 0, 0,
			125, 140, 155, 0, 0, 126, 141, 156, 0, 0,
			0, 0, 125, 140, 155, 0, 0, 0, 126, 141,
			156, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 119, 134, 149, 122,
			137, 152, 120, 135, 150, 123, 138, 153, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 140, 155, 141, 156, 119, 134, 149,
			122, 137, 152, 125, 140, 155, 126, 141, 156, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 134, 149, 137, 152,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 125, 140, 155, 126, 141, 156, 0, 0, 125,
			140, 155, 126, 141, 156, 0, 0, 125, 140, 155,
			126, 141, 156, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 125, 140, 155, 126, 141, 156, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 119, 134,
			149, 122, 137, 152, 0, 0, 0, 119, 134, 149,
			122, 137, 152, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 122, 137, 152, 0, 0, 0, 122, 137, 152,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 124, 139, 154, 0, 124, 139, 154,
			0, 0, 120, 135, 150, 126, 141, 156, 115, 124,
			139, 112, 115, 124, 115, 124, 139, 112, 115, 124,
			115, 124, 139, 112, 115, 124, 124, 139, 154, 124,
			139, 154, 125, 140, 155, 123, 138, 153, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 115, 124,
			139, 112, 115, 124, 115, 124, 139, 112, 115, 124,
			124, 139, 154, 124, 139, 154, 0, 0, 0, 0,
			119, 134, 149, 122, 137, 152, 0, 0, 118, 133,
			148, 117, 132, 147, 124, 139, 154, 0, 130, 145,
			157, 130, 145, 157, 0, 0, 130, 145, 157, 130,
			145, 157, 0, 0, 124, 139, 154, 124, 139, 154,
			124, 139, 154, 124, 139, 154, 124, 139, 154, 124,
			139, 154, 124, 139, 154, 124, 139, 154, 124, 139,
			154, 124, 139, 154, 124, 139, 154, 124, 139, 154,
			0, 0, 0, 0, 0, 0, 124, 139, 154, 124,
			139, 154, 124, 139, 154, 124, 139, 154, 124, 139,
			154, 124, 139, 154, 0, 0, 0, 0, 0, 0,
			124, 139, 154, 0, 124, 139, 154, 0, 124, 139,
			154, 0, 124, 139, 154, 0, 124, 139, 154, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 124, 139,
			154, 0, 124, 139, 154, 0, 124, 139, 154, 0,
			124, 139, 154, 0, 124, 139, 154, 0, 124, 139,
			154, 0, 124, 139, 154, 0, 124, 139, 154, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0
		};
	}
	internal static class InstructionOpCounts
	{
		internal static ReadOnlySpan<byte> OpCount => new byte[4936]
		{
			0, 0, 0, 0, 0, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
			1, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 1, 1, 1, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
			1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 1, 1, 1, 1, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 0, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 0, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 0,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
			2, 1, 1, 1, 3, 3, 3, 1, 1, 1,
			3, 3, 3, 2, 2, 2, 2, 2, 2, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 1, 1, 1, 0,
			0, 0, 2, 2, 2, 0, 0, 0, 0, 0,
			0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 1, 1, 1, 0, 0, 0, 2, 2, 2,
			2, 2, 1, 2, 2, 2, 1, 1, 2, 2,
			2, 0, 0, 0, 1, 1, 1, 0, 0, 0,
			0, 1, 0, 0, 0, 0, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 2, 0, 1, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 1, 1, 1, 1, 1, 1, 1,
			1, 2, 2, 2, 2, 0, 1, 1, 1, 1,
			1, 1, 2, 2, 2, 2, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 2, 2, 1,
			1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
			2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 2, 1,
			1, 2, 2, 1, 1, 1, 1, 1, 1, 1,
			1, 2, 2, 2, 0, 2, 2, 2, 2, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 2, 1,
			1, 1, 1, 1, 1, 2, 2, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
			2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 2, 2, 2, 2, 2, 2, 0, 0,
			0, 2, 2, 1, 1, 1, 1, 1, 1, 2,
			2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 0, 0, 0, 0, 0, 0, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 2, 2, 2, 2, 2, 2, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			2, 2, 2, 1, 1, 1, 0, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 3, 2, 3, 2,
			2, 3, 2, 3, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 3, 2,
			3, 2, 2, 3, 2, 3, 2, 2, 2, 3,
			3, 3, 3, 2, 3, 3, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
			2, 3, 3, 3, 3, 3, 2, 3, 3, 3,
			3, 3, 2, 3, 3, 3, 3, 3, 2, 3,
			3, 2, 3, 3, 2, 3, 3, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 1, 1, 1, 1, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 1, 1, 1, 0, 0, 1, 1, 1, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 0, 0, 0, 0, 0, 0, 0, 0, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 3, 3, 3,
			3, 3, 3, 3, 3, 2, 2, 2, 2, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 3, 3, 2, 3, 3, 2, 2,
			2, 2, 3, 2, 2, 2, 2, 3, 2, 3,
			3, 3, 3, 3, 2, 3, 3, 3, 3, 3,
			2, 3, 3, 3, 3, 3, 2, 3, 3, 3,
			3, 3, 2, 3, 3, 3, 3, 3, 2, 3,
			3, 3, 3, 3, 2, 3, 3, 3, 3, 3,
			2, 3, 3, 3, 3, 3, 2, 3, 3, 3,
			3, 3, 2, 3, 3, 3, 3, 3, 2, 3,
			3, 2, 3, 3, 2, 3, 3, 3, 3, 3,
			2, 3, 3, 3, 3, 3, 2, 3, 3, 2,
			3, 3, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 3, 3, 2, 3, 3,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 3, 3, 3, 3, 3, 2, 3, 3,
			3, 3, 3, 2, 3, 3, 2, 3, 3, 2,
			3, 3, 3, 3, 3, 2, 3, 3, 3, 3,
			3, 2, 3, 3, 2, 3, 3, 2, 3, 3,
			3, 3, 3, 2, 3, 3, 3, 3, 3, 2,
			3, 3, 2, 3, 3, 2, 3, 3, 3, 3,
			3, 2, 3, 3, 3, 3, 3, 2, 3, 3,
			2, 3, 3, 2, 2, 3, 3, 3, 3, 3,
			2, 2, 3, 3, 3, 3, 3, 2, 2, 3,
			3, 3, 3, 3, 2, 2, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 2, 2,
			3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
			3, 3, 2, 2, 3, 3, 3, 3, 3, 2,
			2, 3, 3, 3, 3, 3, 2, 2, 3, 3,
			3, 3, 3, 2, 2, 3, 3, 3, 3, 3,
			2, 2, 3, 3, 3, 3, 3, 2, 3, 3,
			3, 3, 3, 2, 3, 3, 3, 3, 3, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 2, 2,
			3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 2, 2, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 2, 2,
			3, 3, 3, 3, 3, 2, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 2, 3,
			3, 3, 3, 3, 2, 2, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 2, 2,
			3, 3, 3, 3, 3, 0, 0, 0, 2, 2,
			2, 2, 2, 2, 2, 2, 3, 2, 2, 2,
			2, 2, 2, 2, 2, 4, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 3, 3, 3, 3, 2, 3, 3, 2,
			3, 3, 2, 3, 3, 2, 3, 3, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 1, 1, 1, 1, 1, 1, 0, 2,
			2, 2, 3, 3, 3, 3, 3, 3, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 2, 2, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 2, 2, 2,
			2, 2, 1, 1, 1, 1, 1, 1, 0, 2,
			2, 2, 3, 3, 3, 3, 3, 3, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 1, 1, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			3, 4, 4, 4, 4, 4, 3, 4, 4, 4,
			4, 4, 3, 4, 4, 3, 4, 4, 2, 2,
			3, 3, 3, 3, 4, 4, 4, 4, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 4, 4, 4,
			4, 4, 3, 4, 4, 4, 4, 4, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 2, 3, 3, 2, 3, 3, 2, 2, 3,
			3, 3, 3, 3, 2, 2, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 2, 2,
			3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
			3, 3, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 3, 3, 3,
			3, 3, 2, 2, 3, 3, 3, 3, 3, 2,
			2, 3, 3, 3, 3, 3, 2, 2, 3, 3,
			3, 3, 3, 3, 3, 3, 2, 2, 3, 3,
			3, 3, 3, 2, 2, 3, 3, 3, 3, 3,
			2, 2, 3, 3, 3, 3, 3, 2, 2, 3,
			3, 3, 3, 3, 3, 3, 3, 2, 2, 3,
			3, 3, 3, 3, 2, 2, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 2, 2,
			3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
			3, 3, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 3, 3, 3, 3, 3, 2, 2, 3,
			3, 3, 3, 3, 2, 2, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 2, 2,
			3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
			3, 3, 2, 2, 3, 3, 3, 3, 3, 3,
			3, 3, 2, 2, 2, 2, 2, 3, 3, 3,
			3, 3, 2, 2, 3, 3, 3, 3, 3, 2,
			2, 3, 3, 3, 3, 3, 2, 2, 3, 3,
			3, 3, 3, 2, 2, 3, 3, 3, 3, 3,
			2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
			2, 2, 3, 3, 3, 3, 3, 2, 2, 3,
			3, 3, 3, 3, 2, 2, 3, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 2, 2,
			3, 3, 3, 3, 3, 2, 2, 3, 3, 3,
			3, 3, 2, 2, 3, 3, 3, 3, 3, 2,
			2, 2, 2, 2, 3, 3, 3, 3, 3, 2,
			2, 3, 3, 2, 2, 3, 3, 2, 2, 3,
			3, 2, 2, 3, 3, 3, 3, 3, 2, 2,
			3, 3, 2, 2, 3, 3, 2, 2, 3, 3,
			2, 2, 3, 3, 2, 2, 3, 3, 2, 2,
			3, 3, 2, 2, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 2,
			2, 2, 2, 2, 3, 3, 3, 2, 2, 2,
			3, 3, 3, 2, 2, 2, 3, 3, 3, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 3, 3, 3, 3, 3, 3, 2, 2, 2,
			2, 3, 3, 3, 3, 3, 3, 2, 2, 2,
			3, 3, 3, 3, 3, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 2, 3, 3,
			3, 3, 3, 2, 2, 2, 2, 2, 2, 2,
			3, 3, 3, 3, 3, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 3, 3, 3, 3,
			3, 2, 3, 3, 3, 3, 3, 2, 3, 3,
			3, 3, 3, 2, 2, 2, 2, 2, 2, 2,
			3, 3, 3, 3, 3, 3, 3, 3, 2, 2,
			2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
			2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
			3, 3, 2, 3, 3, 3, 3, 3, 2, 3,
			3, 3, 3, 3, 3, 3, 3, 2, 3, 3,
			3, 3, 3, 2, 3, 3, 3, 3, 3, 3,
			3, 3, 2, 3, 3, 3, 3, 3, 3, 3,
			3, 2, 2, 2, 2, 2, 2, 2, 2, 3,
			3, 2, 2, 2, 2, 2, 2, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 2, 2, 2, 2, 2,
			2, 3, 3, 2, 2, 2, 2, 2, 2, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 2, 2,
			2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 2, 2,
			2, 2, 2, 2, 3, 3, 3, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 2, 2, 2, 2, 2, 2, 3, 3,
			3, 3, 2, 2, 2, 2, 2, 2, 3, 3,
			3, 3, 2, 2, 2, 2, 2, 2, 3, 3,
			3, 3, 2, 2, 2, 2, 2, 2, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
			1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
			1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
			3, 3, 2, 2, 2, 2, 3, 3, 2, 3,
			3, 3, 3, 3, 2, 2, 2, 3, 3, 3,
			3, 3, 2, 3, 3, 3, 3, 3, 2, 3,
			3, 3, 3, 3, 2, 3, 3, 3, 3, 3,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 3, 3, 2, 2, 2, 2, 2, 2, 3,
			3, 2, 2, 3, 3, 3, 3, 2, 2, 2,
			2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
			4, 4, 4, 4, 4, 4, 4, 4, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 4, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 4, 4, 3, 4, 4, 3, 4, 4,
			3, 4, 4, 3, 4, 4, 3, 3, 4, 4,
			4, 4, 4, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 4, 4, 4,
			4, 4, 3, 3, 3, 3, 3, 4, 4, 3,
			3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 3, 3,
			4, 4, 4, 4, 3, 4, 4, 3, 3, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 3, 3, 3, 3, 3, 3, 4,
			4, 3, 3, 3, 3, 3, 3, 3, 3, 4,
			4, 4, 4, 4, 3, 3, 3, 3, 3, 4,
			4, 3, 3, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 3, 4, 4, 3, 4,
			3, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			3, 4, 4, 4, 4, 4, 4, 5, 5, 5,
			5, 5, 5, 5, 5, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 3, 3, 3,
			3, 3, 3, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 3, 3, 4,
			4, 4, 4, 4, 3, 4, 4, 4, 4, 4,
			3, 3, 3, 3, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 3, 3, 3, 3, 4, 4, 4, 4,
			4, 4, 4, 4, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 1, 1, 1, 1, 2, 2, 2, 2,
			2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 3, 3, 3, 3, 3, 3, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
			1, 0, 0, 0, 1, 0, 1, 1, 2, 2,
			2, 3, 3, 3, 3, 3, 1, 1, 1, 1,
			0, 0, 0, 2, 2, 1, 1, 1, 1, 0,
			0, 0, 0, 0, 0, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 1, 1, 1, 1, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 0, 0, 0,
			0, 0, 1, 1, 3, 3, 3, 3, 3, 3,
			3, 3, 0, 0, 0, 0, 0, 0, 1, 1,
			1, 0, 0, 3, 3, 3, 3, 4, 4, 4,
			4, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 3, 3,
			2, 2, 3, 2, 2, 3, 3, 3, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 3, 3, 2, 2,
			2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 2, 2, 2, 3, 3, 3,
			3, 4, 3, 3, 3, 3, 3, 3, 3, 3,
			2, 2, 3, 3, 2, 2, 2, 2, 3, 3,
			3, 3, 2, 2, 2, 3, 3, 3, 3, 4,
			3, 3, 3, 4, 2, 2, 2, 3, 3, 3,
			3, 3, 2, 2, 2, 3, 3, 3, 3, 3,
			2, 0, 0, 2, 2, 1, 1, 1, 1, 1,
			1, 1, 1, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 3, 3, 2,
			1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			3, 1, 1, 1, 1, 1, 1, 1, 1, 2,
			2, 2, 2, 2, 2, 2, 2, 3, 3, 3,
			3, 2, 2, 3, 3, 3, 2, 2, 3, 3,
			3, 3, 3, 2, 2, 2, 1, 1, 4, 4,
			3, 3, 3, 3, 2, 3, 3, 3, 3, 3,
			3, 2, 2, 2, 2, 3, 3, 3, 3, 3,
			3, 3, 2, 2, 3, 3, 3, 2, 2, 2,
			2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 2, 2, 2, 2, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 2, 2, 2, 2,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 2, 2, 2, 2, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 2, 2, 2,
			2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 2, 1, 1, 1, 1, 1, 1, 1,
			1, 2, 2, 2, 2, 3, 3, 3, 3, 3,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 4, 3, 4, 4, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
			2, 2, 2, 2, 2, 2, 2, 2, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 2, 2, 2, 2, 2, 2, 2, 2, 2,
			2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 0, 3, 2, 2, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 4
		};
	}
	internal static class InstructionUtils
	{
		public static int GetAddressSizeInBytes(Register baseReg, Register indexReg, int displSize, CodeSize codeSize)
		{
			if ((Register.RAX <= baseReg && baseReg <= Register.R15) || (Register.RAX <= indexReg && indexReg <= Register.R15) || baseReg == Register.RIP)
			{
				return 8;
			}
			if ((Register.EAX <= baseReg && baseReg <= Register.R15D) || (Register.EAX <= indexReg && indexReg <= Register.R15D) || baseReg == Register.EIP)
			{
				return 4;
			}
			if ((Register.AX <= baseReg && baseReg <= Register.DI) || (Register.AX <= indexReg && indexReg <= Register.DI))
			{
				return 2;
			}
			if (displSize == 2 || displSize == 4 || displSize == 8)
			{
				return displSize;
			}
			return codeSize switch
			{
				CodeSize.Code64 => 8, 
				CodeSize.Code32 => 4, 
				CodeSize.Code16 => 2, 
				_ => 8, 
			};
		}
	}
	internal enum MandatoryPrefixByte : uint
	{
		None,
		P66,
		PF3,
		PF2
	}
	public readonly struct MemoryOperand
	{
		public readonly Register SegmentPrefix;

		public readonly Register Base;

		public readonly Register Index;

		public readonly int Scale;

		public readonly long Displacement;

		public readonly int DisplSize;

		public readonly bool IsBroadcast;

		public MemoryOperand(Register @base, Register index, int scale, long displacement, int displSize, bool isBroadcast, Register segmentPrefix)
		{
			SegmentPrefix = segmentPrefix;
			Base = @base;
			Index = index;
			Scale = scale;
			Displacement = displacement;
			DisplSize = displSize;
			IsBroadcast = isBroadcast;
		}

		public MemoryOperand(Register @base, Register index, int scale, bool isBroadcast, Register segmentPrefix)
		{
			SegmentPrefix = segmentPrefix;
			Base = @base;
			Index = index;
			Scale = scale;
			Displacement = 0L;
			DisplSize = 0;
			IsBroadcast = isBroadcast;
		}

		public MemoryOperand(Register @base, long displacement, int displSize, bool isBroadcast, Register segmentPrefix)
		{
			SegmentPrefix = segmentPrefix;
			Base = @base;
			Index = Register.None;
			Scale = 1;
			Displacement = displacement;
			DisplSize = displSize;
			IsBroadcast = isBroadcast;
		}

		public MemoryOperand(Register index, int scale, long displacement, int displSize, bool isBroadcast, Register segmentPrefix)
		{
			SegmentPrefix = segmentPrefix;
			Base = Register.None;
			Index = index;
			Scale = scale;
			Displacement = displacement;
			DisplSize = displSize;
			IsBroadcast = isBroadcast;
		}

		public MemoryOperand(Register @base, long displacement, bool isBroadcast, Register segmentPrefix)
		{
			SegmentPrefix = segmentPrefix;
			Base = @base;
			Index = Register.None;
			Scale = 1;
			Displacement = displacement;
			DisplSize = 1;
			IsBroadcast = isBroadcast;
		}

		public MemoryOperand(Register @base, Register index, int scale, long displacement, int displSize)
		{
			SegmentPrefix = Register.None;
			Base = @base;
			Index = index;
			Scale = scale;
			Displacement = displacement;
			DisplSize = displSize;
			IsBroadcast = false;
		}

		public MemoryOperand(Register @base, Register index, int scale)
		{
			SegmentPrefix = Register.None;
			Base = @base;
			Index = index;
			Scale = scale;
			Displacement = 0L;
			DisplSize = 0;
			IsBroadcast = false;
		}

		public MemoryOperand(Register @base, Register index)
		{
			SegmentPrefix = Register.None;
			Base = @base;
			Index = index;
			Scale = 1;
			Displacement = 0L;
			DisplSize = 0;
			IsBroadcast = false;
		}

		public MemoryOperand(Register @base, long displacement, int displSize)
		{
			SegmentPrefix = Register.None;
			Base = @base;
			Index = Register.None;
			Scale = 1;
			Displacement = displacement;
			DisplSize = displSize;
			IsBroadcast = false;
		}

		public MemoryOperand(Register index, int scale, long displacement, int displSize)
		{
			SegmentPrefix = Register.None;
			Base = Register.None;
			Index = index;
			Scale = scale;
			Displacement = displacement;
			DisplSize = displSize;
			IsBroadcast = false;
		}

		public MemoryOperand(Register @base, long displacement)
		{
			SegmentPrefix = Register.None;
			Base = @base;
			Index = Register.None;
			Scale = 1;
			Displacement = displacement;
			DisplSize = 1;
			IsBroadcast = false;
		}

		public MemoryOperand(Register @base)
		{
			SegmentPrefix = Register.None;
			Base = @base;
			Index = Register.None;
			Scale = 1;
			Displacement = 0L;
			DisplSize = 0;
			IsBroadcast = false;
		}

		public MemoryOperand(ulong displacement, int displSize)
		{
			SegmentPrefix = Register.None;
			Base = Register.None;
			Index = Register.None;
			Scale = 1;
			Displacement = (long)displacement;
			DisplSize = displSize;
			IsBroadcast = false;
		}
	}
	public enum MemorySize
	{
		Unknown,
		UInt8,
		UInt16,
		UInt32,
		UInt52,
		UInt64,
		UInt128,
		UInt256,
		UInt512,
		Int8,
		Int16,
		Int32,
		Int64,
		Int128,
		Int256,
		Int512,
		SegPtr16,
		SegPtr32,
		SegPtr64,
		WordOffset,
		DwordOffset,
		QwordOffset,
		Bound16_WordWord,
		Bound32_DwordDword,
		Bnd32,
		Bnd64,
		Fword6,
		Fword10,
		Float16,
		Float32,
		Float64,
		Float80,
		Float128,
		BFloat16,
		FpuEnv14,
		FpuEnv28,
		FpuState94,
		FpuState108,
		Fxsave_512Byte,
		Fxsave64_512Byte,
		Xsave,
		Xsave64,
		Bcd,
		Tilecfg,
		Tile,
		SegmentDescSelector,
		KLHandleAes128,
		KLHandleAes256,
		Packed16_UInt8,
		Packed16_Int8,
		Packed32_UInt8,
		Packed32_Int8,
		Packed32_UInt16,
		Packed32_Int16,
		Packed32_Float16,
		Packed32_BFloat16,
		Packed64_UInt8,
		Packed64_Int8,
		Packed64_UInt16,
		Packed64_Int16,
		Packed64_UInt32,
		Packed64_Int32,
		Packed64_Float16,
		Packed64_Float32,
		Packed128_UInt8,
		Packed128_Int8,
		Packed128_UInt16,
		Packed128_Int16,
		Packed128_UInt32,
		Packed128_Int32,
		Packed128_UInt52,
		Packed128_UInt64,
		Packed128_Int64,
		Packed128_Float16,
		Packed128_Float32,
		Packed128_Float64,
		Packed128_BFloat16,
		Packed128_2xFloat16,
		Packed128_2xBFloat16,
		Packed256_UInt8,
		Packed256_Int8,
		Packed256_UInt16,
		Packed256_Int16,
		Packed256_UInt32,
		Packed256_Int32,
		Packed256_UInt52,
		Packed256_UInt64,
		Packed256_Int64,
		Packed256_UInt128,
		Packed256_Int128,
		Packed256_Float16,
		Packed256_Float32,
		Packed256_Float64,
		Packed256_Float128,
		Packed256_BFloat16,
		Packed256_2xFloat16,
		Packed256_2xBFloat16,
		Packed512_UInt8,
		Packed512_Int8,
		Packed512_UInt16,
		Packed512_Int16,
		Packed512_UInt32,
		Packed512_Int32,
		Packed512_UInt52,
		Packed512_UInt64,
		Packed512_Int64,
		Packed512_UInt128,
		Packed512_Float16,
		Packed512_Float32,
		Packed512_Float64,
		Packed512_2xFloat16,
		Packed512_2xBFloat16,
		Broadcast32_Float16,
		Broadcast64_UInt32,
		Broadcast64_Int32,
		Broadcast64_Float16,
		Broadcast64_Float32,
		Broadcast128_Int16,
		Broadcast128_UInt16,
		Broadcast128_UInt32,
		Broadcast128_Int32,
		Broadcast128_UInt52,
		Broadcast128_UInt64,
		Broadcast128_Int64,
		Broadcast128_Float16,
		Broadcast128_Float32,
		Broadcast128_Float64,
		Broadcast128_2xInt16,
		Broadcast128_2xInt32,
		Broadcast128_2xUInt32,
		Broadcast128_2xFloat16,
		Broadcast128_2xBFloat16,
		Broadcast256_Int16,
		Broadcast256_UInt16,
		Broadcast256_UInt32,
		Broadcast256_Int32,
		Broadcast256_UInt52,
		Broadcast256_UInt64,
		Broadcast256_Int64,
		Broadcast256_Float16,
		Broadcast256_Float32,
		Broadcast256_Float64,
		Broadcast256_2xInt16,
		Broadcast256_2xInt32,
		Broadcast256_2xUInt32,
		Broadcast256_2xFloat16,
		Broadcast256_2xBFloat16,
		Broadcast512_Int16,
		Broadcast512_UInt16,
		Broadcast512_UInt32,
		Broadcast512_Int32,
		Broadcast512_UInt52,
		Broadcast512_UInt64,
		Broadcast512_Int64,
		Broadcast512_Float16,
		Broadcast512_Float32,
		Broadcast512_Float64,
		Broadcast512_2xFloat16,
		Broadcast512_2xInt16,
		Broadcast512_2xUInt32,
		Broadcast512_2xInt32,
		Broadcast512_2xBFloat16
	}
	public static class MemorySizeExtensions
	{
		internal static readonly MemorySizeInfo[] MemorySizeInfos = GetMemorySizeInfos();

		public static bool IsBroadcast(this MemorySize memorySize)
		{
			return memorySize >= MemorySize.Broadcast32_Float16;
		}

		private static MemorySizeInfo[] GetMemorySizeInfos()
		{
			ReadOnlySpan<byte> readOnlySpan = new byte[486]
			{
				0, 0, 0, 1, 33, 0, 2, 66, 0, 3,
				99, 0, 4, 165, 0, 5, 165, 0, 6, 8,
				1, 7, 74, 1, 8, 140, 1, 9, 33, 128,
				10, 66, 128, 11, 99, 128, 12, 165, 128, 13,
				8, 129, 14, 74, 129, 15, 140, 129, 16, 99,
				0, 17, 132, 0, 18, 198, 0, 19, 66, 0,
				20, 99, 0, 21, 165, 0, 2, 67, 0, 3,
				101, 0, 24, 165, 0, 25, 8, 1, 26, 132,
				0, 27, 198, 0, 28, 66, 128, 29, 99, 128,
				30, 165, 128, 31, 198, 128, 32, 8, 129, 33,
				66, 128, 34, 231, 0, 35, 41, 1, 36, 173,
				1, 37, 206, 1, 38, 239, 1, 39, 239, 1,
				40, 0, 0, 41, 0, 0, 42, 198, 128, 43,
				140, 1, 44, 0, 0, 45, 198, 0, 46, 107,
				1, 47, 140, 1, 1, 34, 0, 9, 34, 128,
				1, 35, 0, 9, 35, 128, 2, 67, 0, 10,
				67, 128, 28, 67, 128, 33, 67, 128, 1, 37,
				0, 9, 37, 128, 2, 69, 0, 10, 69, 128,
				3, 101, 0, 11, 101, 128, 28, 69, 128, 29,
				101, 128, 1, 40, 0, 9, 40, 128, 2, 72,
				0, 10, 72, 128, 3, 104, 0, 11, 104, 128,
				4, 168, 0, 5, 168, 0, 12, 168, 128, 28,
				72, 128, 29, 104, 128, 30, 168, 128, 33, 72,
				128, 54, 104, 128, 55, 104, 128, 1, 42, 0,
				9, 42, 128, 2, 74, 0, 10, 74, 128, 3,
				106, 0, 11, 106, 128, 4, 170, 0, 5, 170,
				0, 12, 170, 128, 6, 10, 1, 13, 10, 129,
				28, 74, 128, 29, 106, 128, 30, 170, 128, 32,
				10, 129, 33, 74, 128, 54, 106, 128, 55, 106,
				128, 1, 44, 0, 9, 44, 128, 2, 76, 0,
				10, 76, 128, 3, 108, 0, 11, 108, 128, 4,
				172, 0, 5, 172, 0, 12, 172, 128, 6, 12,
				1, 28, 76, 128, 29, 108, 128, 30, 172, 128,
				54, 108, 128, 55, 108, 128, 28, 66, 128, 3,
				99, 0, 11, 99, 128, 28, 66, 128, 29, 99,
				128, 10, 66, 0, 2, 66, 0, 3, 99, 0,
				11, 99, 128, 4, 165, 0, 5, 165, 0, 12,
				165, 128, 28, 66, 128, 29, 99, 128, 30, 165,
				128, 53, 99, 128, 61, 165, 128, 60, 165, 0,
				54, 99, 128, 55, 99, 128, 10, 66, 0, 2,
				66, 0, 3, 99, 0, 11, 99, 128, 4, 165,
				0, 5, 165, 0, 12, 165, 128, 28, 66, 128,
				29, 99, 128, 30, 165, 128, 53, 99, 128, 61,
				165, 128, 60, 165, 0, 54, 99, 128, 55, 99,
				128, 10, 66, 0, 2, 66, 0, 3, 99, 0,
				11, 99, 128, 4, 165, 0, 5, 165, 0, 12,
				165, 128, 28, 66, 128, 29, 99, 128, 30, 165,
				128, 54, 99, 128, 53, 99, 128, 60, 165, 0,
				61, 165, 128, 55, 99, 128
			};
			ushort[] array = new ushort[16]
			{
				0, 1, 2, 4, 6, 8, 10, 14, 16, 28,
				32, 48, 64, 94, 108, 512
			};
			MemorySizeInfo[] array2 = new MemorySizeInfo[162];
			int num = 0;
			int num2 = 0;
			while (num < array2.Length)
			{
				MemorySize elementType = (MemorySize)readOnlySpan[num2];
				uint num3 = (uint)((readOnlySpan[num2 + 2] << 8) | readOnlySpan[num2 + 1]);
				ushort size = array[num3 & 0x1F];
				ushort elementSize = array[(num3 >> 5) & 0x1F];
				array2[num] = new MemorySizeInfo((MemorySize)num, size, elementSize, elementType, (num3 & 0x8000) != 0, num >= 112);
				num++;
				num2 += 3;
			}
			return array2;
		}

		public static MemorySizeInfo GetInfo(this MemorySize memorySize)
		{
			MemorySizeInfo[] memorySizeInfos = MemorySizeInfos;
			if ((uint)memorySize >= (uint)memorySizeInfos.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_memorySize();
			}
			return memorySizeInfos[(int)memorySize];
		}

		public static int GetSize(this MemorySize memorySize)
		{
			return memorySize.GetInfo().Size;
		}

		public static int GetElementSize(this MemorySize memorySize)
		{
			return memorySize.GetInfo().ElementSize;
		}

		public static MemorySize GetElementType(this MemorySize memorySize)
		{
			return memorySize.GetInfo().ElementType;
		}

		public static MemorySizeInfo GetElementTypeInfo(this MemorySize memorySize)
		{
			return memorySize.GetInfo().ElementType.GetInfo();
		}

		public static bool IsSigned(this MemorySize memorySize)
		{
			return memorySize.GetInfo().IsSigned;
		}

		public static bool IsPacked(this MemorySize memorySize)
		{
			return memorySize.GetInfo().IsPacked;
		}

		public static int GetElementCount(this MemorySize memorySize)
		{
			return memorySize.GetInfo().ElementCount;
		}
	}
	public readonly struct MemorySizeInfo
	{
		private readonly ushort size;

		private readonly ushort elementSize;

		private readonly byte memorySize;

		private readonly byte elementType;

		private readonly bool isSigned;

		private readonly bool isBroadcast;

		public MemorySize MemorySize => (MemorySize)memorySize;

		public int Size => size;

		public int ElementSize => elementSize;

		public MemorySize ElementType => (MemorySize)elementType;

		public bool IsSigned => isSigned;

		public bool IsBroadcast => isBroadcast;

		public bool IsPacked => elementSize < size;

		public int ElementCount
		{
			get
			{
				if (elementSize != size)
				{
					return size / elementSize;
				}
				return 1;
			}
		}

		public MemorySizeInfo(MemorySize memorySize, int size, int elementSize, MemorySize elementType, bool isSigned, bool isBroadcast)
		{
			if (size < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_size();
			}
			if (elementSize < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_elementSize();
			}
			if (elementSize > size)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_elementSize();
			}
			this.memorySize = (byte)memorySize;
			this.size = (ushort)size;
			this.elementSize = (ushort)elementSize;
			this.elementType = (byte)elementType;
			this.isSigned = isSigned;
			this.isBroadcast = isBroadcast;
		}
	}
	public enum Mnemonic
	{
		INVALID,
		Aaa,
		Aad,
		Aam,
		Aas,
		Adc,
		Adcx,
		Add,
		Addpd,
		Addps,
		Addsd,
		Addss,
		Addsubpd,
		Addsubps,
		Adox,
		Aesdec,
		Aesdeclast,
		Aesenc,
		Aesenclast,
		Aesimc,
		Aeskeygenassist,
		And,
		Andn,
		Andnpd,
		Andnps,
		Andpd,
		Andps,
		Arpl,
		Bextr,
		Blcfill,
		Blci,
		Blcic,
		Blcmsk,
		Blcs,
		Blendpd,
		Blendps,
		Blendvpd,
		Blendvps,
		Blsfill,
		Blsi,
		Blsic,
		Blsmsk,
		Blsr,
		Bndcl,
		Bndcn,
		Bndcu,
		Bndldx,
		Bndmk,
		Bndmov,
		Bndstx,
		Bound,
		Bsf,
		Bsr,
		Bswap,
		Bt,
		Btc,
		Btr,
		Bts,
		Bzhi,
		Call,
		Cbw,
		Cdq,
		Cdqe,
		Cl1invmb,
		Clac,
		Clc,
		Cld,
		Cldemote,
		Clflush,
		Clflushopt,
		Clgi,
		Cli,
		Clrssbsy,
		Clts,
		Clwb,
		Clzero,
		Cmc,
		Cmova,
		Cmovae,
		Cmovb,
		Cmovbe,
		Cmove,
		Cmovg,
		Cmovge,
		Cmovl,
		Cmovle,
		Cmovne,
		Cmovno,
		Cmovnp,
		Cmovns,
		Cmovo,
		Cmovp,
		Cmovs,
		Cmp,
		Cmppd,
		Cmpps,
		Cmpsb,
		Cmpsd,
		Cmpsq,
		Cmpss,
		Cmpsw,
		Cmpxchg,
		Cmpxchg16b,
		Cmpxchg8b,
		Comisd,
		Comiss,
		Cpuid,
		Cqo,
		Crc32,
		Cvtdq2pd,
		Cvtdq2ps,
		Cvtpd2dq,
		Cvtpd2pi,
		Cvtpd2ps,
		Cvtpi2pd,
		Cvtpi2ps,
		Cvtps2dq,
		Cvtps2pd,
		Cvtps2pi,
		Cvtsd2si,
		Cvtsd2ss,
		Cvtsi2sd,
		Cvtsi2ss,
		Cvtss2sd,
		Cvtss2si,
		Cvttpd2dq,
		Cvttpd2pi,
		Cvttps2dq,
		Cvttps2pi,
		Cvttsd2si,
		Cvttss2si,
		Cwd,
		Cwde,
		Daa,
		Das,
		Db,
		Dd,
		Dec,
		Div,
		Divpd,
		Divps,
		Divsd,
		Divss,
		Dppd,
		Dpps,
		Dq,
		Dw,
		Emms,
		Encls,
		Enclu,
		Enclv,
		Endbr32,
		Endbr64,
		Enqcmd,
		Enqcmds,
		Enter,
		Extractps,
		Extrq,
		F2xm1,
		Fabs,
		Fadd,
		Faddp,
		Fbld,
		Fbstp,
		Fchs,
		Fclex,
		Fcmovb,
		Fcmovbe,
		Fcmove,
		Fcmovnb,
		Fcmovnbe,
		Fcmovne,
		Fcmovnu,
		Fcmovu,
		Fcom,
		Fcomi,
		Fcomip,
		Fcomp,
		Fcompp,
		Fcos,
		Fdecstp,
		Fdisi,
		Fdiv,
		Fdivp,
		Fdivr,
		Fdivrp,
		Femms,
		Feni,
		Ffree,
		Ffreep,
		Fiadd,
		Ficom,
		Ficomp,
		Fidiv,
		Fidivr,
		Fild,
		Fimul,
		Fincstp,
		Finit,
		Fist,
		Fistp,
		Fisttp,
		Fisub,
		Fisubr,
		Fld,
		Fld1,
		Fldcw,
		Fldenv,
		Fldl2e,
		Fldl2t,
		Fldlg2,
		Fldln2,
		Fldpi,
		Fldz,
		Fmul,
		Fmulp,
		Fnclex,
		Fndisi,
		Fneni,
		Fninit,
		Fnop,
		Fnsave,
		Fnsetpm,
		Fnstcw,
		Fnstenv,
		Fnstsw,
		Fpatan,
		Fprem,
		Fprem1,
		Fptan,
		Frndint,
		Frstor,
		Frstpm,
		Fsave,
		Fscale,
		Fsetpm,
		Fsin,
		Fsincos,
		Fsqrt,
		Fst,
		Fstcw,
		Fstdw,
		Fstenv,
		Fstp,
		Fstpnce,
		Fstsg,
		Fstsw,
		Fsub,
		Fsubp,
		Fsubr,
		Fsubrp,
		Ftst,
		Fucom,
		Fucomi,
		Fucomip,
		Fucomp,
		Fucompp,
		Fxam,
		Fxch,
		Fxrstor,
		Fxrstor64,
		Fxsave,
		Fxsave64,
		Fxtract,
		Fyl2x,
		Fyl2xp1,
		Getsec,
		Gf2p8affineinvqb,
		Gf2p8affineqb,
		Gf2p8mulb,
		Haddpd,
		Haddps,
		Hlt,
		Hsubpd,
		Hsubps,
		Ibts,
		Idiv,
		Imul,
		In,
		Inc,
		Incsspd,
		Incsspq,
		Insb,
		Insd,
		Insertps,
		Insertq,
		Insw,
		Int,
		Int1,
		Into,
		Invd,
		Invept,
		Invlpg,
		Invlpga,
		Invpcid,
		Invvpid,
		Iret,
		Ja,
		Jae,
		Jb,
		Jbe,
		Jcxz,
		Je,
		Jecxz,
		Jg,
		Jge,
		Jl,
		Jle,
		Jmp,
		Jmpe,
		Jne,
		Jno,
		Jnp,
		Jns,
		Jo,
		Jp,
		Jrcxz,
		Js,
		Kaddb,
		Kaddd,
		Kaddq,
		Kaddw,
		Kandb,
		Kandd,
		Kandnb,
		Kandnd,
		Kandnq,
		Kandnw,
		Kandq,
		Kandw,
		Kmovb,
		Kmovd,
		Kmovq,
		Kmovw,
		Knotb,
		Knotd,
		Knotq,
		Knotw,
		Korb,
		Kord,
		Korq,
		Kortestb,
		Kortestd,
		Kortestq,
		Kortestw,
		Korw,
		Kshiftlb,
		Kshiftld,
		Kshiftlq,
		Kshiftlw,
		Kshiftrb,
		Kshiftrd,
		Kshiftrq,
		Kshiftrw,
		Ktestb,
		Ktestd,
		Ktestq,
		Ktestw,
		Kunpckbw,
		Kunpckdq,
		Kunpckwd,
		Kxnorb,
		Kxnord,
		Kxnorq,
		Kxnorw,
		Kxorb,
		Kxord,
		Kxorq,
		Kxorw,
		Lahf,
		Lar,
		Lddqu,
		Ldmxcsr,
		Lds,
		Lea,
		Leave,
		Les,
		Lfence,
		Lfs,
		Lgdt,
		Lgs,
		Lidt,
		Lldt,
		Llwpcb,
		Lmsw,
		Loadall,
		Lodsb,
		Lodsd,
		Lodsq,
		Lodsw,
		Loop,
		Loope,
		Loopne,
		Lsl,
		Lss,
		Ltr,
		Lwpins,
		Lwpval,
		Lzcnt,
		Maskmovdqu,
		Maskmovq,
		Maxpd,
		Maxps,
		Maxsd,
		Maxss,
		Mcommit,
		Mfence,
		Minpd,
		Minps,
		Minsd,
		Minss,
		Monitor,
		Monitorx,
		Montmul,
		Mov,
		Movapd,
		Movaps,
		Movbe,
		Movd,
		Movddup,
		Movdir64b,
		Movdiri,
		Movdq2q,
		Movdqa,
		Movdqu,
		Movhlps,
		Movhpd,
		Movhps,
		Movlhps,
		Movlpd,
		Movlps,
		Movmskpd,
		Movmskps,
		Movntdq,
		Movntdqa,
		Movnti,
		Movntpd,
		Movntps,
		Movntq,
		Movntsd,
		Movntss,
		Movq,
		Movq2dq,
		Movsb,
		Movsd,
		Movshdup,
		Movsldup,
		Movsq,
		Movss,
		Movsw,
		Movsx,
		Movsxd,
		Movupd,
		Movups,
		Movzx,
		Mpsadbw,
		Mul,
		Mulpd,
		Mulps,
		Mulsd,
		Mulss,
		Mulx,
		Mwait,
		Mwaitx,
		Neg,
		Nop,
		Not,
		Or,
		Orpd,
		Orps,
		Out,
		Outsb,
		Outsd,
		Outsw,
		Pabsb,
		Pabsd,
		Pabsw,
		Packssdw,
		Packsswb,
		Packusdw,
		Packuswb,
		Paddb,
		Paddd,
		Paddq,
		Paddsb,
		Paddsw,
		Paddusb,
		Paddusw,
		Paddw,
		Palignr,
		Pand,
		Pandn,
		Pause,
		Pavgb,
		Pavgusb,
		Pavgw,
		Pblendvb,
		Pblendw,
		Pclmulqdq,
		Pcmpeqb,
		Pcmpeqd,
		Pcmpeqq,
		Pcmpeqw,
		Pcmpestri,
		Pcmpestri64,
		Pcmpestrm,
		Pcmpestrm64,
		Pcmpgtb,
		Pcmpgtd,
		Pcmpgtq,
		Pcmpgtw,
		Pcmpistri,
		Pcmpistrm,
		Pcommit,
		Pconfig,
		Pdep,
		Pext,
		Pextrb,
		Pextrd,
		Pextrq,
		Pextrw,
		Pf2id,
		Pf2iw,
		Pfacc,
		Pfadd,
		Pfcmpeq,
		Pfcmpge,
		Pfcmpgt,
		Pfmax,
		Pfmin,
		Pfmul,
		Pfnacc,
		Pfpnacc,
		Pfrcp,
		Pfrcpit1,
		Pfrcpit2,
		Pfrcpv,
		Pfrsqit1,
		Pfrsqrt,
		Pfrsqrtv,
		Pfsub,
		Pfsubr,
		Phaddd,
		Phaddsw,
		Phaddw,
		Phminposuw,
		Phsubd,
		Phsubsw,
		Phsubw,
		Pi2fd,
		Pi2fw,
		Pinsrb,
		Pinsrd,
		Pinsrq,
		Pinsrw,
		Pmaddubsw,
		Pmaddwd,
		Pmaxsb,
		Pmaxsd,
		Pmaxsw,
		Pmaxub,
		Pmaxud,
		Pmaxuw,
		Pminsb,
		Pminsd,
		Pminsw,
		Pminub,
		Pminud,
		Pminuw,
		Pmovmskb,
		Pmovsxbd,
		Pmovsxbq,
		Pmovsxbw,
		Pmovsxdq,
		Pmovsxwd,
		Pmovsxwq,
		Pmovzxbd,
		Pmovzxbq,
		Pmovzxbw,
		Pmovzxdq,
		Pmovzxwd,
		Pmovzxwq,
		Pmuldq,
		Pmulhrsw,
		Pmulhrw,
		Pmulhuw,
		Pmulhw,
		Pmulld,
		Pmullw,
		Pmuludq,
		Pop,
		Popa,
		Popcnt,
		Popf,
		Por,
		Prefetch,
		Prefetchnta,
		Prefetcht0,
		Prefetcht1,
		Prefetcht2,
		Prefetchw,
		Prefetchwt1,
		Psadbw,
		Pshufb,
		Pshufd,
		Pshufhw,
		Pshuflw,
		Pshufw,
		Psignb,
		Psignd,
		Psignw,
		Pslld,
		Pslldq,
		Psllq,
		Psllw,
		Psrad,
		Psraw,
		Psrld,
		Psrldq,
		Psrlq,
		Psrlw,
		Psubb,
		Psubd,
		Psubq,
		Psubsb,
		Psubsw,
		Psubusb,
		Psubusw,
		Psubw,
		Pswapd,
		Ptest,
		Ptwrite,
		Punpckhbw,
		Punpckhdq,
		Punpckhqdq,
		Punpckhwd,
		Punpcklbw,
		Punpckldq,
		Punpcklqdq,
		Punpcklwd,
		Push,
		Pusha,
		Pushf,
		Pxor,
		Rcl,
		Rcpps,
		Rcpss,
		Rcr,
		Rdfsbase,
		Rdgsbase,
		Rdmsr,
		Rdpid,
		Rdpkru,
		Rdpmc,
		Rdpru,
		Rdrand,
		Rdseed,
		Rdsspd,
		Rdsspq,
		Rdtsc,
		Rdtscp,
		Reservednop,
		Ret,
		Retf,
		Rol,
		Ror,
		Rorx,
		Roundpd,
		Roundps,
		Roundsd,
		Roundss,
		Rsm,
		Rsqrtps,
		Rsqrtss,
		Rstorssp,
		Sahf,
		Sal,
		Salc,
		Sar,
		Sarx,
		Saveprevssp,
		Sbb,
		Scasb,
		Scasd,
		Scasq,
		Scasw,
		Seta,
		Setae,
		Setb,
		Setbe,
		Sete,
		Setg,
		Setge,
		Setl,
		Setle,
		Setne,
		Setno,
		Setnp,
		Setns,
		Seto,
		Setp,
		Sets,
		Setssbsy,
		Sfence,
		Sgdt,
		Sha1msg1,
		Sha1msg2,
		Sha1nexte,
		Sha1rnds4,
		Sha256msg1,
		Sha256msg2,
		Sha256rnds2,
		Shl,
		Shld,
		Shlx,
		Shr,
		Shrd,
		Shrx,
		Shufpd,
		Shufps,
		Sidt,
		Skinit,
		Sldt,
		Slwpcb,
		Smsw,
		Sqrtpd,
		Sqrtps,
		Sqrtsd,
		Sqrtss,
		Stac,
		Stc,
		Std,
		Stgi,
		Sti,
		Stmxcsr,
		Stosb,
		Stosd,
		Stosq,
		Stosw,
		Str,
		Sub,
		Subpd,
		Subps,
		Subsd,
		Subss,
		Swapgs,
		Syscall,
		Sysenter,
		Sysexit,
		Sysret,
		T1mskc,
		Test,
		Tpause,
		Tzcnt,
		Tzmsk,
		Ucomisd,
		Ucomiss,
		Ud0,
		Ud1,
		Ud2,
		Umonitor,
		Umov,
		Umwait,
		Unpckhpd,
		Unpckhps,
		Unpcklpd,
		Unpcklps,
		V4fmaddps,
		V4fmaddss,
		V4fnmaddps,
		V4fnmaddss,
		Vaddpd,
		Vaddps,
		Vaddsd,
		Vaddss,
		Vaddsubpd,
		Vaddsubps,
		Vaesdec,
		Vaesdeclast,
		Vaesenc,
		Vaesenclast,
		Vaesimc,
		Vaeskeygenassist,
		Valignd,
		Valignq,
		Vandnpd,
		Vandnps,
		Vandpd,
		Vandps,
		Vblendmpd,
		Vblendmps,
		Vblendpd,
		Vblendps,
		Vblendvpd,
		Vblendvps,
		Vbroadcastf128,
		Vbroadcastf32x2,
		Vbroadcastf32x4,
		Vbroadcastf32x8,
		Vbroadcastf64x2,
		Vbroadcastf64x4,
		Vbroadcasti128,
		Vbroadcasti32x2,
		Vbroadcasti32x4,
		Vbroadcasti32x8,
		Vbroadcasti64x2,
		Vbroadcasti64x4,
		Vbroadcastsd,
		Vbroadcastss,
		Vcmppd,
		Vcmpps,
		Vcmpsd,
		Vcmpss,
		Vcomisd,
		Vcomiss,
		Vcompresspd,
		Vcompressps,
		Vcvtdq2pd,
		Vcvtdq2ps,
		Vcvtne2ps2bf16,
		Vcvtneps2bf16,
		Vcvtpd2dq,
		Vcvtpd2ps,
		Vcvtpd2qq,
		Vcvtpd2udq,
		Vcvtpd2uqq,
		Vcvtph2ps,
		Vcvtps2dq,
		Vcvtps2pd,
		Vcvtps2ph,
		Vcvtps2qq,
		Vcvtps2udq,
		Vcvtps2uqq,
		Vcvtqq2pd,
		Vcvtqq2ps,
		Vcvtsd2si,
		Vcvtsd2ss,
		Vcvtsd2usi,
		Vcvtsi2sd,
		Vcvtsi2ss,
		Vcvtss2sd,
		Vcvtss2si,
		Vcvtss2usi,
		Vcvttpd2dq,
		Vcvttpd2qq,
		Vcvttpd2udq,
		Vcvttpd2uqq,
		Vcvttps2dq,
		Vcvttps2qq,
		Vcvttps2udq,
		Vcvttps2uqq,
		Vcvttsd2si,
		Vcvttsd2usi,
		Vcvttss2si,
		Vcvttss2usi,
		Vcvtudq2pd,
		Vcvtudq2ps,
		Vcvtuqq2pd,
		Vcvtuqq2ps,
		Vcvtusi2sd,
		Vcvtusi2ss,
		Vdbpsadbw,
		Vdivpd,
		Vdivps,
		Vdivsd,
		Vdivss,
		Vdpbf16ps,
		Vdppd,
		Vdpps,
		Verr,
		Verw,
		Vexp2pd,
		Vexp2ps,
		Vexpandpd,
		Vexpandps,
		Vextractf128,
		Vextractf32x4,
		Vextractf32x8,
		Vextractf64x2,
		Vextractf64x4,
		Vextracti128,
		Vextracti32x4,
		Vextracti32x8,
		Vextracti64x2,
		Vextracti64x4,
		Vextractps,
		Vfixupimmpd,
		Vfixupimmps,
		Vfixupimmsd,
		Vfixupimmss,
		Vfmadd132pd,
		Vfmadd132ps,
		Vfmadd132sd,
		Vfmadd132ss,
		Vfmadd213pd,
		Vfmadd213ps,
		Vfmadd213sd,
		Vfmadd213ss,
		Vfmadd231pd,
		Vfmadd231ps,
		Vfmadd231sd,
		Vfmadd231ss,
		Vfmaddpd,
		Vfmaddps,
		Vfmaddsd,
		Vfmaddss,
		Vfmaddsub132pd,
		Vfmaddsub132ps,
		Vfmaddsub213pd,
		Vfmaddsub213ps,
		Vfmaddsub231pd,
		Vfmaddsub231ps,
		Vfmaddsubpd,
		Vfmaddsubps,
		Vfmsub132pd,
		Vfmsub132ps,
		Vfmsub132sd,
		Vfmsub132ss,
		Vfmsub213pd,
		Vfmsub213ps,
		Vfmsub213sd,
		Vfmsub213ss,
		Vfmsub231pd,
		Vfmsub231ps,
		Vfmsub231sd,
		Vfmsub231ss,
		Vfmsubadd132pd,
		Vfmsubadd132ps,
		Vfmsubadd213pd,
		Vfmsubadd213ps,
		Vfmsubadd231pd,
		Vfmsubadd231ps,
		Vfmsubaddpd,
		Vfmsubaddps,
		Vfmsubpd,
		Vfmsubps,
		Vfmsubsd,
		Vfmsubss,
		Vfnmadd132pd,
		Vfnmadd132ps,
		Vfnmadd132sd,
		Vfnmadd132ss,
		Vfnmadd213pd,
		Vfnmadd213ps,
		Vfnmadd213sd,
		Vfnmadd213ss,
		Vfnmadd231pd,
		Vfnmadd231ps,
		Vfnmadd231sd,
		Vfnmadd231ss,
		Vfnmaddpd,
		Vfnmaddps,
		Vfnmaddsd,
		Vfnmaddss,
		Vfnmsub132pd,
		Vfnmsub132ps,
		Vfnmsub132sd,
		Vfnmsub132ss,
		Vfnmsub213pd,
		Vfnmsub213ps,
		Vfnmsub213sd,
		Vfnmsub213ss,
		Vfnmsub231pd,
		Vfnmsub231ps,
		Vfnmsub231sd,
		Vfnmsub231ss,
		Vfnmsubpd,
		Vfnmsubps,
		Vfnmsubsd,
		Vfnmsubss,
		Vfpclasspd,
		Vfpclassps,
		Vfpclasssd,
		Vfpclassss,
		Vfrczpd,
		Vfrczps,
		Vfrczsd,
		Vfrczss,
		Vgatherdpd,
		Vgatherdps,
		Vgatherpf0dpd,
		Vgatherpf0dps,
		Vgatherpf0qpd,
		Vgatherpf0qps,
		Vgatherpf1dpd,
		Vgatherpf1dps,
		Vgatherpf1qpd,
		Vgatherpf1qps,
		Vgatherqpd,
		Vgatherqps,
		Vgetexppd,
		Vgetexpps,
		Vgetexpsd,
		Vgetexpss,
		Vgetmantpd,
		Vgetmantps,
		Vgetmantsd,
		Vgetmantss,
		Vgf2p8affineinvqb,
		Vgf2p8affineqb,
		Vgf2p8mulb,
		Vhaddpd,
		Vhaddps,
		Vhsubpd,
		Vhsubps,
		Vinsertf128,
		Vinsertf32x4,
		Vinsertf32x8,
		Vinsertf64x2,
		Vinsertf64x4,
		Vinserti128,
		Vinserti32x4,
		Vinserti32x8,
		Vinserti64x2,
		Vinserti64x4,
		Vinsertps,
		Vlddqu,
		Vldmxcsr,
		Vmaskmovdqu,
		Vmaskmovpd,
		Vmaskmovps,
		Vmaxpd,
		Vmaxps,
		Vmaxsd,
		Vmaxss,
		Vmcall,
		Vmclear,
		Vmfunc,
		Vminpd,
		Vminps,
		Vminsd,
		Vminss,
		Vmlaunch,
		Vmload,
		Vmmcall,
		Vmovapd,
		Vmovaps,
		Vmovd,
		Vmovddup,
		Vmovdqa,
		Vmovdqa32,
		Vmovdqa64,
		Vmovdqu,
		Vmovdqu16,
		Vmovdqu32,
		Vmovdqu64,
		Vmovdqu8,
		Vmovhlps,
		Vmovhpd,
		Vmovhps,
		Vmovlhps,
		Vmovlpd,
		Vmovlps,
		Vmovmskpd,
		Vmovmskps,
		Vmovntdq,
		Vmovntdqa,
		Vmovntpd,
		Vmovntps,
		Vmovq,
		Vmovsd,
		Vmovshdup,
		Vmovsldup,
		Vmovss,
		Vmovupd,
		Vmovups,
		Vmpsadbw,
		Vmptrld,
		Vmptrst,
		Vmread,
		Vmresume,
		Vmrun,
		Vmsave,
		Vmulpd,
		Vmulps,
		Vmulsd,
		Vmulss,
		Vmwrite,
		Vmxoff,
		Vmxon,
		Vorpd,
		Vorps,
		Vp2intersectd,
		Vp2intersectq,
		Vp4dpwssd,
		Vp4dpwssds,
		Vpabsb,
		Vpabsd,
		Vpabsq,
		Vpabsw,
		Vpackssdw,
		Vpacksswb,
		Vpackusdw,
		Vpackuswb,
		Vpaddb,
		Vpaddd,
		Vpaddq,
		Vpaddsb,
		Vpaddsw,
		Vpaddusb,
		Vpaddusw,
		Vpaddw,
		Vpalignr,
		Vpand,
		Vpandd,
		Vpandn,
		Vpandnd,
		Vpandnq,
		Vpandq,
		Vpavgb,
		Vpavgw,
		Vpblendd,
		Vpblendmb,
		Vpblendmd,
		Vpblendmq,
		Vpblendmw,
		Vpblendvb,
		Vpblendw,
		Vpbroadcastb,
		Vpbroadcastd,
		Vpbroadcastmb2q,
		Vpbroadcastmw2d,
		Vpbroadcastq,
		Vpbroadcastw,
		Vpclmulqdq,
		Vpcmov,
		Vpcmpb,
		Vpcmpd,
		Vpcmpeqb,
		Vpcmpeqd,
		Vpcmpeqq,
		Vpcmpeqw,
		Vpcmpestri,
		Vpcmpestri64,
		Vpcmpestrm,
		Vpcmpestrm64,
		Vpcmpgtb,
		Vpcmpgtd,
		Vpcmpgtq,
		Vpcmpgtw,
		Vpcmpistri,
		Vpcmpistrm,
		Vpcmpq,
		Vpcmpub,
		Vpcmpud,
		Vpcmpuq,
		Vpcmpuw,
		Vpcmpw,
		Vpcomb,
		Vpcomd,
		Vpcompressb,
		Vpcompressd,
		Vpcompressq,
		Vpcompressw,
		Vpcomq,
		Vpcomub,
		Vpcomud,
		Vpcomuq,
		Vpcomuw,
		Vpcomw,
		Vpconflictd,
		Vpconflictq,
		Vpdpbusd,
		Vpdpbusds,
		Vpdpwssd,
		Vpdpwssds,
		Vperm2f128,
		Vperm2i128,
		Vpermb,
		Vpermd,
		Vpermi2b,
		Vpermi2d,
		Vpermi2pd,
		Vpermi2ps,
		Vpermi2q,
		Vpermi2w,
		Vpermil2pd,
		Vpermil2ps,
		Vpermilpd,
		Vpermilps,
		Vpermpd,
		Vpermps,
		Vpermq,
		Vpermt2b,
		Vpermt2d,
		Vpermt2pd,
		Vpermt2ps,
		Vpermt2q,
		Vpermt2w,
		Vpermw,
		Vpexpandb,
		Vpexpandd,
		Vpexpandq,
		Vpexpandw,
		Vpextrb,
		Vpextrd,
		Vpextrq,
		Vpextrw,
		Vpgatherdd,
		Vpgatherdq,
		Vpgatherqd,
		Vpgatherqq,
		Vphaddbd,
		Vphaddbq,
		Vphaddbw,
		Vphaddd,
		Vphadddq,
		Vphaddsw,
		Vphaddubd,
		Vphaddubq,
		Vphaddubw,
		Vphaddudq,
		Vphadduwd,
		Vphadduwq,
		Vphaddw,
		Vphaddwd,
		Vphaddwq,
		Vphminposuw,
		Vphsubbw,
		Vphsubd,
		Vphsubdq,
		Vphsubsw,
		Vphsubw,
		Vphsubwd,
		Vpinsrb,
		Vpinsrd,
		Vpinsrq,
		Vpinsrw,
		Vplzcntd,
		Vplzcntq,
		Vpmacsdd,
		Vpmacsdqh,
		Vpmacsdql,
		Vpmacssdd,
		Vpmacssdqh,
		Vpmacssdql,
		Vpmacsswd,
		Vpmacssww,
		Vpmacswd,
		Vpmacsww,
		Vpmadcsswd,
		Vpmadcswd,
		Vpmadd52huq,
		Vpmadd52luq,
		Vpmaddubsw,
		Vpmaddwd,
		Vpmaskmovd,
		Vpmaskmovq,
		Vpmaxsb,
		Vpmaxsd,
		Vpmaxsq,
		Vpmaxsw,
		Vpmaxub,
		Vpmaxud,
		Vpmaxuq,
		Vpmaxuw,
		Vpminsb,
		Vpminsd,
		Vpminsq,
		Vpminsw,
		Vpminub,
		Vpminud,
		Vpminuq,
		Vpminuw,
		Vpmovb2m,
		Vpmovd2m,
		Vpmovdb,
		Vpmovdw,
		Vpmovm2b,
		Vpmovm2d,
		Vpmovm2q,
		Vpmovm2w,
		Vpmovmskb,
		Vpmovq2m,
		Vpmovqb,
		Vpmovqd,
		Vpmovqw,
		Vpmovsdb,
		Vpmovsdw,
		Vpmovsqb,
		Vpmovsqd,
		Vpmovsqw,
		Vpmovswb,
		Vpmovsxbd,
		Vpmovsxbq,
		Vpmovsxbw,
		Vpmovsxdq,
		Vpmovsxwd,
		Vpmovsxwq,
		Vpmovusdb,
		Vpmovusdw,
		Vpmovusqb,
		Vpmovusqd,
		Vpmovusqw,
		Vpmovuswb,
		Vpmovw2m,
		Vpmovwb,
		Vpmovzxbd,
		Vpmovzxbq,
		Vpmovzxbw,
		Vpmovzxdq,
		Vpmovzxwd,
		Vpmovzxwq,
		Vpmuldq,
		Vpmulhrsw,
		Vpmulhuw,
		Vpmulhw,
		Vpmulld,
		Vpmullq,
		Vpmullw,
		Vpmultishiftqb,
		Vpmuludq,
		Vpopcntb,
		Vpopcntd,
		Vpopcntq,
		Vpopcntw,
		Vpor,
		Vpord,
		Vporq,
		Vpperm,
		Vprold,
		Vprolq,
		Vprolvd,
		Vprolvq,
		Vprord,
		Vprorq,
		Vprorvd,
		Vprorvq,
		Vprotb,
		Vprotd,
		Vprotq,
		Vprotw,
		Vpsadbw,
		Vpscatterdd,
		Vpscatterdq,
		Vpscatterqd,
		Vpscatterqq,
		Vpshab,
		Vpshad,
		Vpshaq,
		Vpshaw,
		Vpshlb,
		Vpshld,
		Vpshldd,
		Vpshldq,
		Vpshldvd,
		Vpshldvq,
		Vpshldvw,
		Vpshldw,
		Vpshlq,
		Vpshlw,
		Vpshrdd,
		Vpshrdq,
		Vpshrdvd,
		Vpshrdvq,
		Vpshrdvw,
		Vpshrdw,
		Vpshufb,
		Vpshufbitqmb,
		Vpshufd,
		Vpshufhw,
		Vpshuflw,
		Vpsignb,
		Vpsignd,
		Vpsignw,
		Vpslld,
		Vpslldq,
		Vpsllq,
		Vpsllvd,
		Vpsllvq,
		Vpsllvw,
		Vpsllw,
		Vpsrad,
		Vpsraq,
		Vpsravd,
		Vpsravq,
		Vpsravw,
		Vpsraw,
		Vpsrld,
		Vpsrldq,
		Vpsrlq,
		Vpsrlvd,
		Vpsrlvq,
		Vpsrlvw,
		Vpsrlw,
		Vpsubb,
		Vpsubd,
		Vpsubq,
		Vpsubsb,
		Vpsubsw,
		Vpsubusb,
		Vpsubusw,
		Vpsubw,
		Vpternlogd,
		Vpternlogq,
		Vptest,
		Vptestmb,
		Vptestmd,
		Vptestmq,
		Vptestmw,
		Vptestnmb,
		Vptestnmd,
		Vptestnmq,
		Vptestnmw,
		Vpunpckhbw,
		Vpunpckhdq,
		Vpunpckhqdq,
		Vpunpckhwd,
		Vpunpcklbw,
		Vpunpckldq,
		Vpunpcklqdq,
		Vpunpcklwd,
		Vpxor,
		Vpxord,
		Vpxorq,
		Vrangepd,
		Vrangeps,
		Vrangesd,
		Vrangess,
		Vrcp14pd,
		Vrcp14ps,
		Vrcp14sd,
		Vrcp14ss,
		Vrcp28pd,
		Vrcp28ps,
		Vrcp28sd,
		Vrcp28ss,
		Vrcpps,
		Vrcpss,
		Vreducepd,
		Vreduceps,
		Vreducesd,
		Vreducess,
		Vrndscalepd,
		Vrndscaleps,
		Vrndscalesd,
		Vrndscaless,
		Vroundpd,
		Vroundps,
		Vroundsd,
		Vroundss,
		Vrsqrt14pd,
		Vrsqrt14ps,
		Vrsqrt14sd,
		Vrsqrt14ss,
		Vrsqrt28pd,
		Vrsqrt28ps,
		Vrsqrt28sd,
		Vrsqrt28ss,
		Vrsqrtps,
		Vrsqrtss,
		Vscalefpd,
		Vscalefps,
		Vscalefsd,
		Vscalefss,
		Vscatterdpd,
		Vscatterdps,
		Vscatterpf0dpd,
		Vscatterpf0dps,
		Vscatterpf0qpd,
		Vscatterpf0qps,
		Vscatterpf1dpd,
		Vscatterpf1dps,
		Vscatterpf1qpd,
		Vscatterpf1qps,
		Vscatterqpd,
		Vscatterqps,
		Vshuff32x4,
		Vshuff64x2,
		Vshufi32x4,
		Vshufi64x2,
		Vshufpd,
		Vshufps,
		Vsqrtpd,
		Vsqrtps,
		Vsqrtsd,
		Vsqrtss,
		Vstmxcsr,
		Vsubpd,
		Vsubps,
		Vsubsd,
		Vsubss,
		Vtestpd,
		Vtestps,
		Vucomisd,
		Vucomiss,
		Vunpckhpd,
		Vunpckhps,
		Vunpcklpd,
		Vunpcklps,
		Vxorpd,
		Vxorps,
		Vzeroall,
		Vzeroupper,
		Wait,
		Wbinvd,
		Wbnoinvd,
		Wrfsbase,
		Wrgsbase,
		Wrmsr,
		Wrpkru,
		Wrssd,
		Wrssq,
		Wrussd,
		Wrussq,
		Xabort,
		Xadd,
		Xbegin,
		Xbts,
		Xchg,
		Xcryptcbc,
		Xcryptcfb,
		Xcryptctr,
		Xcryptecb,
		Xcryptofb,
		Xend,
		Xgetbv,
		Xlatb,
		Xor,
		Xorpd,
		Xorps,
		Xrstor,
		Xrstor64,
		Xrstors,
		Xrstors64,
		Xsave,
		Xsave64,
		Xsavec,
		Xsavec64,
		Xsaveopt,
		Xsaveopt64,
		Xsaves,
		Xsaves64,
		Xsetbv,
		Xsha1,
		Xsha256,
		Xstore,
		Xtest,
		Rmpadjust,
		Rmpupdate,
		Psmash,
		Pvalidate,
		Serialize,
		Xsusldtrk,
		Xresldtrk,
		Invlpgb,
		Tlbsync,
		Vmgexit,
		Getsecq,
		Sysexitq,
		Ldtilecfg,
		Tilerelease,
		Sttilecfg,
		Tilezero,
		Tileloaddt1,
		Tilestored,
		Tileloadd,
		Tdpbf16ps,
		Tdpbuud,
		Tdpbusd,
		Tdpbsud,
		Tdpbssd,
		Sysretq,
		Fnstdw,
		Fnstsg,
		Rdshr,
		Wrshr,
		Smint,
		Dmint,
		Rdm,
		Svdc,
		Rsdc,
		Svldt,
		Rsldt,
		Svts,
		Rsts,
		Bb0_reset,
		Bb1_reset,
		Cpu_write,
		Cpu_read,
		Altinst,
		Paveb,
		Paddsiw,
		Pmagw,
		Pdistib,
		Psubsiw,
		Pmvzb,
		Pmvnzb,
		Pmvlzb,
		Pmvgezb,
		Pmulhriw,
		Pmachriw,
		Ftstp,
		Frint2,
		Frichop,
		Frinear,
		Undoc,
		Tdcall,
		Seamret,
		Seamops,
		Seamcall,
		Aesencwide128kl,
		Aesdecwide128kl,
		Aesencwide256kl,
		Aesdecwide256kl,
		Loadiwkey,
		Aesenc128kl,
		Aesdec128kl,
		Aesenc256kl,
		Aesdec256kl,
		Encodekey128,
		Encodekey256,
		Pushad,
		Popad,
		Pushfd,
		Pushfq,
		Popfd,
		Popfq,
		Iretd,
		Iretq,
		Int3,
		Uiret,
		Testui,
		Clui,
		Stui,
		Senduipi,
		Hreset,
		Ccs_hash,
		Ccs_encrypt,
		Lkgs,
		Eretu,
		Erets,
		Storeall,
		Vaddph,
		Vaddsh,
		Vcmpph,
		Vcmpsh,
		Vcomish,
		Vcvtdq2ph,
		Vcvtpd2ph,
		Vcvtph2dq,
		Vcvtph2pd,
		Vcvtph2psx,
		Vcvtph2qq,
		Vcvtph2udq,
		Vcvtph2uqq,
		Vcvtph2uw,
		Vcvtph2w,
		Vcvtps2phx,
		Vcvtqq2ph,
		Vcvtsd2sh,
		Vcvtsh2sd,
		Vcvtsh2si,
		Vcvtsh2ss,
		Vcvtsh2usi,
		Vcvtsi2sh,
		Vcvtss2sh,
		Vcvttph2dq,
		Vcvttph2qq,
		Vcvttph2udq,
		Vcvttph2uqq,
		Vcvttph2uw,
		Vcvttph2w,
		Vcvttsh2si,
		Vcvttsh2usi,
		Vcvtudq2ph,
		Vcvtuqq2ph,
		Vcvtusi2sh,
		Vcvtuw2ph,
		Vcvtw2ph,
		Vdivph,
		Vdivsh,
		Vfcmaddcph,
		Vfmaddcph,
		Vfcmaddcsh,
		Vfmaddcsh,
		Vfcmulcph,
		Vfmulcph,
		Vfcmulcsh,
		Vfmulcsh,
		Vfmaddsub132ph,
		Vfmaddsub213ph,
		Vfmaddsub231ph,
		Vfmsubadd132ph,
		Vfmsubadd213ph,
		Vfmsubadd231ph,
		Vfmadd132ph,
		Vfmadd213ph,
		Vfmadd231ph,
		Vfnmadd132ph,
		Vfnmadd213ph,
		Vfnmadd231ph,
		Vfmadd132sh,
		Vfmadd213sh,
		Vfmadd231sh,
		Vfnmadd132sh,
		Vfnmadd213sh,
		Vfnmadd231sh,
		Vfmsub132ph,
		Vfmsub213ph,
		Vfmsub231ph,
		Vfnmsub132ph,
		Vfnmsub213ph,
		Vfnmsub231ph,
		Vfmsub132sh,
		Vfmsub213sh,
		Vfmsub231sh,
		Vfnmsub132sh,
		Vfnmsub213sh,
		Vfnmsub231sh,
		Vfpclassph,
		Vfpclasssh,
		Vgetexpph,
		Vgetexpsh,
		Vgetmantph,
		Vgetmantsh,
		Vmaxph,
		Vmaxsh,
		Vminph,
		Vminsh,
		Vmovsh,
		Vmovw,
		Vmulph,
		Vmulsh,
		Vrcpph,
		Vrcpsh,
		Vreduceph,
		Vreducesh,
		Vrndscaleph,
		Vrndscalesh,
		Vrsqrtph,
		Vrsqrtsh,
		Vscalefph,
		Vscalefsh,
		Vsqrtph,
		Vsqrtsh,
		Vsubph,
		Vsubsh,
		Vucomish,
		Rdudbg,
		Wrudbg,
		Clevict0,
		Clevict1,
		Delay,
		Jknzd,
		Jkzd,
		Kand,
		Kandn,
		Kandnr,
		Kconcath,
		Kconcatl,
		Kextract,
		Kmerge2l1h,
		Kmerge2l1l,
		Kmov,
		Knot,
		Kor,
		Kortest,
		Kxnor,
		Kxor,
		Spflt,
		Tzcnti,
		Vaddnpd,
		Vaddnps,
		Vaddsetsps,
		Vcvtfxpntdq2ps,
		Vcvtfxpntpd2dq,
		Vcvtfxpntpd2udq,
		Vcvtfxpntps2dq,
		Vcvtfxpntps2udq,
		Vcvtfxpntudq2ps,
		Vexp223ps,
		Vfixupnanpd,
		Vfixupnanps,
		Vfmadd233ps,
		Vgatherpf0hintdpd,
		Vgatherpf0hintdps,
		Vgmaxabsps,
		Vgmaxpd,
		Vgmaxps,
		Vgminpd,
		Vgminps,
		Vloadunpackhd,
		Vloadunpackhpd,
		Vloadunpackhps,
		Vloadunpackhq,
		Vloadunpackld,
		Vloadunpacklpd,
		Vloadunpacklps,
		Vloadunpacklq,
		Vlog2ps,
		Vmovnrapd,
		Vmovnraps,
		Vmovnrngoapd,
		Vmovnrngoaps,
		Vpackstorehd,
		Vpackstorehpd,
		Vpackstorehps,
		Vpackstorehq,
		Vpackstoreld,
		Vpackstorelpd,
		Vpackstorelps,
		Vpackstorelq,
		Vpadcd,
		Vpaddsetcd,
		Vpaddsetsd,
		Vpcmpltd,
		Vpermf32x4,
		Vpmadd231d,
		Vpmadd233d,
		Vpmulhd,
		Vpmulhud,
		Vprefetch0,
		Vprefetch1,
		Vprefetch2,
		Vprefetche0,
		Vprefetche1,
		Vprefetche2,
		Vprefetchenta,
		Vprefetchnta,
		Vpsbbd,
		Vpsbbrd,
		Vpsubrd,
		Vpsubrsetbd,
		Vpsubsetbd,
		Vrcp23ps,
		Vrndfxpntpd,
		Vrndfxpntps,
		Vrsqrt23ps,
		Vscaleps,
		Vscatterpf0hintdpd,
		Vscatterpf0hintdps,
		Vsubrpd,
		Vsubrps,
		Xsha512,
		Xstore_alt,
		Xsha512_alt,
		Zero_bytes,
		Aadd,
		Aand,
		Aor,
		Axor,
		Cmpbexadd,
		Cmpbxadd,
		Cmplexadd,
		Cmplxadd,
		Cmpnbexadd,
		Cmpnbxadd,
		Cmpnlexadd,
		Cmpnlxadd,
		Cmpnoxadd,
		Cmpnpxadd,
		Cmpnsxadd,
		Cmpnzxadd,
		Cmpoxadd,
		Cmppxadd,
		Cmpsxadd,
		Cmpzxadd,
		Prefetchit0,
		Prefetchit1,
		Rdmsrlist,
		Rmpquery,
		Tdpfp16ps,
		Vbcstnebf162ps,
		Vbcstnesh2ps,
		Vcvtneebf162ps,
		Vcvtneeph2ps,
		Vcvtneobf162ps,
		Vcvtneoph2ps,
		Vpdpbssd,
		Vpdpbssds,
		Vpdpbsud,
		Vpdpbsuds,
		Vpdpbuud,
		Vpdpbuuds,
		Wrmsrlist,
		Wrmsrns,
		Tcmmrlfp16ps,
		Tcmmimfp16ps,
		Pbndkb,
		Vpdpwsud,
		Vpdpwsuds,
		Vpdpwusd,
		Vpdpwusds,
		Vpdpwuud,
		Vpdpwuuds,
		Vsha512msg1,
		Vsha512msg2,
		Vsha512rnds2,
		Vsm3msg1,
		Vsm3msg2,
		Vsm3rnds2,
		Vsm4key4,
		Vsm4rnds4
	}
	public static class MnemonicUtils
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Mnemonic Mnemonic(this Code code)
		{
			return (Mnemonic)MnemonicUtilsData.toMnemonic[(int)code];
		}
	}
	internal static class MnemonicUtilsData
	{
		internal static readonly ushort[] toMnemonic = new ushort[4936]
		{
			0, 135, 146, 136, 145, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 7, 640, 640, 590,
			590, 467, 467, 467, 467, 467, 467, 467, 467, 467,
			467, 467, 467, 640, 640, 590, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 640, 640,
			590, 590, 681, 681, 681, 681, 681, 681, 681, 681,
			681, 681, 681, 681, 640, 640, 590, 590, 21, 21,
			21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
			133, 740, 740, 740, 740, 740, 740, 740, 740, 740,
			740, 740, 740, 134, 1518, 1518, 1518, 1518, 1518, 1518,
			1518, 1518, 1518, 1518, 1518, 1518, 1, 93, 93, 93,
			93, 93, 93, 93, 93, 93, 93, 93, 93, 4,
			279, 279, 137, 137, 640, 640, 640, 590, 590, 590,
			641, 1612, 591, 1613, 50, 50, 27, 27, 451, 451,
			451, 640, 640, 640, 277, 277, 277, 640, 640, 640,
			277, 277, 277, 282, 286, 283, 471, 473, 472, 314,
			314, 314, 311, 311, 311, 299, 299, 299, 298, 298,
			298, 302, 302, 302, 310, 310, 310, 300, 300, 300,
			297, 297, 297, 317, 317, 317, 313, 313, 313, 315,
			315, 315, 312, 312, 312, 306, 306, 306, 305, 305,
			305, 307, 307, 307, 304, 304, 304, 7, 467, 5,
			681, 21, 740, 1518, 93, 7, 7, 7, 467, 467,
			467, 5, 5, 5, 681, 681, 681, 21, 21, 21,
			740, 740, 740, 1518, 1518, 1518, 93, 93, 93, 7,
			467, 5, 681, 21, 740, 1518, 93, 7, 7, 7,
			467, 467, 467, 5, 5, 5, 681, 681, 681, 21,
			21, 21, 740, 740, 740, 1518, 1518, 1518, 93, 93,
			93, 751, 751, 751, 751, 1509, 1509, 1509, 1509, 414,
			414, 414, 414, 414, 414, 414, 414, 414, 414, 414,
			374, 374, 374, 414, 414, 414, 590, 590, 590, 465,
			465, 465, 1509, 1509, 1509, 492, 60, 132, 62, 131,
			61, 107, 59, 59, 1494, 642, 1614, 1615, 593, 1616,
			1617, 675, 369, 414, 414, 414, 414, 414, 414, 414,
			414, 443, 449, 444, 447, 96, 100, 97, 98, 751,
			751, 751, 751, 735, 738, 736, 737, 386, 389, 387,
			388, 682, 685, 683, 684, 414, 414, 414, 414, 664,
			665, 644, 647, 712, 715, 676, 678, 664, 664, 664,
			665, 665, 665, 644, 644, 644, 647, 647, 647, 712,
			712, 712, 715, 715, 715, 676, 676, 676, 678, 678,
			678, 662, 662, 662, 662, 662, 662, 376, 376, 373,
			373, 414, 1505, 414, 414, 414, 1507, 1507, 155, 155,
			155, 375, 375, 375, 663, 663, 663, 663, 663, 663,
			1620, 287, 289, 296, 1618, 1619, 664, 665, 644, 647,
			712, 715, 676, 678, 664, 664, 664, 665, 665, 665,
			644, 644, 644, 647, 647, 647, 712, 712, 712, 715,
			715, 715, 676, 676, 676, 678, 678, 678, 664, 665,
			644, 647, 712, 715, 676, 678, 664, 664, 664, 665,
			665, 665, 644, 644, 644, 647, 647, 647, 712, 712,
			712, 715, 715, 715, 676, 676, 676, 678, 678, 678,
			3, 2, 677, 1517, 160, 214, 174, 177, 247, 249,
			182, 184, 160, 214, 174, 177, 247, 249, 182, 184,
			204, 239, 243, 207, 207, 206, 224, 242, 224, 242,
			223, 240, 204, 258, 220, 244, 164, 159, 251, 257,
			205, 209, 208, 212, 210, 211, 213, 158, 264, 229,
			226, 263, 228, 180, 197, 227, 265, 238, 237, 230,
			234, 236, 179, 190, 196, 191, 192, 202, 203, 193,
			194, 166, 168, 167, 173, 256, 195, 201, 199, 200,
			204, 243, 169, 171, 170, 172, 218, 187, 217, 181,
			216, 165, 219, 198, 222, 235, 232, 253, 175, 160,
			214, 174, 177, 247, 249, 182, 184, 160, 214, 174,
			177, 249, 247, 184, 182, 204, 201, 239, 243, 231,
			231, 221, 233, 221, 233, 225, 246, 188, 258, 239,
			243, 252, 255, 190, 196, 191, 192, 202, 203, 193,
			194, 161, 215, 177, 178, 250, 248, 185, 183, 195,
			201, 199, 200, 162, 195, 163, 200, 189, 258, 243,
			243, 225, 246, 241, 245, 254, 176, 392, 392, 392,
			392, 392, 392, 392, 391, 391, 391, 391, 391, 391,
			391, 390, 390, 390, 390, 390, 390, 390, 301, 301,
			303, 303, 303, 316, 316, 278, 278, 278, 470, 470,
			470, 59, 59, 59, 308, 308, 308, 308, 308, 308,
			308, 308, 278, 278, 278, 470, 470, 470, 288, 272,
			76, 751, 751, 466, 464, 456, 277, 138, 276, 751,
			751, 751, 751, 751, 751, 466, 466, 466, 464, 464,
			464, 456, 456, 456, 277, 277, 277, 138, 138, 138,
			276, 276, 276, 65, 730, 71, 733, 66, 731, 279,
			137, 279, 279, 279, 137, 137, 137, 59, 59, 59,
			59, 59, 59, 308, 308, 308, 308, 308, 308, 640,
			640, 640, 722, 722, 722, 739, 739, 739, 382, 382,
			382, 395, 395, 395, 869, 869, 869, 870, 870, 870,
			309, 309, 704, 704, 704, 720, 720, 720, 379, 379,
			379, 381, 381, 381, 724, 724, 724, 674, 384, 384,
			384, 292, 150, 1025, 1032, 1070, 1078, 514, 411, 411,
			411, 462, 64, 729, 148, 1516, 1533, 1027, 1515, 1537,
			149, 1071, 1071, 1071, 1034, 1033, 1033, 1033, 1072, 1072,
			1072, 732, 70, 721, 293, 293, 293, 702, 680, 652,
			1500, 745, 660, 412, 412, 412, 405, 463, 75, 75,
			75, 654, 370, 370, 370, 393, 393, 393, 1632, 385,
			746, 73, 385, 749, 1562, 290, 1495, 1496, 63, 759,
			661, 661, 661, 595, 600, 601, 186, 761, 761, 761,
			761, 761, 761, 453, 1065, 1065, 1065, 1065, 1065, 452,
			1064, 1064, 1064, 1064, 1064, 448, 1063, 1063, 1063, 1063,
			444, 1060, 1060, 1060, 1060, 453, 1065, 1065, 1065, 1065,
			1065, 452, 1064, 1064, 1064, 1064, 1064, 448, 1063, 1063,
			1063, 1063, 444, 1060, 1060, 1060, 1060, 425, 430, 1047,
			1052, 1047, 1052, 429, 1051, 1051, 446, 1062, 1062, 1062,
			1062, 1062, 419, 1038, 1038, 1038, 1038, 1038, 430, 1052,
			1052, 429, 1051, 1051, 766, 1489, 1489, 1489, 1489, 1489,
			765, 1488, 1488, 1488, 1488, 1488, 764, 1487, 1487, 1487,
			1487, 1487, 763, 1486, 1486, 1486, 1486, 1486, 428, 1050,
			1050, 427, 1049, 1049, 426, 1048, 1048, 445, 1061, 1061,
			1061, 1061, 1061, 427, 1049, 1049, 426, 1048, 1048, 661,
			661, 661, 661, 661, 661, 661, 661, 661, 661, 661,
			661, 661, 661, 661, 661, 661, 661, 661, 661, 661,
			661, 661, 661, 596, 597, 598, 599, 46, 48, 48,
			43, 43, 45, 45, 49, 48, 48, 47, 47, 44,
			44, 67, 657, 658, 152, 151, 465, 465, 465, 414,
			414, 414, 414, 414, 414, 414, 414, 414, 414, 416,
			1036, 1036, 1036, 1036, 1036, 415, 1035, 1035, 1035, 1035,
			1035, 416, 1036, 1036, 1036, 1036, 1036, 415, 1035, 1035,
			1035, 1035, 1035, 115, 114, 122, 122, 839, 839, 839,
			839, 121, 121, 838, 838, 838, 838, 437, 1058, 1058,
			1058, 1058, 1058, 436, 1057, 1057, 1057, 1057, 1057, 440,
			439, 128, 126, 130, 130, 853, 853, 853, 853, 129,
			129, 851, 851, 851, 851, 118, 112, 124, 124, 841,
			841, 841, 841, 119, 119, 835, 835, 835, 835, 756,
			1485, 1485, 755, 1484, 1484, 105, 104, 814, 813, 814,
			813, 1499, 659, 650, 653, 747, 748, 1549, 266, 90,
			90, 90, 87, 87, 87, 79, 79, 79, 78, 78,
			78, 81, 81, 81, 86, 86, 86, 80, 80, 80,
			77, 77, 77, 92, 92, 92, 89, 89, 89, 91,
			91, 91, 88, 88, 88, 84, 84, 84, 83, 83,
			83, 85, 85, 85, 82, 82, 82, 329, 328, 322,
			323, 327, 326, 324, 325, 337, 336, 334, 335, 345,
			340, 338, 339, 364, 363, 361, 362, 368, 367, 365,
			366, 321, 320, 318, 319, 360, 359, 358, 432, 432,
			1054, 1054, 1054, 1054, 431, 431, 1053, 1053, 1053, 1053,
			726, 1474, 1474, 1474, 1474, 1474, 725, 1473, 1473, 1473,
			1473, 1473, 728, 1476, 1476, 727, 1475, 1475, 672, 1449,
			1449, 673, 1450, 645, 1427, 1427, 646, 1428, 26, 788,
			788, 788, 788, 788, 25, 787, 787, 787, 787, 787,
			24, 786, 786, 786, 786, 786, 23, 785, 785, 785,
			785, 785, 469, 1081, 1081, 1081, 1081, 1081, 468, 1080,
			1080, 1080, 1080, 1080, 1520, 1491, 1491, 1491, 1491, 1491,
			1519, 1490, 1490, 1490, 1490, 1490, 9, 772, 772, 772,
			772, 772, 8, 771, 771, 771, 771, 771, 11, 774,
			774, 10, 773, 773, 458, 1074, 1074, 1074, 1074, 1074,
			457, 1073, 1073, 1073, 1073, 1073, 460, 1076, 1076, 459,
			1075, 1075, 117, 828, 828, 828, 828, 828, 113, 822,
			822, 822, 822, 822, 123, 840, 840, 120, 836, 836,
			110, 818, 818, 818, 818, 818, 834, 834, 834, 116,
			827, 827, 827, 827, 827, 127, 847, 847, 847, 847,
			847, 742, 1479, 1479, 1479, 1479, 1479, 741, 1478, 1478,
			1478, 1478, 1478, 744, 1481, 1481, 743, 1480, 1480, 408,
			1029, 1029, 1029, 1029, 1029, 407, 1028, 1028, 1028, 1028,
			1028, 410, 1031, 1031, 409, 1030, 1030, 140, 863, 863,
			863, 863, 863, 139, 862, 862, 862, 862, 862, 142,
			865, 865, 141, 864, 864, 402, 1022, 1022, 1022, 1022,
			1022, 401, 1021, 1021, 1021, 1021, 1021, 404, 1024, 1024,
			403, 1023, 1023, 636, 636, 1408, 1408, 1408, 1408, 1408,
			639, 639, 1411, 1411, 1411, 1411, 1411, 637, 637, 1409,
			1409, 1409, 1409, 1409, 478, 478, 1091, 1091, 1091, 1091,
			1091, 507, 507, 1136, 1136, 1136, 1136, 1136, 510, 510,
			1139, 1139, 1139, 1139, 1139, 508, 508, 1137, 1137, 1137,
			1137, 1137, 480, 480, 1093, 1093, 1093, 1093, 1093, 632,
			632, 1404, 1404, 1404, 1404, 1404, 635, 635, 1407, 1407,
			1407, 1407, 1407, 633, 633, 1405, 1405, 1405, 1405, 1405,
			477, 477, 1090, 1090, 1090, 1090, 1090, 638, 1410, 1410,
			1410, 1410, 1410, 634, 1406, 1406, 1406, 1406, 1406, 418,
			441, 418, 441, 1037, 1059, 1037, 1059, 441, 423, 1039,
			1039, 1040, 1040, 1040, 1041, 1041, 1041, 424, 1042, 1042,
			1044, 1044, 1044, 1045, 1045, 1045, 1046, 1046, 1046, 1043,
			1043, 1043, 607, 604, 1359, 1359, 1359, 1359, 1359, 605,
			1360, 1360, 1360, 1360, 1360, 606, 1361, 1361, 1361, 1361,
			1361, 620, 620, 1384, 1384, 1384, 1384, 1384, 616, 616,
			1377, 1377, 1377, 1377, 1377, 614, 614, 1371, 1371, 1371,
			1371, 1371, 1324, 1324, 1324, 1325, 1325, 1325, 1320, 1320,
			1320, 1321, 1321, 1321, 617, 617, 1378, 1378, 1378, 1378,
			1378, 615, 615, 1372, 1372, 1372, 1372, 1372, 1373, 1373,
			1373, 611, 611, 1365, 1365, 1365, 1365, 1365, 619, 619,
			1380, 1380, 1380, 1380, 1380, 618, 1379, 1379, 1379, 1379,
			1379, 613, 613, 1367, 1367, 1367, 1367, 1367, 612, 1366,
			1366, 1366, 1366, 1366, 499, 499, 1128, 1128, 1128, 1128,
			1128, 502, 502, 1131, 1131, 1131, 1131, 1131, 500, 500,
			1129, 1129, 1129, 1129, 1129, 147, 1493, 1492, 1069, 1069,
			849, 849, 849, 845, 845, 845, 157, 850, 850, 850,
			846, 846, 846, 854, 854, 285, 852, 852, 1077, 1077,
			831, 831, 831, 824, 824, 824, 157, 832, 832, 832,
			825, 825, 825, 842, 842, 285, 837, 837, 848, 848,
			848, 844, 844, 844, 855, 855, 855, 857, 857, 857,
			856, 856, 856, 858, 858, 858, 830, 830, 830, 823,
			823, 823, 860, 860, 859, 859, 270, 1001, 1001, 271,
			1002, 1002, 273, 1003, 1003, 274, 1004, 1004, 418, 441,
			418, 441, 1037, 1059, 1037, 1059, 441, 1059, 1059, 441,
			423, 1039, 1039, 1040, 1040, 1040, 1041, 1041, 1041, 424,
			1042, 1042, 1044, 1044, 1044, 1045, 1045, 1045, 1046, 1046,
			1046, 1043, 1043, 1043, 314, 314, 314, 311, 311, 311,
			299, 299, 299, 298, 298, 298, 302, 302, 302, 310,
			310, 310, 300, 300, 300, 297, 297, 297, 317, 317,
			317, 313, 313, 313, 315, 315, 315, 312, 312, 312,
			306, 306, 306, 305, 305, 305, 307, 307, 307, 304,
			304, 304, 699, 696, 688, 687, 690, 695, 689, 686,
			701, 698, 700, 697, 693, 692, 694, 691, 333, 332,
			330, 331, 333, 332, 330, 331, 333, 330, 331, 332,
			333, 330, 331, 332, 344, 343, 341, 342, 357, 356,
			354, 355, 640, 640, 640, 590, 590, 590, 106, 54,
			54, 54, 713, 713, 713, 713, 713, 713, 413, 413,
			413, 1534, 1534, 1534, 1535, 1535, 1535, 1508, 1508, 1536,
			1536, 1536, 1513, 1513, 1513, 1510, 1510, 1510, 1512, 1512,
			1512, 1511, 1511, 1511, 1514, 1514, 1514, 275, 275, 101,
			101, 101, 640, 640, 640, 590, 590, 590, 671, 57,
			57, 57, 716, 716, 716, 716, 716, 716, 261, 262,
			648, 648, 259, 260, 649, 649, 372, 1497, 1497, 1017,
			734, 1498, 1498, 1477, 1525, 1526, 631, 631, 1521, 1522,
			280, 281, 1529, 1530, 74, 752, 752, 72, 760, 760,
			760, 762, 762, 68, 69, 377, 377, 377, 377, 377,
			377, 377, 377, 406, 406, 406, 406, 406, 406, 406,
			406, 703, 703, 703, 703, 703, 703, 703, 703, 513,
			277, 277, 277, 101, 101, 101, 101, 394, 394, 394,
			56, 56, 56, 378, 378, 378, 380, 380, 380, 454,
			454, 454, 454, 454, 454, 309, 309, 592, 592, 592,
			758, 758, 758, 54, 54, 54, 57, 57, 57, 56,
			56, 56, 55, 55, 55, 55, 55, 55, 51, 51,
			51, 753, 753, 753, 52, 52, 52, 398, 398, 398,
			450, 450, 450, 450, 450, 450, 1506, 1506, 1506, 1506,
			95, 810, 810, 810, 810, 810, 94, 809, 809, 809,
			809, 809, 99, 812, 812, 97, 811, 811, 435, 435,
			554, 554, 554, 554, 1227, 1227, 1227, 1227, 520, 520,
			520, 520, 1197, 1197, 1197, 1197, 719, 1472, 1472, 1472,
			1472, 1472, 718, 1471, 1471, 1471, 1471, 1471, 103, 102,
			1523, 1524, 1527, 1528, 1531, 1532, 1067, 1026, 1079, 655,
			655, 655, 1068, 656, 656, 656, 651, 651, 53, 53,
			53, 12, 775, 775, 13, 776, 776, 620, 620, 1384,
			1384, 1384, 1384, 1384, 617, 617, 1378, 1378, 1378, 1378,
			1378, 619, 619, 1380, 1380, 1380, 1380, 1380, 483, 483,
			1096, 1096, 1096, 1096, 1096, 588, 588, 1309, 1309, 1309,
			1309, 1309, 441, 1059, 1059, 442, 422, 569, 569, 569,
			569, 1272, 1272, 1272, 1272, 626, 626, 1390, 1390, 1390,
			1390, 1390, 627, 627, 1391, 1391, 1391, 1391, 1391, 566,
			566, 1260, 1260, 1260, 1260, 1260, 490, 490, 1103, 1103,
			1104, 1104, 1104, 1108, 1108, 1108, 486, 486, 1099, 1099,
			1099, 1099, 1099, 487, 487, 1100, 1100, 1100, 1100, 1100,
			560, 560, 1252, 1252, 1252, 1252, 1252, 491, 491, 1105,
			1105, 1106, 1106, 1106, 1107, 1107, 1107, 493, 493, 1109,
			1109, 1109, 1109, 1109, 616, 616, 1377, 1377, 1377, 1377,
			1377, 615, 615, 1372, 1372, 1372, 1372, 1372, 1373, 1373,
			1373, 495, 495, 1110, 1110, 1110, 1110, 1110, 585, 585,
			1305, 1305, 1305, 1305, 1305, 586, 586, 1306, 1306, 1306,
			1306, 1306, 125, 843, 843, 843, 843, 843, 109, 817,
			817, 817, 817, 817, 833, 833, 833, 111, 821, 821,
			821, 821, 821, 438, 433, 1055, 1055, 1055, 1055, 1055,
			624, 624, 1388, 1388, 1388, 1388, 1388, 625, 625, 1389,
			1389, 1389, 1389, 1389, 565, 565, 1259, 1259, 1259, 1259,
			1259, 594, 594, 1316, 1316, 1317, 1317, 1317, 1318, 1318,
			1318, 484, 484, 1097, 1097, 1097, 1097, 1097, 485, 485,
			1098, 1098, 1098, 1098, 1098, 559, 559, 1251, 1251, 1251,
			1251, 1251, 643, 643, 1412, 1412, 1413, 1413, 1413, 1414,
			1414, 1414, 371, 1016, 1016, 614, 614, 1371, 1371, 1371,
			1371, 1371, 611, 611, 1365, 1365, 1365, 1365, 1365, 613,
			613, 1367, 1367, 1367, 1367, 1367, 589, 589, 1311, 1311,
			1311, 1311, 1311, 556, 556, 1245, 1245, 1245, 1245, 1245,
			602, 602, 1332, 1332, 1332, 1332, 1332, 400, 399, 1018,
			621, 621, 1385, 1385, 1385, 1385, 1385, 628, 628, 1392,
			1392, 1392, 1392, 1392, 622, 622, 1386, 1386, 1386, 1386,
			1386, 623, 623, 1387, 1387, 1387, 1387, 1387, 481, 481,
			1094, 1094, 1094, 1094, 1094, 488, 488, 1101, 1101, 1101,
			1101, 1101, 482, 482, 1095, 1095, 1095, 1095, 1095, 757,
			757, 757, 603, 603, 1357, 1357, 1357, 1357, 1357, 544,
			544, 1214, 1214, 542, 542, 1205, 1205, 543, 543, 1207,
			1207, 555, 555, 1244, 1244, 1244, 1244, 1244, 548, 548,
			1222, 1222, 546, 546, 1219, 1219, 547, 547, 1221, 1221,
			608, 608, 1362, 1362, 610, 610, 1364, 1364, 609, 609,
			1363, 1363, 583, 583, 1304, 1304, 1304, 1304, 1304, 1179,
			1179, 1179, 1179, 1179, 1178, 1178, 1178, 1178, 1178, 1483,
			1483, 1482, 1482, 496, 1383, 1383, 1383, 1294, 1294, 1294,
			1376, 1376, 1376, 1289, 1289, 1289, 1370, 1370, 1370, 1291,
			1291, 1291, 826, 826, 826, 826, 826, 1290, 1290, 1290,
			37, 1326, 1326, 1326, 1327, 1327, 1327, 1293, 1293, 1293,
			36, 1322, 1322, 1322, 1323, 1323, 1323, 1292, 1292, 1292,
			1181, 1181, 1181, 1180, 1180, 630, 1395, 1395, 808, 808,
			808, 808, 808, 807, 796, 796, 807, 807, 795, 797,
			797, 799, 799, 798, 800, 474, 474, 1086, 1086, 1086,
			1086, 1086, 476, 476, 1089, 1089, 1089, 1089, 1089, 475,
			475, 1087, 1087, 1087, 1087, 1087, 1088, 1088, 1088, 572,
			1285, 1285, 1285, 1285, 1285, 1282, 1282, 1282, 570, 1283,
			1283, 1283, 1283, 1283, 1277, 1277, 1277, 571, 1284, 1284,
			1284, 1284, 1284, 1279, 1279, 1279, 574, 1287, 1287, 1287,
			1287, 1287, 1278, 1278, 1278, 575, 1288, 1288, 1288, 1288,
			1288, 1281, 1281, 1281, 573, 1286, 1286, 1286, 1286, 1286,
			1280, 1280, 1280, 1396, 1396, 1396, 1399, 1399, 1399, 1400,
			1400, 1400, 1403, 1403, 1403, 1397, 1397, 1397, 1398, 1398,
			1398, 1401, 1401, 1401, 1402, 1402, 1402, 582, 1303, 1303,
			1303, 1303, 1303, 1268, 1268, 1268, 1271, 1271, 1271, 501,
			1130, 1130, 1130, 1130, 1130, 1264, 1264, 1264, 1295, 1295,
			1295, 434, 1056, 1056, 1056, 1056, 1056, 1120, 1120, 1120,
			479, 1092, 1092, 1092, 1092, 1092, 1020, 1020, 1452, 1452,
			1452, 1451, 1451, 1451, 1019, 1019, 1454, 1453, 1020, 1020,
			1019, 1019, 578, 1299, 1299, 1299, 1299, 1299, 1296, 1296,
			1296, 576, 1297, 1297, 1297, 1297, 1297, 1266, 1266, 1266,
			577, 1298, 1298, 1298, 1298, 1298, 1274, 1274, 1274, 580,
			1301, 1301, 1301, 1301, 1301, 1267, 1267, 1267, 581, 1302,
			1302, 1302, 1302, 1302, 1276, 1276, 1276, 579, 1300, 1300,
			1300, 1300, 1300, 1275, 1275, 1275, 1169, 1169, 1169, 1182,
			1182, 509, 1138, 1138, 1138, 1138, 1138, 563, 1256, 1256,
			1256, 1256, 1256, 1269, 1269, 1269, 1270, 1270, 1270, 564,
			1257, 1257, 1257, 1257, 1257, 1258, 1258, 1258, 1265, 1265,
			1265, 1273, 1273, 1273, 568, 1263, 1263, 1263, 1263, 1263,
			1121, 1121, 1121, 567, 1261, 1261, 1261, 1261, 1261, 1262,
			1262, 1262, 557, 1248, 1248, 1248, 1248, 1248, 558, 1249,
			1249, 1249, 1249, 1249, 1250, 1250, 1250, 562, 1255, 1255,
			1255, 1255, 1255, 561, 1253, 1253, 1253, 1253, 1253, 1254,
			1254, 1254, 587, 1307, 1307, 1307, 1307, 1307, 1308, 1308,
			1308, 545, 1217, 991, 991, 991, 990, 990, 990, 993,
			992, 1228, 1228, 1228, 1229, 1229, 1229, 1381, 1381, 1382,
			1382, 1381, 1381, 1381, 1382, 1382, 1382, 1374, 1374, 1374,
			1374, 1374, 1375, 1375, 1375, 1368, 1368, 1369, 1369, 1368,
			1368, 1368, 1369, 1369, 1369, 1420, 1420, 1420, 1419, 1419,
			1419, 1422, 1421, 1442, 1442, 1442, 1441, 1441, 1441, 1444,
			1443, 1162, 1162, 1162, 1163, 1163, 1163, 1164, 1164, 1164,
			866, 866, 866, 1084, 1165, 1165, 1165, 1085, 1312, 1312,
			1312, 1315, 1315, 1315, 1313, 1313, 1313, 1314, 1314, 1314,
			1119, 1119, 1119, 1119, 1119, 1122, 1122, 802, 802, 802,
			1122, 1122, 1122, 801, 803, 803, 805, 805, 804, 806,
			1190, 1190, 1190, 1193, 1193, 1193, 1150, 1150, 1150, 1153,
			1153, 1153, 1113, 1113, 1113, 1114, 1114, 1114, 790, 790,
			790, 789, 789, 789, 1112, 1112, 1112, 1115, 1115, 1115,
			1082, 1082, 1082, 1083, 1083, 1083, 1347, 1347, 1347, 1345,
			1345, 1345, 1346, 1346, 1346, 1355, 1355, 1355, 820, 820,
			820, 819, 819, 819, 1353, 1353, 1353, 1354, 1354, 1354,
			1170, 1170, 1170, 1175, 1175, 1175, 1171, 1171, 1171, 1174,
			1174, 1174, 1173, 1173, 1173, 1172, 1172, 1172, 1118, 1118,
			1118, 1118, 1118, 1123, 1123, 1123, 1123, 1123, 1118, 1118,
			1118, 1123, 1123, 1123, 1119, 1119, 1119, 1122, 1122, 1122,
			1183, 1183, 1183, 1188, 1188, 1188, 1184, 1184, 1184, 1187,
			1187, 1187, 1186, 1186, 1186, 1185, 1185, 1185, 291, 291,
			295, 295, 294, 294, 1310, 1310, 1310, 874, 874, 874,
			873, 873, 873, 1191, 1191, 1191, 1192, 1192, 1192, 816,
			816, 816, 815, 815, 815, 1151, 1151, 1151, 1152, 1152,
			1152, 1246, 1246, 1247, 1247, 1168, 1168, 1168, 1189, 1189,
			1189, 1246, 1246, 1247, 1247, 1358, 1358, 1358, 1198, 1198,
			1199, 1199, 1198, 1198, 1198, 1199, 1199, 1199, 1200, 1200,
			1201, 1201, 1200, 1200, 1200, 1201, 1201, 1201, 979, 979,
			978, 978, 979, 979, 979, 978, 978, 978, 989, 989,
			988, 988, 989, 989, 989, 988, 988, 988, 907, 907,
			906, 906, 907, 907, 907, 906, 906, 906, 927, 927,
			926, 926, 927, 927, 927, 926, 926, 926, 891, 891,
			890, 890, 891, 891, 891, 890, 890, 890, 893, 892,
			893, 892, 915, 915, 914, 914, 915, 915, 915, 914,
			914, 914, 767, 917, 916, 917, 916, 768, 939, 939,
			938, 938, 939, 939, 939, 938, 938, 938, 941, 940,
			941, 940, 955, 955, 954, 954, 955, 955, 955, 954,
			954, 954, 957, 956, 957, 956, 1333, 1333, 1333, 1334,
			1334, 1334, 1335, 1335, 1335, 1336, 1336, 1336, 1456, 1456,
			1456, 1455, 1455, 1455, 1466, 1466, 1466, 1465, 1465, 1465,
			909, 909, 908, 908, 909, 909, 909, 908, 908, 908,
			929, 929, 928, 928, 929, 929, 929, 928, 928, 928,
			895, 895, 894, 894, 895, 895, 895, 894, 894, 894,
			897, 896, 897, 896, 919, 919, 918, 918, 919, 919,
			919, 918, 918, 918, 769, 921, 920, 921, 920, 770,
			943, 943, 942, 942, 943, 943, 943, 942, 942, 942,
			945, 944, 945, 944, 959, 959, 958, 958, 959, 959,
			959, 958, 958, 958, 961, 960, 961, 960, 1243, 1243,
			1243, 1242, 1242, 1242, 911, 911, 910, 910, 911, 911,
			911, 910, 910, 910, 931, 931, 930, 930, 931, 931,
			931, 930, 930, 930, 899, 899, 898, 898, 899, 899,
			899, 898, 898, 898, 901, 900, 901, 900, 923, 923,
			922, 922, 923, 923, 923, 922, 922, 922, 925, 924,
			925, 924, 947, 947, 946, 946, 947, 947, 947, 946,
			946, 946, 949, 948, 949, 948, 963, 963, 962, 962,
			963, 963, 963, 962, 962, 962, 965, 964, 965, 964,
			1160, 1160, 1160, 1161, 1161, 1161, 981, 980, 985, 984,
			1458, 1457, 1462, 1461, 983, 982, 987, 986, 1460, 1459,
			1464, 1463, 707, 872, 871, 705, 706, 1424, 1423, 711,
			1426, 1425, 709, 1446, 1445, 710, 1448, 1447, 269, 1000,
			1000, 1000, 1000, 1000, 19, 781, 17, 779, 779, 779,
			779, 779, 18, 780, 780, 780, 780, 780, 15, 777,
			777, 777, 777, 777, 16, 778, 778, 778, 778, 778,
			417, 417, 417, 108, 108, 417, 417, 417, 108, 108,
			108, 22, 22, 42, 42, 41, 41, 39, 39, 58,
			58, 1503, 1504, 516, 516, 515, 515, 1501, 1502, 6,
			6, 14, 14, 461, 461, 28, 28, 714, 714, 679,
			679, 717, 717, 420, 420, 420, 154, 154, 154, 153,
			153, 153, 421, 421, 1182, 1182, 1182, 1180, 1180, 1180,
			1111, 1111, 783, 783, 783, 784, 784, 784, 1179, 1179,
			1179, 1179, 1179, 1178, 1178, 1178, 1178, 1178, 1166, 668,
			1438, 1438, 1434, 1434, 1434, 667, 1437, 1437, 1433, 1433,
			1433, 670, 1440, 1436, 669, 1439, 1435, 35, 792, 792,
			34, 791, 791, 497, 1117, 1117, 489, 489, 1102, 1102,
			1102, 1102, 1102, 517, 517, 1194, 1194, 1194, 1194, 520,
			520, 1197, 1197, 1197, 1197, 518, 519, 1195, 1196, 1195,
			1196, 156, 156, 885, 885, 885, 885, 1005, 1006, 1006,
			1008, 1008, 875, 876, 876, 878, 878, 1007, 1009, 877,
			879, 829, 829, 829, 829, 829, 1144, 1144, 1144, 1145,
			1145, 1145, 1127, 1127, 1127, 1142, 1142, 1142, 551, 551,
			1224, 1224, 1224, 1224, 284, 1015, 1015, 552, 553, 1225,
			1226, 1225, 1226, 1467, 1467, 1468, 1468, 1393, 1393, 1393,
			1394, 1394, 1394, 995, 995, 995, 994, 994, 994, 997,
			996, 350, 353, 351, 352, 346, 349, 347, 348, 1010,
			1011, 1011, 1013, 1013, 880, 881, 881, 883, 883, 1012,
			1014, 882, 884, 1143, 1143, 1143, 1146, 1146, 1146, 1126,
			1126, 1126, 1147, 1147, 1147, 144, 868, 868, 143, 867,
			455, 1066, 1066, 861, 861, 861, 1469, 1469, 1470, 1470,
			498, 1124, 1124, 1124, 1124, 1124, 1167, 1177, 1177, 1177,
			1177, 1176, 1176, 1176, 1176, 794, 794, 793, 793, 1116,
			1116, 1416, 1416, 1416, 1415, 1415, 1415, 1418, 1417, 887,
			887, 887, 886, 886, 886, 889, 888, 1430, 1430, 1430,
			1429, 1429, 1429, 1432, 1431, 913, 913, 913, 913, 912,
			912, 912, 912, 933, 933, 933, 933, 932, 932, 932,
			932, 505, 506, 1134, 1135, 503, 504, 1132, 1133, 512,
			1141, 511, 1140, 971, 971, 971, 970, 970, 970, 973,
			972, 903, 903, 903, 903, 902, 902, 902, 902, 905,
			905, 904, 904, 935, 935, 935, 935, 934, 934, 934,
			934, 937, 937, 936, 936, 1348, 1348, 1348, 1343, 1343,
			1343, 1344, 1344, 1344, 1356, 1356, 1356, 1351, 1351, 1351,
			1352, 1352, 1352, 951, 951, 951, 951, 950, 950, 950,
			950, 953, 953, 952, 952, 967, 967, 967, 967, 966,
			966, 966, 966, 969, 969, 968, 968, 708, 268, 999,
			999, 999, 999, 999, 267, 998, 998, 998, 998, 998,
			20, 782, 666, 666, 1237, 1236, 1235, 1233, 1234, 1239,
			1238, 1232, 1230, 1231, 1125, 1125, 1125, 1125, 1319, 1319,
			1240, 1241, 1328, 1331, 1329, 1330, 1148, 1159, 1149, 1154,
			1155, 1158, 1156, 1157, 29, 29, 38, 38, 33, 33,
			754, 754, 31, 31, 40, 40, 750, 750, 32, 32,
			30, 30, 383, 383, 723, 723, 975, 975, 974, 974,
			977, 976, 1328, 1328, 1331, 1331, 1329, 1329, 1330, 1330,
			1341, 1341, 1350, 1350, 1342, 1342, 1349, 1349, 1337, 1337,
			1340, 1340, 1338, 1338, 1339, 1339, 1204, 1202, 1203, 1215,
			1216, 1206, 1210, 1208, 1209, 1212, 1213, 1211, 1218, 1223,
			1220, 28, 28, 396, 396, 397, 397, 550, 549, 522,
			521, 536, 539, 531, 532, 526, 529, 533, 538, 540,
			524, 527, 528, 534, 537, 541, 523, 525, 530, 535,
			584, 629, 494, 1538, 1539, 1540, 1541, 1541, 1541, 1542,
			1543, 1544, 1545, 1545, 1545, 1546, 600, 595, 595, 595,
			595, 757, 1547, 1548, 1550, 1551, 1552, 1553, 1554, 1555,
			1556, 1557, 1558, 1559, 1560, 1561, 1563, 1564, 1565, 1566,
			1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1567,
			1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585,
			1586, 584, 1587, 1588, 1589, 1590, 1591, 1596, 1596, 1592,
			1596, 1593, 1594, 1596, 1596, 1596, 1596, 1596, 1595, 1597,
			1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607,
			1608, 1609, 1610, 1611, 808, 808, 807, 1547, 1621, 1622,
			1623, 1624, 1625, 1626, 1162, 1162, 1163, 1163, 1164, 1164,
			1165, 1165, 1627, 1627, 1627, 1628, 1628, 1628, 1629, 1629,
			1629, 1630, 1631, 1633, 1633, 1633, 1634, 1635, 1635, 1635,
			1636, 1637, 1638, 1638, 1638, 1639, 1639, 1639, 1640, 1640,
			1640, 1641, 1641, 1641, 1642, 1642, 1642, 1643, 1643, 1643,
			1644, 1644, 1644, 1645, 1645, 1645, 1646, 1646, 1646, 1647,
			1647, 1647, 1648, 1648, 1648, 1649, 1649, 1649, 1650, 1651,
			1652, 1652, 1653, 1654, 1654, 1655, 1655, 1656, 1657, 1657,
			1657, 1658, 1658, 1658, 1659, 1659, 1659, 1660, 1660, 1660,
			1661, 1661, 1661, 1662, 1662, 1662, 1663, 1663, 1664, 1664,
			1665, 1665, 1665, 1666, 1666, 1666, 1667, 1667, 1668, 1668,
			1668, 1669, 1669, 1669, 1670, 1670, 1670, 1671, 1672, 1672,
			1672, 1673, 1673, 1673, 1674, 1675, 1676, 1676, 1676, 1677,
			1677, 1677, 1678, 1679, 1680, 1680, 1680, 1681, 1681, 1681,
			1682, 1682, 1682, 1683, 1683, 1683, 1684, 1684, 1684, 1685,
			1685, 1685, 1686, 1686, 1686, 1687, 1687, 1687, 1688, 1688,
			1688, 1689, 1689, 1689, 1690, 1690, 1690, 1691, 1691, 1691,
			1692, 1693, 1694, 1695, 1696, 1697, 1698, 1698, 1698, 1699,
			1699, 1699, 1700, 1700, 1700, 1701, 1701, 1701, 1702, 1702,
			1702, 1703, 1703, 1703, 1704, 1705, 1706, 1707, 1708, 1709,
			1710, 1710, 1710, 1711, 1712, 1712, 1712, 1713, 1714, 1714,
			1714, 1715, 1716, 1716, 1716, 1717, 1718, 1718, 1718, 1719,
			1720, 1720, 1720, 1720, 1721, 1721, 1721, 1721, 1722, 1722,
			1722, 1723, 1724, 1724, 1724, 1725, 1726, 1726, 1726, 1727,
			1728, 1728, 1728, 1729, 1730, 1730, 1730, 1731, 1732, 1732,
			1732, 1733, 1734, 1734, 1734, 1735, 1736, 1736, 1736, 1737,
			1738, 1739, 1740, 1745, 1744, 1819, 1812, 1813, 1814, 1818,
			1815, 1816, 1817, 1746, 1747, 1748, 1755, 1756, 1758, 1759,
			1752, 1753, 1745, 1744, 1754, 1754, 1754, 1749, 1750, 1757,
			1743, 1743, 1760, 1760, 1742, 1741, 592, 592, 753, 753,
			1761, 1761, 398, 398, 1596, 1596, 1596, 1596, 1596, 1596,
			1751, 1819, 1812, 1813, 1814, 1818, 1815, 1816, 1817, 1036,
			1035, 1036, 1035, 1791, 1793, 1792, 1794, 772, 771, 1074,
			1073, 828, 822, 1479, 1478, 1137, 1040, 1041, 1359, 1378,
			1372, 1365, 1129, 855, 1040, 1041, 1742, 1741, 810, 809,
			1104, 1108, 1106, 1107, 817, 1317, 1318, 1413, 1414, 1386,
			1095, 808, 807, 797, 800, 1397, 1169, 1257, 1261, 1249,
			1253, 1307, 991, 990, 1381, 1374, 1368, 1596, 1596, 1596,
			1596, 1763, 1762, 1777, 1781, 1780, 1779, 1778, 1596, 1773,
			1772, 1596, 1596, 1119, 1122, 803, 806, 1803, 1804, 1820,
			1824, 1113, 1114, 790, 789, 1596, 1596, 1596, 1596, 1596,
			1822, 1833, 1832, 1821, 1823, 1596, 1596, 1596, 1596, 1806,
			1829, 1811, 1810, 1198, 1199, 979, 978, 1596, 1596, 891,
			890, 915, 914, 939, 938, 955, 954, 1333, 1334, 1456,
			1455, 1774, 895, 894, 919, 918, 943, 942, 959, 958,
			1596, 1596, 1809, 1808, 899, 898, 923, 922, 947, 946,
			963, 962, 1596, 1776, 1775, 981, 985, 1831, 1830, 1458,
			1462, 1771, 1790, 1825, 1828, 1764, 1805, 1596, 1596, 1596,
			1786, 1789, 1799, 1802, 1788, 1787, 1801, 1800, 1596, 1596,
			1596, 1782, 1785, 1795, 1798, 1784, 1783, 1797, 1796, 1596,
			1596, 1596, 783, 1807, 1144, 1127, 995, 994, 1827, 1826,
			1770, 1769, 1767, 1765, 1768, 1596, 1596, 1766, 1596, 1596,
			1596, 1596, 1596, 1596, 1834, 1834, 1834, 1835, 1835, 1835,
			1836, 1836, 1836, 1837, 1876, 1875, 1860, 1861, 1859, 1858,
			1838, 1838, 1839, 1839, 1841, 1841, 1840, 1840, 1873, 1873,
			1871, 1871, 1869, 1869, 1874, 1874, 1872, 1872, 1870, 1870,
			1862, 820, 820, 1868, 1868, 1866, 1866, 1865, 1865, 1867,
			1867, 1864, 1864, 1863, 1863, 1243, 1243, 1242, 1242, 1854,
			1854, 1850, 1850, 1843, 1843, 1847, 1847, 1857, 1857, 1853,
			1853, 1842, 1842, 1846, 1846, 1856, 1856, 1852, 1852, 1855,
			1855, 1851, 1851, 1845, 1845, 1849, 1849, 1844, 1844, 1848,
			1848, 1877, 1878, 1879, 1888, 1886, 1887, 1884, 1884, 1882,
			1882, 1880, 1880, 1885, 1885, 1883, 1883, 1881, 1881, 1889,
			1890, 1892, 1892, 1893, 1893, 1891
		};
	}
	public enum OpKind
	{
		Register,
		NearBranch16,
		NearBranch32,
		NearBranch64,
		FarBranch16,
		FarBranch32,
		Immediate8,
		Immediate8_2nd,
		Immediate16,
		Immediate32,
		Immediate64,
		Immediate8to16,
		Immediate8to32,
		Immediate8to64,
		Immediate32to64,
		MemorySegSI,
		MemorySegESI,
		MemorySegRSI,
		MemorySegDI,
		MemorySegEDI,
		MemorySegRDI,
		MemoryESDI,
		MemoryESEDI,
		MemoryESRDI,
		Memory
	}
	public enum Register
	{
		None,
		AL,
		CL,
		DL,
		BL,
		AH,
		CH,
		DH,
		BH,
		SPL,
		BPL,
		SIL,
		DIL,
		R8L,
		R9L,
		R10L,
		R11L,
		R12L,
		R13L,
		R14L,
		R15L,
		AX,
		CX,
		DX,
		BX,
		SP,
		BP,
		SI,
		DI,
		R8W,
		R9W,
		R10W,
		R11W,
		R12W,
		R13W,
		R14W,
		R15W,
		EAX,
		ECX,
		EDX,
		EBX,
		ESP,
		EBP,
		ESI,
		EDI,
		R8D,
		R9D,
		R10D,
		R11D,
		R12D,
		R13D,
		R14D,
		R15D,
		RAX,
		RCX,
		RDX,
		RBX,
		RSP,
		RBP,
		RSI,
		RDI,
		R8,
		R9,
		R10,
		R11,
		R12,
		R13,
		R14,
		R15,
		EIP,
		RIP,
		ES,
		CS,
		SS,
		DS,
		FS,
		GS,
		XMM0,
		XMM1,
		XMM2,
		XMM3,
		XMM4,
		XMM5,
		XMM6,
		XMM7,
		XMM8,
		XMM9,
		XMM10,
		XMM11,
		XMM12,
		XMM13,
		XMM14,
		XMM15,
		XMM16,
		XMM17,
		XMM18,
		XMM19,
		XMM20,
		XMM21,
		XMM22,
		XMM23,
		XMM24,
		XMM25,
		XMM26,
		XMM27,
		XMM28,
		XMM29,
		XMM30,
		XMM31,
		YMM0,
		YMM1,
		YMM2,
		YMM3,
		YMM4,
		YMM5,
		YMM6,
		YMM7,
		YMM8,
		YMM9,
		YMM10,
		YMM11,
		YMM12,
		YMM13,
		YMM14,
		YMM15,
		YMM16,
		YMM17,
		YMM18,
		YMM19,
		YMM20,
		YMM21,
		YMM22,
		YMM23,
		YMM24,
		YMM25,
		YMM26,
		YMM27,
		YMM28,
		YMM29,
		YMM30,
		YMM31,
		ZMM0,
		ZMM1,
		ZMM2,
		ZMM3,
		ZMM4,
		ZMM5,
		ZMM6,
		ZMM7,
		ZMM8,
		ZMM9,
		ZMM10,
		ZMM11,
		ZMM12,
		ZMM13,
		ZMM14,
		ZMM15,
		ZMM16,
		ZMM17,
		ZMM18,
		ZMM19,
		ZMM20,
		ZMM21,
		ZMM22,
		ZMM23,
		ZMM24,
		ZMM25,
		ZMM26,
		ZMM27,
		ZMM28,
		ZMM29,
		ZMM30,
		ZMM31,
		K0,
		K1,
		K2,
		K3,
		K4,
		K5,
		K6,
		K7,
		BND0,
		BND1,
		BND2,
		BND3,
		CR0,
		CR1,
		CR2,
		CR3,
		CR4,
		CR5,
		CR6,
		CR7,
		CR8,
		CR9,
		CR10,
		CR11,
		CR12,
		CR13,
		CR14,
		CR15,
		DR0,
		DR1,
		DR2,
		DR3,
		DR4,
		DR5,
		DR6,
		DR7,
		DR8,
		DR9,
		DR10,
		DR11,
		DR12,
		DR13,
		DR14,
		DR15,
		ST0,
		ST1,
		ST2,
		ST3,
		ST4,
		ST5,
		ST6,
		ST7,
		MM0,
		MM1,
		MM2,
		MM3,
		MM4,
		MM5,
		MM6,
		MM7,
		TR0,
		TR1,
		TR2,
		TR3,
		TR4,
		TR5,
		TR6,
		TR7,
		TMM0,
		TMM1,
		TMM2,
		TMM3,
		TMM4,
		TMM5,
		TMM6,
		TMM7,
		[Obsolete("Not part of the public API", false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		DontUse0,
		[Obsolete("Not part of the public API", false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		DontUseFA,
		[Obsolete("Not part of the public API", false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		DontUseFB,
		[Obsolete("Not part of the public API", false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		DontUseFC,
		[Obsolete("Not part of the public API", false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		DontUseFD,
		[Obsolete("Not part of the public API", false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		DontUseFE,
		[Obsolete("Not part of the public API", false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		DontUseFF
	}
	public static class RegisterExtensions
	{
		public static bool IsSegmentRegister(this Register register)
		{
			if (Register.ES <= register)
			{
				return register <= Register.GS;
			}
			return false;
		}

		public static bool IsGPR(this Register register)
		{
			if (Register.AL <= register)
			{
				return register <= Register.R15;
			}
			return false;
		}

		public static bool IsGPR8(this Register register)
		{
			if (Register.AL <= register)
			{
				return register <= Register.R15L;
			}
			return false;
		}

		public static bool IsGPR16(this Register register)
		{
			if (Register.AX <= register)
			{
				return register <= Register.R15W;
			}
			return false;
		}

		public static bool IsGPR32(this Register register)
		{
			if (Register.EAX <= register)
			{
				return register <= Register.R15D;
			}
			return false;
		}

		public static bool IsGPR64(this Register register)
		{
			if (Register.RAX <= register)
			{
				return register <= Register.R15;
			}
			return false;
		}

		public static bool IsXMM(this Register register)
		{
			if (Register.XMM0 <= register)
			{
				return register <= Register.XMM31;
			}
			return false;
		}

		public static bool IsYMM(this Register register)
		{
			if (Register.YMM0 <= register)
			{
				return register <= Register.YMM31;
			}
			return false;
		}

		public static bool IsZMM(this Register register)
		{
			if (Register.ZMM0 <= register)
			{
				return register <= Register.ZMM31;
			}
			return false;
		}

		public static bool IsIP(this Register register)
		{
			if (register != Register.EIP)
			{
				return register == Register.RIP;
			}
			return true;
		}

		public static bool IsK(this Register register)
		{
			if (Register.K0 <= register)
			{
				return register <= Register.K7;
			}
			return false;
		}

		public static bool IsCR(this Register register)
		{
			if (Register.CR0 <= register)
			{
				return register <= Register.CR15;
			}
			return false;
		}

		public static bool IsDR(this Register register)
		{
			if (Register.DR0 <= register)
			{
				return register <= Register.DR15;
			}
			return false;
		}

		public static bool IsTR(this Register register)
		{
			if (Register.TR0 <= register)
			{
				return register <= Register.TR7;
			}
			return false;
		}

		public static bool IsST(this Register register)
		{
			if (Register.ST0 <= register)
			{
				return register <= Register.ST7;
			}
			return false;
		}

		public static bool IsBND(this Register register)
		{
			if (Register.BND0 <= register)
			{
				return register <= Register.BND3;
			}
			return false;
		}

		public static bool IsMM(this Register register)
		{
			if (Register.MM0 <= register)
			{
				return register <= Register.MM7;
			}
			return false;
		}

		public static bool IsTMM(this Register register)
		{
			if (Register.TMM0 <= register)
			{
				return register <= Register.TMM7;
			}
			return false;
		}

		public static bool IsVectorRegister(this Register register)
		{
			if (Register.XMM0 <= register)
			{
				return register <= Register.ZMM31;
			}
			return false;
		}
	}
	public enum RoundingControl
	{
		None,
		RoundToNearest,
		RoundDown,
		RoundUp,
		RoundTowardZero
	}
	internal static class Static
	{
		[Conditional("E3967789CA584C48B3D02600CAB3C7B2")]
		public static void Assert(byte ignored)
		{
		}
	}
	public sealed class StreamCodeReader : CodeReader
	{
		public readonly Stream Stream;

		public StreamCodeReader(Stream stream)
		{
			Stream = stream;
		}

		public override int ReadByte()
		{
			return Stream.ReadByte();
		}
	}
	public sealed class StreamCodeWriter : CodeWriter
	{
		public readonly Stream Stream;

		public StreamCodeWriter(Stream stream)
		{
			Stream = stream;
		}

		public override void WriteByte(byte value)
		{
			Stream.WriteByte(value);
		}
	}
	internal static class ThrowHelper
	{
		[DoesNotReturn]
		internal static void ThrowArgumentException()
		{
			throw new ArgumentException();
		}

		[DoesNotReturn]
		internal static void ThrowInvalidOperationException()
		{
			throw new InvalidOperationException();
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException_codeWriter()
		{
			throw new ArgumentNullException("codeWriter");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException_data()
		{
			throw new ArgumentNullException("data");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException_writer()
		{
			throw new ArgumentNullException("writer");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException_options()
		{
			throw new ArgumentNullException("options");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException_value()
		{
			throw new ArgumentNullException("value");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException_list()
		{
			throw new ArgumentNullException("list");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException_collection()
		{
			throw new ArgumentNullException("collection");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException_array()
		{
			throw new ArgumentNullException("array");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException_sb()
		{
			throw new ArgumentNullException("sb");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentNullException_output()
		{
			throw new ArgumentNullException("output");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_value()
		{
			throw new ArgumentOutOfRangeException("value");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_index()
		{
			throw new ArgumentOutOfRangeException("index");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_count()
		{
			throw new ArgumentOutOfRangeException("count");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_length()
		{
			throw new ArgumentOutOfRangeException("length");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_operand()
		{
			throw new ArgumentOutOfRangeException("operand");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_instructionOperand()
		{
			throw new ArgumentOutOfRangeException("instructionOperand");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_capacity()
		{
			throw new ArgumentOutOfRangeException("capacity");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_memorySize()
		{
			throw new ArgumentOutOfRangeException("memorySize");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_size()
		{
			throw new ArgumentOutOfRangeException("size");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_elementSize()
		{
			throw new ArgumentOutOfRangeException("elementSize");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_register()
		{
			throw new ArgumentOutOfRangeException("register");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_code()
		{
			throw new ArgumentOutOfRangeException("code");
		}

		[DoesNotReturn]
		internal static void ThrowArgumentOutOfRangeException_data()
		{
			throw new ArgumentOutOfRangeException("data");
		}
	}
	public enum TupleType
	{
		N1,
		N2,
		N4,
		N8,
		N16,
		N32,
		N64,
		N8b4,
		N16b4,
		N32b4,
		N64b4,
		N16b8,
		N32b8,
		N64b8,
		N4b2,
		N8b2,
		N16b2,
		N32b2,
		N64b2
	}
	internal static class TupleTypeTable
	{
		private static ReadOnlySpan<byte> tupleTypeData => new byte[38]
		{
			1, 1, 2, 2, 4, 4, 8, 8, 16, 16,
			32, 32, 64, 64, 8, 4, 16, 4, 32, 4,
			64, 4, 16, 8, 32, 8, 64, 8, 4, 2,
			8, 2, 16, 2, 32, 2, 64, 2
		};

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint GetDisp8N(TupleType tupleType, bool bcst)
		{
			int index = ((int)tupleType << 1) | (bcst ? 1 : 0);
			return tupleTypeData[index];
		}
	}
	internal enum VectorLength
	{
		L128,
		L256,
		L512,
		Unknown
	}
}
namespace Iced.Intel.Internal
{
	internal ref struct DataReader
	{
		private readonly ReadOnlySpan<byte> data;

		private readonly char[] stringData;

		private int index;

		public int Index
		{
			readonly get
			{
				return index;
			}
			set
			{
				index = value;
			}
		}

		public readonly bool CanRead => (uint)index < (uint)data.Length;

		public DataReader(ReadOnlySpan<byte> data)
			: this(data, 0)
		{
		}

		public DataReader(ReadOnlySpan<byte> data, int maxStringLength)
		{
			this.data = data;
			stringData = ((maxStringLength == 0) ? Array2.Empty<char>() : new char[maxStringLength]);
			index = 0;
		}

		public byte ReadByte()
		{
			return data[index++];
		}

		public uint ReadCompressedUInt32()
		{
			uint num = 0u;
			for (int i = 0; i < 32; i += 7)
			{
				uint num2 = ReadByte();
				if ((num2 & 0x80) == 0)
				{
					return num | (num2 << i);
				}
				num |= (num2 & 0x7F) << i;
			}
			throw new InvalidOperationException();
		}

		public string ReadAsciiString()
		{
			int num = ReadByte();
			char[] array = stringData;
			for (int i = 0; i < num; i++)
			{
				array[i] = (char)ReadByte();
			}
			return new string(array, 0, num);
		}
	}
}
namespace Iced.Intel.EncoderInternal
{
	internal static class EncoderData
	{
		internal static readonly uint[] EncFlags1 = GetEncFlags1();

		internal static readonly uint[] EncFlags2 = GetEncFlags2();

		internal static readonly uint[] EncFlags3 = GetEncFlags3();

		private static uint[] GetEncFlags1()
		{
			return new uint[4936]
			{
				0u, 0u, 0u, 0u, 0u, 2055u, 2312u, 2825u, 3339u, 912u,
				1042u, 1174u, 1434u, 6829u, 7471u, 7601u, 7730u, 39u, 39u, 39u,
				39u, 2055u, 2312u, 2825u, 3339u, 912u, 1042u, 1174u, 1434u, 6829u,
				7471u, 7601u, 7730u, 40u, 40u, 40u, 2055u, 2312u, 2825u, 3339u,
				912u, 1042u, 1174u, 1434u, 6829u, 7471u, 7601u, 7730u, 41u, 41u,
				41u, 41u, 2055u, 2312u, 2825u, 3339u, 912u, 1042u, 1174u, 1434u,
				6829u, 7471u, 7601u, 7730u, 42u, 42u, 42u, 42u, 2055u, 2312u,
				2825u, 3339u, 912u, 1042u, 1174u, 1434u, 6829u, 7471u, 7601u, 7730u,
				0u, 2055u, 2312u, 2825u, 3339u, 912u, 1042u, 1174u, 1434u, 6829u,
				7471u, 7601u, 7730u, 0u, 2055u, 2312u, 2825u, 3339u, 912u, 1042u,
				1174u, 1434u, 6829u, 7471u, 7601u, 7730u, 0u, 2055u, 2312u, 2825u,
				3339u, 912u, 1042u, 1174u, 1434u, 6829u, 7471u, 7601u, 7730u, 0u,
				21u, 25u, 21u, 25u, 21u, 25u, 29u, 21u, 25u, 29u,
				0u, 0u, 0u, 0u, 530u, 534u, 2312u, 2825u, 1042u, 1174u,
				1178u, 58u, 59u, 60u, 951314u, 967830u, 984474u, 55u, 56u, 57u,
				902162u, 918678u, 935322u, 6207u, 6207u, 6207u, 7984u, 7984u, 7984u, 66u,
				67u, 68u, 66u, 67u, 68u, 66u, 67u, 68u, 66u, 67u,
				68u, 66u, 67u, 68u, 66u, 67u, 68u, 66u, 67u, 68u,
				66u, 67u, 68u, 66u, 67u, 68u, 66u, 67u, 68u, 66u,
				67u, 68u, 66u, 67u, 68u, 66u, 67u, 68u, 66u, 67u,
				68u, 66u, 67u, 68u, 66u, 67u, 68u, 6791u, 6791u, 6791u,
				6791u, 6791u, 6791u, 6791u, 6791u, 7432u, 7561u, 7691u, 7432u, 7561u,
				7691u, 7432u, 7561u, 7691u, 7432u, 7561u, 7691u, 7432u, 7561u, 7691u,
				7432u, 7561u, 7691u, 7432u, 7561u, 7691u, 7432u, 7561u, 7691u, 6791u,
				6791u, 6791u, 6791u, 6791u, 6791u, 6791u, 6791u, 7048u, 7177u, 7307u,
				7048u, 7177u, 7307u, 7048u, 7177u, 7307u, 7048u, 7177u, 7307u, 7048u,
				7177u, 7307u, 7048u, 7177u, 7307u, 7048u, 7177u, 7307u, 7048u, 7177u,
				7307u, 2055u, 2312u, 2825u, 3339u, 2055u, 2312u, 2825u, 3339u, 2055u,
				2312u, 2825u, 3339u, 912u, 1042u, 1174u, 1434u, 3848u, 3849u, 3851u,
				530u, 534u, 538u, 1054u, 1182u, 1438u, 8u, 9u, 11u, 0u,
				0u, 0u, 6037u, 6297u, 6429u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 1u, 2u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 429u, 431u, 433u, 434u, 5763u, 6019u, 6275u,
				6403u, 7999u, 7999u, 7999u, 7999u, 8126u, 8126u, 8126u, 8126u, 6829u,
				7471u, 7601u, 7730u, 5823u, 6079u, 6335u, 6463u, 7981u, 7983u, 7985u,
				7986u, 8109u, 8111u, 8113u, 8114u, 6801u, 7445u, 7577u, 7837u, 6791u,
				6791u, 6791u, 6791u, 6791u, 6791u, 6791u, 6791u, 6792u, 6793u, 6795u,
				6792u, 6793u, 6795u, 6792u, 6793u, 6795u, 6792u, 6793u, 6795u, 6792u,
				6793u, 6795u, 6792u, 6793u, 6795u, 6792u, 6793u, 6795u, 6792u, 6793u,
				6795u, 58u, 58u, 58u, 0u, 0u, 0u, 530u, 534u, 530u,
				534u, 6791u, 53u, 7432u, 7561u, 7691u, 72u, 73u, 6842u, 6842u,
				6842u, 0u, 0u, 0u, 58u, 58u, 58u, 0u, 0u, 0u,
				0u, 53u, 0u, 0u, 0u, 0u, 6919u, 6919u, 6919u, 6919u,
				6919u, 6919u, 6919u, 6919u, 6920u, 6921u, 6923u, 6920u, 6921u, 6923u,
				6920u, 6921u, 6923u, 6920u, 6921u, 6923u, 6920u, 6921u, 6923u, 6920u,
				6921u, 6923u, 6920u, 6921u, 6923u, 6920u, 6921u, 6923u, 5895u, 5895u,
				5895u, 5895u, 5895u, 5895u, 5895u, 5895u, 5896u, 5897u, 5899u, 5896u,
				5897u, 5899u, 5896u, 5897u, 5899u, 5896u, 5897u, 5899u, 5896u, 5897u,
				5899u, 5896u, 5897u, 5899u, 5896u, 5897u, 5899u, 5896u, 5897u, 5899u,
				53u, 53u, 0u, 65u, 4u, 4u, 4u, 4u, 4u, 4u,
				4u, 4u, 6707u, 6707u, 6707u, 6707u, 6707u, 6707u, 6707u, 6707u,
				4u, 4u, 4u, 4u, 4u, 4u, 4u, 4u, 4u, 4u,
				4u, 4u, 52u, 6707u, 0u, 52u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 4u, 4u, 4u, 4u, 4u, 4u, 4u,
				4u, 6707u, 6707u, 6707u, 6707u, 0u, 4u, 4u, 4u, 4u,
				4u, 4u, 6707u, 6707u, 6707u, 6707u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 6707u, 6707u, 4u,
				4u, 4u, 4u, 4u, 4u, 4u, 4u, 6580u, 6580u, 6707u,
				6707u, 6580u, 6580u, 6580u, 6580u, 4u, 4u, 4u, 4u, 4u,
				4u, 4u, 4u, 4u, 4u, 4u, 4u, 52u, 6707u, 52u,
				52u, 6707u, 6707u, 4u, 4u, 4u, 4u, 4u, 4u, 4u,
				4u, 6580u, 6580u, 6707u, 0u, 6580u, 6580u, 6580u, 6580u, 4u,
				4u, 4u, 4u, 4u, 4u, 4u, 4u, 52u, 6707u, 52u,
				52u, 47u, 47u, 47u, 47u, 6707u, 6707u, 66u, 67u, 66u,
				67u, 68u, 66u, 68u, 66u, 67u, 66u, 67u, 68u, 66u,
				68u, 66u, 67u, 66u, 67u, 68u, 66u, 68u, 66u, 67u,
				66u, 67u, 68u, 66u, 68u, 6829u, 6831u, 6833u, 5813u, 6069u,
				6325u, 69u, 70u, 71u, 69u, 70u, 71u, 1u, 2u, 66u,
				67u, 68u, 6189u, 6191u, 6193u, 5808u, 6064u, 6320u, 0u, 0u,
				0u, 6791u, 6791u, 7u, 7u, 7u, 7u, 7u, 7u, 7432u,
				7561u, 7691u, 7432u, 7561u, 7691u, 8u, 9u, 11u, 8u, 9u,
				11u, 8u, 9u, 11u, 8u, 9u, 11u, 8u, 9u, 11u,
				8u, 9u, 11u, 0u, 0u, 0u, 0u, 0u, 0u, 7u,
				7u, 8u, 9u, 11u, 8u, 9u, 11u, 8u, 9u, 11u,
				4u, 4u, 4u, 8u, 9u, 11u, 4u, 4u, 4u, 8u,
				9u, 11u, 8u, 9u, 11u, 8u, 9u, 11u, 8u, 9u,
				11u, 8u, 9u, 11u, 8u, 9u, 11u, 8u, 9u, 11u,
				8u, 9u, 4u, 4u, 4u, 4u, 4u, 4u, 4u, 4u,
				4u, 4u, 4u, 4u, 8u, 9u, 11u, 4u, 8u, 9u,
				11u, 4u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 1042u, 1174u, 1434u, 1042u, 1174u, 1434u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				2312u, 2825u, 3339u, 4u, 4u, 4u, 0u, 2055u, 2312u, 2825u,
				912u, 1042u, 1174u, 1825u, 532u, 601u, 340u, 376u, 411u, 1825u,
				532u, 601u, 340u, 376u, 411u, 1825u, 87444u, 84u, 22228u, 52u,
				1825u, 87444u, 84u, 22228u, 52u, 4238u, 1288u, 1609u, 650u, 779u,
				876u, 4238u, 1288u, 1609u, 650u, 779u, 876u, 4238u, 83349u, 1281u,
				21205u, 641u, 4238u, 83349u, 1281u, 21205u, 641u, 4385u, 545u, 87444u,
				5524u, 22228u, 1748u, 545u, 5524u, 1748u, 1825u, 532u, 601u, 340u,
				376u, 411u, 1825u, 532u, 601u, 340u, 376u, 411u, 4228u, 1281u,
				641u, 4228u, 1281u, 641u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u,
				1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 38617u, 10964u,
				12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 4385u, 87444u,
				22228u, 545u, 5524u, 1748u, 545u, 5524u, 1748u, 1825u, 532u, 601u,
				340u, 376u, 411u, 4228u, 1281u, 641u, 4228u, 1281u, 641u, 2312u,
				2825u, 3339u, 2312u, 2825u, 3339u, 2312u, 2825u, 3339u, 2312u, 2825u,
				3339u, 2312u, 2825u, 3339u, 2312u, 2825u, 3339u, 2312u, 2825u, 3339u,
				2312u, 2825u, 3339u, 4u, 4u, 4u, 4u, 806u, 1958u, 1958u,
				1318u, 1574u, 1318u, 1574u, 4870u, 4879u, 4879u, 678u, 678u, 1318u,
				1574u, 4u, 24u, 28u, 0u, 0u, 8u, 9u, 11u, 2147488152u,
				2147488156u, 4632u, 4636u, 2147486755u, 2147487267u, 3108u, 3620u, 4760u, 3109u, 1825u,
				532u, 601u, 340u, 376u, 411u, 1825u, 532u, 601u, 340u, 376u,
				411u, 4238u, 1288u, 1609u, 650u, 779u, 876u, 4238u, 1288u, 1609u,
				650u, 779u, 876u, 1697u, 1697u, 1185u, 1441u, 26004u, 30100u, 8916u,
				9940u, 1185u, 1441u, 26004u, 30100u, 1073750740u, 9940u, 4228u, 1281u, 1601u,
				641u, 769u, 865u, 4228u, 1281u, 1601u, 641u, 769u, 865u, 4228u,
				4228u, 1823u, 1823u, 1814u, 1818u, 523u, 526u, 333u, 335u, 1814u,
				1818u, 523u, 526u, 333u, 335u, 1823u, 1823u, 1814u, 1818u, 523u,
				526u, 333u, 335u, 1814u, 1818u, 523u, 526u, 333u, 335u, 1825u,
				532u, 340u, 1825u, 532u, 340u, 1825u, 1825u, 532u, 532u, 340u,
				340u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 1042u,
				1174u, 1434u, 1042u, 1174u, 1434u, 1042u, 1174u, 1434u, 1042u, 1174u,
				1434u, 1042u, 1174u, 1434u, 1042u, 1174u, 1434u, 1042u, 1174u, 1434u,
				1042u, 1174u, 1434u, 1042u, 1174u, 1434u, 1042u, 1174u, 1434u, 1042u,
				1174u, 1434u, 1042u, 1174u, 1434u, 1042u, 1174u, 1434u, 1042u, 1174u,
				1434u, 1042u, 1174u, 1434u, 1042u, 1174u, 1434u, 74961u, 74961u, 74961u,
				74961u, 74961u, 74961u, 74961u, 74961u, 1169u, 1169u, 1169u, 1169u, 74961u,
				74961u, 74961u, 74961u, 74961u, 74961u, 74961u, 74961u, 74961u, 74961u, 74961u,
				74961u, 74961u, 74961u, 74961u, 74961u, 74961u, 74961u, 74961u, 4374u, 4378u,
				1355u, 1358u, 1675u, 1678u, 4374u, 4378u, 1355u, 1358u, 1675u, 1678u,
				1825u, 532u, 601u, 340u, 376u, 411u, 1825u, 532u, 601u, 340u,
				376u, 411u, 1825u, 34196u, 10964u, 1825u, 34196u, 10964u, 1825u, 532u,
				601u, 1825u, 34196u, 1825u, 532u, 601u, 1825u, 34196u, 1825u, 34196u,
				38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u,
				1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 38617u, 10964u,
				12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u,
				38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u,
				1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 38617u, 10964u,
				12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u,
				10964u, 1825u, 34196u, 10964u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u,
				1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 10964u, 1825u,
				34196u, 10964u, 1825u, 532u, 537u, 340u, 344u, 379u, 1825u, 532u,
				596u, 340u, 372u, 408u, 1825u, 34196u, 10964u, 1825u, 34196u, 10964u,
				1825u, 532u, 601u, 340u, 376u, 411u, 340u, 372u, 408u, 1825u,
				532u, 601u, 340u, 376u, 411u, 1825u, 532u, 601u, 340u, 376u,
				411u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 38617u,
				10964u, 12120u, 13243u, 1825u, 34196u, 10964u, 1825u, 34196u, 10964u, 1825u,
				34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u,
				13243u, 1825u, 34196u, 10964u, 1825u, 34196u, 10964u, 1825u, 34196u, 38617u,
				10964u, 12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u,
				34196u, 10964u, 1825u, 34196u, 10964u, 1825u, 34196u, 38617u, 10964u, 12120u,
				13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 10964u,
				1825u, 34196u, 10964u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u,
				1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u,
				38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u,
				13243u, 1695u, 1825u, 34196u, 38617u, 10961u, 12113u, 13233u, 1695u, 1825u,
				34196u, 38617u, 10961u, 12113u, 13233u, 1695u, 1825u, 34196u, 38617u, 10961u,
				12113u, 13233u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u,
				1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u,
				10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u,
				1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 38617u,
				10964u, 12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1183u,
				1439u, 1185u, 1441u, 404u, 468u, 276u, 308u, 1695u, 1825u, 532u,
				601u, 340u, 376u, 411u, 340u, 376u, 411u, 1825u, 532u, 601u,
				340u, 376u, 411u, 340u, 376u, 411u, 340u, 376u, 411u, 340u,
				376u, 411u, 870047u, 870177u, 127508u, 127577u, 32084u, 32120u, 32155u, 870177u,
				127508u, 127577u, 32084u, 32120u, 32155u, 870177u, 127508u, 127577u, 32084u, 32120u,
				32155u, 6816u, 6818u, 128342u, 128667u, 32086u, 32122u, 32157u, 6816u, 6818u,
				128342u, 128667u, 32086u, 32122u, 32157u, 6816u, 6818u, 128342u, 128667u, 32086u,
				32122u, 32157u, 32086u, 32122u, 32157u, 32086u, 32122u, 32157u, 32086u, 32122u,
				32157u, 32086u, 32122u, 32157u, 6816u, 6818u, 128342u, 128667u, 32086u, 32122u,
				32157u, 6816u, 6818u, 128342u, 128667u, 32086u, 32122u, 32157u, 32086u, 32122u,
				32157u, 6816u, 6818u, 128342u, 128667u, 32086u, 32122u, 32157u, 6816u, 6818u,
				128342u, 128667u, 32086u, 32122u, 32157u, 6818u, 128342u, 128667u, 32086u, 32122u,
				32157u, 6816u, 6818u, 128342u, 128667u, 32086u, 32122u, 32157u, 6818u, 128342u,
				128667u, 32086u, 32122u, 32157u, 1695u, 1825u, 34196u, 38617u, 10961u, 12113u,
				13233u, 1695u, 1825u, 34196u, 38617u, 10961u, 12113u, 13233u, 1695u, 1825u,
				34196u, 38617u, 10961u, 12113u, 13233u, 0u, 0u, 0u, 2825u, 3339u,
				340u, 376u, 411u, 340u, 372u, 408u, 875170u, 340u, 344u, 379u,
				340u, 376u, 411u, 333u, 335u, 112021793u, 333u, 335u, 1174u, 1434u,
				340u, 376u, 411u, 340u, 372u, 408u, 4385u, 340u, 344u, 379u,
				340u, 376u, 411u, 333u, 335u, 4385u, 333u, 335u, 340u, 344u,
				379u, 340u, 376u, 411u, 340u, 344u, 1073742203u, 340u, 376u, 411u,
				340u, 376u, 411u, 340u, 372u, 408u, 340u, 344u, 379u, 340u,
				376u, 411u, 8916u, 9940u, 1073750740u, 9940u, 1825u, 34196u, 38617u, 1825u,
				34196u, 38617u, 1825u, 34196u, 38617u, 1825u, 34196u, 38617u, 3977u, 3979u,
				4233u, 4235u, 1286u, 1287u, 648u, 649u, 1825u, 532u, 340u, 3981u,
				4238u, 1288u, 1609u, 650u, 779u, 876u, 650u, 779u, 876u, 4238u,
				1288u, 1609u, 650u, 779u, 876u, 650u, 779u, 876u, 650u, 779u,
				876u, 650u, 779u, 876u, 69u, 70u, 71u, 69u, 70u, 71u,
				69u, 70u, 71u, 69u, 70u, 71u, 69u, 70u, 71u, 69u,
				70u, 71u, 69u, 70u, 71u, 69u, 70u, 71u, 69u, 70u,
				71u, 69u, 70u, 71u, 69u, 70u, 71u, 69u, 70u, 71u,
				69u, 70u, 71u, 69u, 70u, 71u, 69u, 70u, 71u, 69u,
				70u, 71u, 7u, 7u, 7u, 7u, 7u, 7u, 7u, 7u,
				7u, 7u, 7u, 7u, 7u, 7u, 7u, 7u, 657u, 657u,
				657u, 657u, 1089u, 1089u, 1089u, 1089u, 785u, 785u, 785u, 977u,
				1163u, 1163u, 1163u, 1166u, 1169u, 1169u, 1169u, 1169u, 1169u, 1169u,
				1169u, 1169u, 43u, 43u, 43u, 43u, 43u, 43u, 0u, 2312u,
				2825u, 3339u, 870664u, 871177u, 871691u, 755976u, 756489u, 757003u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 1042u, 1174u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 2312u, 2825u, 2055u,
				2312u, 2825u, 44u, 44u, 44u, 44u, 44u, 44u, 0u, 2312u,
				2825u, 3339u, 870664u, 871177u, 871691u, 755976u, 756489u, 757003u, 4u, 4u,
				24u, 28u, 4u, 4u, 24u, 28u, 4u, 24u, 28u, 1u,
				4u, 24u, 28u, 1u, 4u, 4u, 9u, 11u, 4u, 4u,
				24u, 28u, 4u, 4u, 4u, 24u, 28u, 4u, 20u, 24u,
				28u, 24u, 28u, 4u, 4u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				1042u, 1174u, 1434u, 2055u, 2312u, 2825u, 3339u, 530u, 534u, 538u,
				2312u, 2825u, 3339u, 530u, 534u, 538u, 530u, 534u, 538u, 914u,
				918u, 922u, 1042u, 1046u, 1050u, 74u, 75u, 1042u, 1174u, 1434u,
				1042u, 1174u, 1434u, 6792u, 6793u, 6795u, 6792u, 6793u, 6795u, 6792u,
				6793u, 6795u, 6792u, 6793u, 6795u, 2312u, 2825u, 3339u, 1042u, 1174u,
				1434u, 1042u, 1174u, 1434u, 1042u, 1174u, 1434u, 1042u, 1174u, 1434u,
				914u, 918u, 922u, 1042u, 1046u, 1050u, 2055u, 2312u, 2825u, 3339u,
				870177u, 8160660u, 8165081u, 1026769u, 1027921u, 1029041u, 870177u, 8160660u, 8165081u, 1026769u,
				1027921u, 1029041u, 870177u, 8160660u, 1026769u, 870177u, 8160660u, 1026769u, 2820u, 3332u,
				869535u, 869791u, 869537u, 869793u, 8152468u, 8156564u, 1024724u, 1025748u, 872470u, 872474u,
				872726u, 872730u, 128331u, 128334u, 32429u, 32431u, 870177u, 8160660u, 8165081u, 1026772u,
				1027928u, 1029051u, 870177u, 8160660u, 8165081u, 1026772u, 1027928u, 1029051u, 4u, 4u,
				4u, 4u, 4u, 4u, 4u, 4u, 4u, 4u, 4u, 20u,
				24u, 28u, 4u, 20u, 24u, 28u, 24u, 28u, 21u, 25u,
				29u, 1825u, 34196u, 38617u, 1825u, 34196u, 38617u, 1695u, 1825u, 34196u,
				34521u, 10964u, 11096u, 11195u, 1695u, 1825u, 34196u, 34521u, 10964u, 11096u,
				11195u, 1695u, 1825u, 34196u, 34521u, 10964u, 11096u, 11195u, 1695u, 1825u,
				34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u,
				12120u, 13243u, 4238u, 1288u, 650u, 4129u, 4383u, 4118u, 4122u, 4374u,
				4378u, 1355u, 1358u, 1675u, 1678u, 1695u, 1825u, 34196u, 38617u, 10964u,
				12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u,
				1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u,
				10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u,
				10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u,
				1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u,
				38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u,
				38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 34521u, 10964u, 11096u,
				11195u, 1695u, 1825u, 34196u, 34521u, 10964u, 11096u, 11195u, 10964u, 11096u,
				11195u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u,
				34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u,
				12120u, 13243u, 1825u, 532u, 596u, 340u, 372u, 408u, 1825u, 532u,
				537u, 340u, 344u, 1073742203u, 340u, 376u, 411u, 1825u, 532u, 596u,
				340u, 372u, 408u, 3972u, 4228u, 1281u, 1601u, 641u, 769u, 865u,
				1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u,
				38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u,
				13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u,
				13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u,
				34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u,
				12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 545u, 84u, 89u, 1695u, 1825u, 34196u, 34521u, 10964u,
				11096u, 11195u, 1695u, 1825u, 34196u, 34521u, 10964u, 11096u, 11195u, 1695u,
				1825u, 34196u, 34521u, 10964u, 11096u, 11195u, 1695u, 1825u, 34196u, 38617u,
				10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u,
				1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 528320u, 561344u, 87328u,
				1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u,
				38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u,
				13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u,
				34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u,
				12120u, 13243u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1042u,
				1174u, 1434u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u,
				1825u, 34196u, 38617u, 1695u, 1825u, 34196u, 38617u, 1695u, 1825u, 34196u,
				38617u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1695u, 1825u,
				34196u, 38617u, 1695u, 1825u, 34196u, 38617u, 1695u, 1825u, 34196u, 38617u,
				1695u, 1825u, 34196u, 38617u, 1695u, 1825u, 34196u, 38617u, 1695u, 1825u,
				34196u, 38617u, 1695u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 34196u,
				38617u, 10964u, 12120u, 13243u, 34196u, 38617u, 10964u, 12120u, 13243u, 532u,
				601u, 532u, 601u, 1825u, 10964u, 12120u, 13243u, 650u, 778u, 875u,
				10964u, 12120u, 13243u, 650u, 778u, 874u, 10964u, 12120u, 13243u, 650u,
				778u, 874u, 532u, 537u, 340u, 344u, 379u, 650u, 778u, 875u,
				1825u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 650u, 778u, 874u,
				1825u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 650u, 778u, 875u,
				38617u, 12120u, 13243u, 12120u, 13243u, 1825u, 532u, 601u, 84u, 89u,
				340u, 344u, 347u, 89u, 344u, 347u, 344u, 347u, 89u, 56u,
				59u, 56u, 59u, 59u, 59u, 1695u, 1825u, 532u, 601u, 340u,
				376u, 411u, 1695u, 1825u, 532u, 601u, 340u, 376u, 411u, 1695u,
				1825u, 532u, 601u, 340u, 376u, 411u, 340u, 376u, 411u, 1825u,
				532u, 537u, 340u, 344u, 379u, 650u, 778u, 875u, 1825u, 532u,
				537u, 340u, 344u, 347u, 650u, 778u, 874u, 1825u, 532u, 537u,
				340u, 344u, 347u, 650u, 778u, 874u, 1825u, 532u, 537u, 340u,
				344u, 379u, 650u, 778u, 875u, 1825u, 532u, 537u, 340u, 344u,
				347u, 650u, 778u, 874u, 1825u, 532u, 537u, 340u, 344u, 379u,
				650u, 778u, 875u, 10961u, 12113u, 13233u, 10961u, 12113u, 13233u, 10961u,
				12113u, 13233u, 10961u, 12113u, 13233u, 10961u, 12113u, 13233u, 10961u, 12113u,
				13233u, 10961u, 12113u, 13233u, 10961u, 12113u, 13233u, 1825u, 34196u, 38617u,
				10964u, 12120u, 13243u, 628u, 632u, 635u, 628u, 632u, 635u, 1825u,
				34196u, 38617u, 10961u, 12113u, 13233u, 689u, 817u, 913u, 689u, 817u,
				913u, 545u, 84u, 89u, 52u, 56u, 59u, 628u, 632u, 635u,
				1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 5524u, 5849u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 5524u, 5849u, 10964u, 10964u, 83329u, 104129u,
				83329u, 104129u, 1825u, 532u, 537u, 340u, 344u, 379u, 650u, 778u,
				875u, 1825u, 532u, 537u, 340u, 344u, 347u, 650u, 778u, 874u,
				1825u, 532u, 537u, 340u, 344u, 347u, 650u, 778u, 874u, 1825u,
				532u, 537u, 340u, 344u, 379u, 650u, 778u, 875u, 1825u, 532u,
				537u, 340u, 344u, 347u, 650u, 778u, 874u, 1825u, 532u, 537u,
				340u, 344u, 379u, 650u, 778u, 875u, 38617u, 12120u, 13243u, 12120u,
				13243u, 1825u, 34196u, 38617u, 10961u, 12113u, 13233u, 1825u, 34196u, 38617u,
				10964u, 12120u, 13243u, 628u, 632u, 635u, 628u, 632u, 635u, 1825u,
				34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 689u, 817u,
				913u, 689u, 817u, 913u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u,
				628u, 632u, 635u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u,
				38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 1825u, 34196u, 38617u,
				10964u, 12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u,
				13243u, 1825u, 532u, 340u, 376u, 411u, 340u, 376u, 411u, 10964u,
				10964u, 340u, 376u, 411u, 340u, 376u, 411u, 34196u, 38617u, 34196u,
				38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 34196u, 38617u, 10964u,
				12120u, 13243u, 10964u, 12120u, 13243u, 34196u, 38617u, 34196u, 38617u, 10964u,
				12120u, 13243u, 10964u, 12120u, 13243u, 340u, 376u, 411u, 340u, 376u,
				411u, 10964u, 10964u, 340u, 376u, 411u, 340u, 376u, 411u, 10964u,
				10964u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u,
				10964u, 12120u, 13243u, 2011u, 10964u, 12120u, 13243u, 2011u, 340u, 376u,
				411u, 340u, 376u, 411u, 340u, 376u, 411u, 340u, 376u, 411u,
				532u, 537u, 340u, 344u, 347u, 532u, 537u, 340u, 344u, 347u,
				340u, 344u, 347u, 89u, 56u, 59u, 56u, 59u, 59u, 59u,
				340u, 376u, 411u, 340u, 376u, 411u, 650u, 779u, 876u, 650u,
				779u, 876u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u,
				10962u, 12114u, 13234u, 10962u, 12114u, 13234u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 340u, 372u,
				408u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u,
				10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 532u, 537u,
				340u, 344u, 347u, 532u, 537u, 340u, 344u, 347u, 468u, 472u,
				475u, 468u, 472u, 475u, 468u, 472u, 475u, 532u, 536u, 539u,
				10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 534u, 538u,
				534u, 538u, 534u, 538u, 10964u, 12120u, 13243u, 340u, 376u, 411u,
				340u, 376u, 411u, 340u, 376u, 411u, 340u, 376u, 411u, 650u,
				779u, 876u, 650u, 779u, 876u, 650u, 779u, 876u, 650u, 779u,
				876u, 5524u, 5849u, 5524u, 5849u, 10964u, 12120u, 13243u, 10964u, 12120u,
				13243u, 83329u, 104129u, 83329u, 104129u, 10961u, 12113u, 13233u, 90260u, 110873u,
				90260u, 110745u, 84u, 152u, 219u, 84u, 88u, 155u, 90324u, 90452u,
				90324u, 110937u, 116u, 180u, 248u, 116u, 184u, 251u, 90260u, 110873u,
				90260u, 110745u, 84u, 152u, 219u, 84u, 88u, 155u, 90324u, 90452u,
				90324u, 110937u, 116u, 180u, 248u, 116u, 184u, 251u, 34196u, 38617u,
				34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 34196u, 38617u,
				34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 34196u, 38617u,
				34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 34196u, 34196u,
				10964u, 10964u, 34196u, 38617u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 2011u, 34196u, 34196u, 10964u, 10964u, 1780u, 34196u, 38617u,
				34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 34196u, 34196u,
				10964u, 10964u, 34196u, 38617u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 34196u, 34196u, 10964u, 10964u, 642u, 772u, 870u, 642u,
				770u, 868u, 643u, 645u, 775u, 643u, 773u, 871u, 642u, 772u,
				870u, 642u, 770u, 868u, 643u, 645u, 775u, 643u, 773u, 871u,
				34196u, 38617u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u,
				34196u, 38617u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u,
				34196u, 38617u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u,
				34196u, 34196u, 10964u, 10964u, 34196u, 38617u, 34196u, 38617u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 2011u, 34196u, 34196u, 10964u, 10964u, 1780u,
				34196u, 38617u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u,
				34196u, 34196u, 10964u, 10964u, 34196u, 38617u, 34196u, 38617u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 34196u, 34196u, 10964u, 10964u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 34196u, 38617u, 34196u, 38617u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 34196u, 38617u, 34196u, 38617u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 34196u, 38617u, 34196u, 38617u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 34196u, 34196u, 10964u, 10964u, 34196u, 38617u,
				34196u, 38617u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 34196u, 34196u,
				10964u, 10964u, 34196u, 38617u, 34196u, 38617u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 34196u, 34196u, 10964u, 10964u, 34196u, 38617u, 34196u, 38617u,
				10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 34196u, 34196u, 10964u, 10964u,
				340u, 376u, 411u, 340u, 376u, 411u, 6u, 4u, 6u, 4u,
				6u, 4u, 6u, 4u, 7u, 7u, 7u, 7u, 7u, 7u,
				7u, 7u, 1825u, 411u, 411u, 1825u, 1825u, 411u, 411u, 1825u,
				10964u, 10964u, 1825u, 411u, 411u, 1825u, 10964u, 10964u, 1825u, 34196u,
				38617u, 10964u, 12120u, 13243u, 1825u, 532u, 1825u, 34196u, 38617u, 10964u,
				12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u, 1825u, 34196u,
				38617u, 10964u, 12120u, 13243u, 1825u, 34196u, 38617u, 10964u, 12120u, 13243u,
				530u, 534u, 538u, 918u, 922u, 2308u, 2820u, 3332u, 1046u, 1174u,
				1434u, 25419u, 29710u, 397u, 464u, 397u, 464u, 397u, 464u, 53643u,
				65998u, 2820u, 3332u, 25419u, 29710u, 25419u, 29710u, 2820u, 3332u, 1174u,
				1434u, 1174u, 1434u, 25419u, 29710u, 53643u, 65998u, 53643u, 65998u, 53643u,
				65998u, 53643u, 65998u, 531u, 535u, 539u, 531u, 535u, 539u, 531u,
				535u, 539u, 2820u, 3332u, 127577u, 32120u, 32155u, 127577u, 32120u, 32155u,
				8160660u, 8165081u, 1026772u, 1027928u, 1029051u, 1026772u, 1027928u, 1029051u, 127508u, 127577u,
				32084u, 32120u, 32155u, 127508u, 127577u, 32084u, 32120u, 32155u, 8165081u, 870177u,
				127508u, 127577u, 32084u, 32120u, 32155u, 870177u, 127508u, 127577u, 32084u, 32120u,
				32155u, 870177u, 8160660u, 1026772u, 870177u, 8160660u, 1026772u, 870177u, 8160660u, 8165081u,
				870177u, 8160660u, 8165081u, 870177u, 8160660u, 8165081u, 870047u, 870177u, 8160660u, 8165081u,
				1026772u, 1027928u, 1029051u, 872585u, 872587u, 128262u, 128263u, 32392u, 32393u, 872585u,
				872587u, 128262u, 128263u, 32392u, 32393u, 872585u, 872587u, 128262u, 128263u, 32392u,
				32393u, 872585u, 872587u, 128262u, 128263u, 32392u, 32393u, 8160985u, 1026904u, 1027003u,
				1026904u, 1027003u, 128584u, 32522u, 32618u, 32522u, 32618u, 1028027u, 1028027u, 32619u,
				32619u, 128264u, 128584u, 32394u, 32522u, 32619u, 1026769u, 1027921u, 1029041u, 1026769u,
				1027921u, 1029041u, 1026769u, 1027921u, 1029041u, 1026769u, 1027921u, 1029041u, 869537u, 869793u,
				8152468u, 8156564u, 1024724u, 1025748u, 870177u, 8160660u, 1026772u, 869537u, 869793u, 8152468u,
				8156564u, 1024724u, 1025748u, 1027928u, 1029051u, 1027928u, 1029051u, 1026772u, 1027928u, 1029051u,
				1026772u, 1027928u, 1029051u, 32084u, 32120u, 32155u, 32084u, 32120u, 32155u, 1026772u,
				1026772u, 128145u, 128145u, 128145u, 128145u, 128145u, 128145u, 128145u, 128145u, 8160985u,
				1026904u, 1027003u, 1026904u, 1027003u, 128584u, 32522u, 32618u, 32522u, 32618u, 1028027u,
				1028027u, 32619u, 32619u, 1026769u, 1027921u, 1029041u, 1026769u, 1027921u, 1029041u, 1026769u,
				1027921u, 1029041u, 1026769u, 1027921u, 1029041u, 870177u, 8160660u, 8165081u, 870177u, 8160660u,
				870177u, 8160660u, 8165081u, 1026772u, 1027928u, 1029051u, 1027928u, 1029051u, 1027928u, 1029051u,
				870177u, 8160660u, 8165081u, 1026772u, 1027928u, 1029051u, 8165081u, 509642132u, 510957273u, 505513364u,
				505796313u, 509642132u, 510957273u, 505513364u, 505796313u, 6063508u, 7378649u, 6063508u, 7378649u, 6063508u,
				7378649u, 1026772u, 1027928u, 1029051u, 1026772u, 1027928u, 1029051u, 1026772u, 1026772u, 1026772u,
				1027928u, 1029051u, 1026772u, 1027928u, 1029051u, 1026772u, 1026772u, 32084u, 32120u, 32155u,
				32084u, 32120u, 32155u, 1026772u, 1026772u, 6063508u, 7378649u, 2192788u, 2475737u, 6063508u,
				7378649u, 2192788u, 2475737u, 6063508u, 7378649u, 2192788u, 2475737u, 6063508u, 7378649u, 2192788u,
				2475737u, 870177u, 870177u, 127508u, 127508u, 870177u, 870177u, 127508u, 127508u, 870177u,
				127508u, 870177u, 127508u, 32081u, 32113u, 32145u, 32081u, 32113u, 32145u, 32081u,
				32081u, 6063508u, 7378649u, 2192788u, 2475737u, 6063508u, 7378649u, 2192788u, 2475737u, 6063508u,
				2192788u, 6063508u, 2192788u, 6063508u, 7378649u, 2192788u, 2475737u, 6063508u, 7378649u, 2192788u,
				2475737u, 6063508u, 2192788u, 6063508u, 2192788u, 1026772u, 1027928u, 1029051u, 1026772u, 1027928u,
				1029051u, 1026772u, 1027928u, 1029051u, 1026772u, 1027928u, 1029051u, 1026772u, 1027928u, 1029051u,
				1026772u, 1027928u, 1029051u, 6063508u, 7378649u, 2192788u, 2475737u, 6063508u, 7378649u, 2192788u,
				2475737u, 6063508u, 2192788u, 6063508u, 2192788u, 6063508u, 7378649u, 2192788u, 2475737u, 6063508u,
				7378649u, 2192788u, 2475737u, 6063508u, 2192788u, 6063508u, 2192788u, 870177u, 870177u, 8160660u,
				8165081u, 1026772u, 1027928u, 1029051u, 870177u, 8160660u, 8165081u, 1026772u, 1027928u, 1029051u,
				870177u, 127508u, 127371u, 127438u, 429451u, 429451u, 429451u, 429451u, 429451u, 429451u,
				429451u, 429451u, 429451u, 429451u, 429451u, 528878u, 112011u, 147950u, 429451u, 112011u,
				429451u, 429451u, 17515u, 17515u, 17515u, 17515u, 560523u, 560523u, 560523u, 560523u,
				560523u, 560523u, 560523u, 560523u, 39u, 74u, 39u, 74u, 39u, 74u,
				39u, 74u, 39u, 74u, 39u, 74u, 39u, 74u, 39u, 74u,
				39u, 74u, 6u, 9u, 6u, 9u, 107u, 142u, 107u, 142u,
				107u, 107u, 12395u, 3467u, 12395u, 3467u, 12395u, 3467u, 12395u, 3467u,
				12395u, 3467u, 12395u, 3467u, 12395u, 3467u, 12395u, 3467u, 12395u, 3467u,
				12395u, 3467u, 12395u, 3467u, 12395u, 3467u, 107u, 107u, 107u, 107u,
				107u, 107u, 107u, 107u, 107u, 107u, 107u, 107u, 107u, 107u,
				107u, 18469u, 18504u, 18471u, 18474u, 18471u, 18474u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 4u, 4u, 4u, 4u,
				4u, 0u, 0u, 0u, 1u, 0u, 1u, 36u, 2276u, 2339u,
				2276u, 158052u, 158052u, 158052u, 158052u, 158052u, 47u, 47u, 9u, 9u,
				0u, 0u, 0u, 3844u, 542u, 4u, 4u, 4u, 4u, 0u,
				0u, 0u, 0u, 0u, 0u, 1695u, 1695u, 1695u, 543u, 1695u,
				543u, 1695u, 543u, 543u, 543u, 1695u, 543u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 4u, 4u, 4u, 4u, 4385u, 545u, 545u,
				545u, 545u, 3094u, 3094u, 1364u, 1369u, 1369u, 0u, 0u, 0u,
				0u, 0u, 28u, 53u, 34196u, 38617u, 34196u, 38617u, 34196u, 38617u,
				34196u, 38617u, 0u, 0u, 0u, 0u, 0u, 0u, 8u, 9u,
				11u, 0u, 0u, 10964u, 12120u, 13243u, 10964u, 1026769u, 1027921u, 1029041u,
				1026769u, 340u, 340u, 372u, 408u, 340u, 372u, 404u, 340u, 344u,
				379u, 340u, 344u, 347u, 340u, 344u, 379u, 340u, 344u, 347u,
				340u, 344u, 379u, 340u, 344u, 347u, 340u, 376u, 411u, 340u,
				376u, 411u, 340u, 372u, 408u, 340u, 372u, 404u, 10964u, 10964u,
				333u, 335u, 10964u, 333u, 335u, 8916u, 9940u, 10964u, 340u, 344u,
				379u, 340u, 344u, 347u, 340u, 344u, 379u, 340u, 344u, 347u,
				340u, 376u, 411u, 340u, 376u, 411u, 333u, 335u, 333u, 335u,
				340u, 372u, 408u, 340u, 372u, 404u, 8916u, 9940u, 340u, 376u,
				411u, 340u, 376u, 411u, 10964u, 12120u, 13243u, 10964u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 10964u, 10964u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 10964u, 10964u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u,
				10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u,
				10964u, 10964u, 10964u, 10964u, 10964u, 10964u, 10964u, 12120u, 13243u, 10964u,
				12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u, 13243u, 10964u, 12120u,
				13243u, 10964u, 12120u, 13243u, 10964u, 10964u, 10964u, 10964u, 10964u, 10964u,
				32081u, 32113u, 32145u, 32081u, 340u, 376u, 411u, 10964u, 32084u, 32120u,
				32155u, 1026772u, 10964u, 12120u, 13243u, 10964u, 10964u, 12120u, 13243u, 10964u,
				52u, 641u, 22228u, 21205u, 276u, 308u, 648u, 649u, 10964u, 12120u,
				13243u, 10964u, 340u, 376u, 411u, 10964u, 32084u, 32120u, 32155u, 1026772u,
				32084u, 32120u, 32155u, 1026772u, 340u, 376u, 411u, 10964u, 10964u, 12120u,
				13243u, 10964u, 340u, 376u, 411u, 10964u, 10964u, 12120u, 13243u, 10964u,
				340u, 0u, 0u, 2131u, 2131u, 1u, 1u, 1u, 1u, 1u,
				1u, 1u, 1u, 1169u, 1169u, 1169u, 1169u, 1169u, 1169u, 1169u,
				1169u, 1169u, 2195u, 2195u, 1169u, 785u, 1163u, 74958u, 74958u, 1169u,
				12u, 15u, 12u, 15u, 1u, 1u, 779u, 974u, 779u, 974u,
				779u, 974u, 779u, 974u, 395u, 462u, 395u, 462u, 395u, 462u,
				127953u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 54u,
				54u, 97u, 97u, 97u, 97u, 97u, 97u, 886u, 886u, 886u,
				886u, 54u, 54u, 886u, 886u, 884u, 54u, 54u, 2102u, 2103u,
				2103u, 2103u, 884u, 54u, 97u, 97u, 1u, 1u, 33652u, 33652u,
				886u, 886u, 886u, 886u, 54u, 886u, 886u, 886u, 886u, 886u,
				886u, 22u, 22u, 22u, 22u, 884u, 886u, 886u, 886u, 886u,
				886u, 886u, 54u, 54u, 886u, 886u, 886u, 54u, 54u, 54u,
				54u, 886u, 886u, 886u, 886u, 886u, 886u, 886u, 886u, 886u,
				886u, 886u, 886u, 22u, 22u, 22u, 22u, 854u, 854u, 854u,
				854u, 886u, 886u, 886u, 886u, 886u, 54u, 54u, 54u, 54u,
				886u, 886u, 886u, 854u, 854u, 886u, 886u, 886u, 886u, 884u,
				886u, 886u, 886u, 38u, 38u, 38u, 38u, 886u, 886u, 886u,
				886u, 886u, 886u, 886u, 886u, 886u, 886u, 98u, 98u, 98u,
				98u, 886u, 886u, 886u, 886u, 886u, 886u, 886u, 886u, 886u,
				38u, 38u, 886u, 886u, 886u, 886u, 886u, 886u, 886u, 886u,
				886u, 886u, 38u, 2u, 2u, 2u, 2u, 2u, 2u, 2u,
				2u, 54u, 54u, 54u, 54u, 886u, 886u, 886u, 886u, 886u,
				22u, 22u, 97u, 97u, 22u, 22u, 97u, 97u, 54u, 54u,
				54u, 22u, 22u, 97u, 97u, 22u, 22u, 97u, 97u, 54u,
				54u, 54u, 33654u, 2102u, 33652u, 33652u, 2102u, 2102u, 2102u, 2102u,
				2102u, 2102u, 2102u, 2102u, 2102u, 2102u, 2102u, 2102u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 4u, 4u,
				2820u, 3332u, 2820u, 3332u, 2820u, 3332u, 2820u, 3332u, 34196u, 38617u,
				34196u, 38617u, 34196u, 38617u, 34196u, 38617u, 34196u, 38617u, 34196u, 38617u,
				158052u, 532u, 596u, 84u, 89u, 84u, 89u, 84u, 89u, 84u,
				89u, 84u, 89u, 84u, 89u, 34196u, 38617u, 34196u, 38617u, 53953u,
				66433u, 53953u, 66433u, 53953u, 66433u, 53953u, 66433u, 53953u, 66433u, 53953u,
				66433u, 53953u, 66433u, 53953u, 66433u, 53953u, 66433u, 53953u, 66433u, 53953u,
				66433u, 53953u, 66433u, 53953u, 66433u, 53953u, 66433u, 53953u, 66433u, 53953u,
				66433u, 158052u, 158052u, 0u, 87769u, 1369u, 1689u, 34196u, 38617u, 34196u,
				38617u, 34196u, 38617u, 34196u, 38617u, 34196u, 38617u, 34196u, 38617u, 34196u,
				34196u, 34196u, 38617u, 34196u, 38617u, 8160660u
			};
		}

		private static uint[] GetEncFlags2()
		{
			return new uint[4936]
			{
				0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 2u,
				3u, 3u, 3u, 4u, 5u, 5u, 5u, 6u, 6u, 7u,
				7u, 8u, 9u, 9u, 9u, 10u, 11u, 11u, 11u, 12u,
				13u, 13u, 13u, 14u, 14u, 15u, 16u, 17u, 17u, 17u,
				18u, 19u, 19u, 19u, 20u, 21u, 21u, 21u, 22u, 22u,
				23u, 23u, 24u, 25u, 25u, 25u, 26u, 27u, 27u, 27u,
				28u, 29u, 29u, 29u, 30u, 30u, 31u, 31u, 32u, 33u,
				33u, 33u, 34u, 35u, 35u, 35u, 36u, 37u, 37u, 37u,
				39u, 40u, 41u, 41u, 41u, 42u, 43u, 43u, 43u, 44u,
				45u, 45u, 45u, 47u, 48u, 49u, 49u, 49u, 50u, 51u,
				51u, 51u, 52u, 53u, 53u, 53u, 55u, 56u, 57u, 57u,
				57u, 58u, 59u, 59u, 59u, 60u, 61u, 61u, 61u, 63u,
				64u, 64u, 72u, 72u, 80u, 80u, 80u, 88u, 88u, 88u,
				96u, 96u, 97u, 97u, 98u, 98u, 99u, 99u, 99u, 99u,
				99u, 104u, 104u, 104u, 105u, 105u, 105u, 106u, 106u, 106u,
				107u, 107u, 107u, 108u, 109u, 109u, 110u, 111u, 111u, 112u,
				112u, 112u, 113u, 113u, 113u, 114u, 114u, 114u, 115u, 115u,
				115u, 116u, 116u, 116u, 117u, 117u, 117u, 118u, 118u, 118u,
				119u, 119u, 119u, 120u, 120u, 120u, 121u, 121u, 121u, 122u,
				122u, 122u, 123u, 123u, 123u, 124u, 124u, 124u, 125u, 125u,
				125u, 126u, 126u, 126u, 127u, 127u, 127u, 2147483776u, 2281701504u, 2415919232u,
				2550136960u, 2684354688u, 2818572416u, 2952790144u, 3087007872u, 2147483777u, 2147483777u, 2147483777u, 2281701505u, 2281701505u,
				2281701505u, 2415919233u, 2415919233u, 2415919233u, 2550136961u, 2550136961u, 2550136961u, 2684354689u, 2684354689u, 2684354689u,
				2818572417u, 2818572417u, 2818572417u, 2952790145u, 2952790145u, 2952790145u, 3087007873u, 3087007873u, 3087007873u, 2147483778u,
				2281701506u, 2415919234u, 2550136962u, 2684354690u, 2818572418u, 2952790146u, 3087007874u, 2147483779u, 2147483779u, 2147483779u,
				2281701507u, 2281701507u, 2281701507u, 2415919235u, 2415919235u, 2415919235u, 2550136963u, 2550136963u, 2550136963u, 2684354691u,
				2684354691u, 2684354691u, 2818572419u, 2818572419u, 2818572419u, 2952790147u, 2952790147u, 2952790147u, 3087007875u, 3087007875u,
				3087007875u, 132u, 133u, 133u, 133u, 134u, 135u, 135u, 135u, 136u,
				137u, 137u, 137u, 138u, 139u, 139u, 139u, 140u, 140u, 140u,
				141u, 141u, 141u, 142u, 142u, 142u, 2147483791u, 2147483791u, 2147483791u, 144u,
				144u, 144u, 144u, 144u, 144u, 1075839120u, 152u, 152u, 152u, 153u,
				153u, 153u, 154u, 154u, 155u, 156u, 156u, 156u, 157u, 157u,
				157u, 158u, 159u, 160u, 161u, 161u, 161u, 162u, 163u, 163u,
				163u, 164u, 165u, 165u, 165u, 166u, 167u, 167u, 167u, 168u,
				169u, 169u, 169u, 170u, 171u, 171u, 171u, 172u, 173u, 173u,
				173u, 174u, 175u, 175u, 175u, 176u, 184u, 184u, 184u, 2147483840u,
				2281701568u, 2415919296u, 2550137024u, 2684354752u, 2818572480u, 2952790208u, 3087007936u, 2147483841u, 2147483841u, 2147483841u,
				2281701569u, 2281701569u, 2281701569u, 2415919297u, 2415919297u, 2415919297u, 2550137025u, 2550137025u, 2550137025u, 2684354753u,
				2684354753u, 2684354753u, 2818572481u, 2818572481u, 2818572481u, 2952790209u, 2952790209u, 2952790209u, 3087007937u, 3087007937u,
				3087007937u, 194u, 194u, 194u, 195u, 195u, 195u, 196u, 196u, 197u,
				197u, 2147483846u, 116472u, 2147483847u, 2147483847u, 2147483847u, 116728u, 116728u, 200u, 200u,
				200u, 201u, 201u, 201u, 202u, 202u, 202u, 203u, 203u, 203u,
				204u, 205u, 206u, 207u, 207u, 207u, 2147483856u, 2281701584u, 2415919312u, 2550137040u,
				2684354768u, 2818572496u, 2952790224u, 3087007952u, 2147483857u, 2147483857u, 2147483857u, 2281701585u, 2281701585u, 2281701585u,
				2415919313u, 2415919313u, 2415919313u, 2550137041u, 2550137041u, 2550137041u, 2684354769u, 2684354769u, 2684354769u, 2818572497u,
				2818572497u, 2818572497u, 2952790225u, 2952790225u, 2952790225u, 3087007953u, 3087007953u, 3087007953u, 2147483858u, 2281701586u,
				2415919314u, 2550137042u, 2684354770u, 2818572498u, 2952790226u, 3087007954u, 2147483859u, 2147483859u, 2147483859u, 2281701587u,
				2281701587u, 2281701587u, 2415919315u, 2415919315u, 2415919315u, 2550137043u, 2550137043u, 2550137043u, 2684354771u, 2684354771u,
				2684354771u, 2818572499u, 2818572499u, 2818572499u, 2952790227u, 2952790227u, 2952790227u, 3087007955u, 3087007955u, 3087007955u,
				212u, 213u, 214u, 215u, 2147483864u, 2281701592u, 2415919320u, 2550137048u, 2684354776u, 2818572504u,
				2952790232u, 3087007960u, 121024u, 121032u, 121040u, 121048u, 121056u, 121064u, 121072u, 121080u,
				2147483865u, 2415919321u, 2550137049u, 2684354777u, 2684354777u, 2818572505u, 2952790233u, 2952790233u, 2952790233u, 2952790233u,
				3087007961u, 3087007961u, 121280u, 121288u, 121296u, 121304u, 121312u, 121313u, 121316u, 121317u,
				121320u, 121321u, 121322u, 121323u, 121324u, 121325u, 121326u, 121328u, 121329u, 121330u,
				121331u, 121332u, 121333u, 121334u, 121335u, 121336u, 121337u, 121338u, 121339u, 121340u,
				121341u, 121342u, 121343u, 2147483866u, 2281701594u, 2415919322u, 2550137050u, 2684354778u, 2818572506u, 2952790234u,
				3087007962u, 121536u, 121544u, 121552u, 121560u, 121577u, 2147483867u, 2281701595u, 2415919323u, 2550137051u,
				2818572507u, 3087007963u, 121792u, 121800u, 121808u, 121816u, 121824u, 121824u, 121825u, 121825u,
				121826u, 121826u, 121827u, 121827u, 121828u, 121828u, 121829u, 121832u, 121840u, 2147483868u,
				2281701596u, 2415919324u, 2550137052u, 2684354780u, 2818572508u, 2952790236u, 3087007964u, 122048u, 122056u, 122064u,
				122072u, 122080u, 122088u, 122096u, 122104u, 2147483869u, 2281701597u, 2415919325u, 2550137053u, 2684354781u,
				2684354781u, 2952790237u, 2952790237u, 2952790237u, 2952790237u, 3087007965u, 3087007965u, 122304u, 122312u, 122320u,
				122328u, 122336u, 122344u, 2147483870u, 2281701598u, 2415919326u, 2550137054u, 2684354782u, 2818572510u, 2952790238u,
				3087007966u, 122560u, 122568u, 122576u, 122585u, 122592u, 122600u, 122608u, 122616u, 2147483871u,
				2281701599u, 2415919327u, 2550137055u, 2684354783u, 2818572511u, 2952790239u, 3087007967u, 122816u, 122824u, 122832u,
				122840u, 122848u, 122848u, 122849u, 122850u, 122856u, 122864u, 224u, 224u, 224u,
				224u, 224u, 224u, 224u, 225u, 225u, 225u, 225u, 225u, 225u,
				225u, 226u, 226u, 226u, 226u, 226u, 226u, 226u, 227u, 227u,
				227u, 227u, 227u, 227u, 227u, 228u, 229u, 229u, 230u, 231u,
				231u, 232u, 232u, 232u, 233u, 233u, 233u, 234u, 234u, 235u,
				235u, 235u, 236u, 237u, 237u, 238u, 239u, 239u, 241u, 244u,
				245u, 2147483894u, 2281701622u, 2415919350u, 2550137078u, 2684354806u, 2818572534u, 2952790262u, 3087007990u, 2147483895u,
				2147483895u, 2147483895u, 2281701623u, 2281701623u, 2281701623u, 2415919351u, 2415919351u, 2415919351u, 2550137079u, 2550137079u,
				2550137079u, 2684354807u, 2684354807u, 2684354807u, 2818572535u, 2818572535u, 2818572535u, 2952790263u, 2952790263u, 2952790263u,
				3087007991u, 3087007991u, 3087007991u, 248u, 249u, 250u, 251u, 252u, 253u, 2147483902u,
				2281701630u, 2147483903u, 2147483903u, 2147483903u, 2281701631u, 2281701631u, 2281701631u, 2415919359u, 2415919359u, 2415919359u,
				2550137087u, 2550137087u, 2550137087u, 2684354815u, 2684354815u, 2684354815u, 2818572543u, 2818572543u, 2818572543u, 2952790271u,
				2952790271u, 2952790271u, 2147614720u, 2147614720u, 2147614720u, 2281832448u, 2281832448u, 2281832448u, 2416050176u, 2416050176u,
				2416050176u, 2550267904u, 2550267904u, 2550267904u, 2684485632u, 2684485632u, 2684485632u, 2818703360u, 2818703360u, 2818703360u,
				2952921088u, 2952921088u, 2147614721u, 2147614721u, 2147614721u, 2281832449u, 2281832449u, 2281832449u, 2416050177u, 2416050177u,
				2416050177u, 2550267905u, 2550267905u, 2550267905u, 2684485633u, 2684485633u, 2684485633u, 3894542337u, 2952921089u, 2952921089u,
				2952921089u, 3087138817u, 1073938880u, 1073938881u, 1073938882u, 1073938883u, 1073938884u, 1073938885u, 1073938888u, 1073938888u,
				1073938888u, 1073938889u, 1073938890u, 1073938891u, 1073938895u, 1073938896u, 1073938897u, 1073938900u, 1073938901u, 1073938902u,
				1073938903u, 197080u, 197080u, 197080u, 197081u, 197082u, 197082u, 197082u, 197083u, 197083u,
				197083u, 197084u, 197085u, 197086u, 197087u, 197087u, 197087u, 1076036072u, 1076036074u, 1073938926u,
				1073938927u, 197112u, 197113u, 1073938938u, 1073938938u, 1073938938u, 1076036090u, 1073938939u, 197116u, 197116u,
				197116u, 1073938941u, 131074u, 131074u, 131074u, 131075u, 131075u, 131075u, 131076u, 131077u,
				131077u, 131078u, 131079u, 131079u, 131079u, 131080u, 131081u, 1075970057u, 131082u, 131083u,
				131085u, 131085u, 131085u, 2147614733u, 2281832461u, 2416050189u, 131086u, 131088u, 131089u, 131089u,
				131090u, 131091u, 131091u, 1073872912u, 1149370384u, 1166147600u, 1140981776u, 1157758992u, 1174536208u, 1074921488u,
				1150418960u, 1167196176u, 1146224656u, 1163001872u, 1179779088u, 1075970064u, 1117913104u, 1117913104u, 1109524496u, 1109524496u,
				1077018640u, 1118961680u, 1118961680u, 1114767376u, 1114767376u, 1073872913u, 1149370385u, 1166147601u, 1140981777u, 1157758993u,
				1174536209u, 1074921489u, 1150418961u, 1167196177u, 1146224657u, 1163001873u, 1179779089u, 1075970065u, 1117913105u, 1117913105u,
				1109524497u, 1109524497u, 1077018641u, 1118961681u, 1118961681u, 1114767377u, 1114767377u, 1073872914u, 1073872914u, 1149370386u,
				1149370386u, 1140981778u, 1140981778u, 1074921490u, 1150418962u, 1146224658u, 1075970066u, 1151467538u, 1168244754u, 1143078930u,
				1159856146u, 1176633362u, 1077018642u, 1152516114u, 1169293330u, 1148321810u, 1165099026u, 1181876242u, 1073872915u, 1149370387u,
				1140981779u, 1074921491u, 1150418963u, 1146224659u, 1073872916u, 1149370388u, 1166147604u, 1140981780u, 1157758996u, 1174536212u,
				1074921492u, 1150418964u, 1167196180u, 1146224660u, 1163001876u, 1179779092u, 1073872917u, 1149370389u, 1166147605u, 1140981781u,
				1157758997u, 1174536213u, 1074921493u, 1150418965u, 1167196181u, 1146224661u, 1163001877u, 1179779093u, 1073872918u, 1149370390u,
				1140981782u, 1073872918u, 1149370390u, 1140981782u, 1074921494u, 1150418966u, 1146224662u, 1075970070u, 1151467542u, 1168244758u,
				1143078934u, 1159856150u, 1176633366u, 1073872919u, 1149370391u, 1140981783u, 1074921495u, 1150418967u, 1146224663u, 131096u,
				131096u, 131096u, 131097u, 131097u, 131097u, 131098u, 131098u, 131098u, 131099u, 131099u,
				131099u, 131100u, 131100u, 131100u, 131101u, 131101u, 131101u, 131102u, 131102u, 131102u,
				131103u, 131103u, 131103u, 2147614744u, 2281832472u, 2416050200u, 2550267928u, 1073872922u, 1074921498u, 1074921498u,
				1075970074u, 1075970074u, 1077018650u, 1077018650u, 1073872923u, 1074921499u, 1074921499u, 1075970075u, 1075970075u, 1077018651u,
				1077018651u, 3221356572u, 3357671454u, 3357671454u, 1076043514u, 1076043515u, 2147614751u, 2147614751u, 2147614751u, 131104u,
				131104u, 131105u, 131105u, 131106u, 131106u, 131107u, 131107u, 131108u, 131110u, 1073872936u,
				1149370408u, 1166147624u, 1140981800u, 1157759016u, 1174536232u, 1074921512u, 1150418984u, 1167196200u, 1146224680u, 1163001896u,
				1179779112u, 1073872937u, 1149370409u, 1166147625u, 1140981801u, 1157759017u, 1174536233u, 1074921513u, 1150418985u, 1167196201u,
				1146224681u, 1163001897u, 1179779113u, 1073872938u, 1074921514u, 1075970090u, 1075970090u, 1122107434u, 1113718826u, 1122107434u,
				1113718826u, 1077018666u, 1077018666u, 1123156010u, 1114767402u, 1123156010u, 1114767402u, 1073872939u, 1149370411u, 1166147627u,
				1140981803u, 1157759019u, 1174536235u, 1074921515u, 1150418987u, 1167196203u, 1146224683u, 1163001899u, 1179779115u, 1075970091u,
				1077018667u, 1073872940u, 1074921516u, 1075970092u, 1075970092u, 1122107436u, 1113718828u, 1122107436u, 1113718828u, 1077018668u,
				1077018668u, 1123156012u, 1114767404u, 1123156012u, 1114767404u, 1073872941u, 1074921517u, 1075970093u, 1075970093u, 1122107437u,
				1113718829u, 1122107437u, 1113718829u, 1077018669u, 1077018669u, 1123156013u, 1114767405u, 1123156013u, 1114767405u, 1073872942u,
				1115815982u, 1107427374u, 1074921518u, 1116864558u, 1112670254u, 1073872943u, 1074921519u, 1115815983u, 1116864559u, 1107427375u,
				1112670255u, 131120u, 131121u, 131122u, 131123u, 131124u, 131125u, 131125u, 1073872951u, 131136u,
				131136u, 131136u, 131137u, 131137u, 131137u, 131138u, 131138u, 131138u, 131139u, 131139u,
				131139u, 131140u, 131140u, 131140u, 131141u, 131141u, 131141u, 131142u, 131142u, 131142u,
				131143u, 131143u, 131143u, 131144u, 131144u, 131144u, 131145u, 131145u, 131145u, 131146u,
				131146u, 131146u, 131147u, 131147u, 131147u, 131148u, 131148u, 131148u, 131149u, 131149u,
				131149u, 131150u, 131150u, 131150u, 131151u, 131151u, 131151u, 1090650177u, 1094844481u, 1091698753u,
				1095893057u, 1090650178u, 1094844482u, 1091698754u, 1095893058u, 1073872964u, 1078067268u, 1074921540u, 1079115844u, 1090650181u,
				1094844485u, 1091698757u, 1095893061u, 1090650182u, 1094844486u, 1091698758u, 1095893062u, 1090650183u, 1094844487u, 1091698759u,
				1095893063u, 1090650186u, 1094844490u, 1091698762u, 1095893066u, 1090650187u, 1094844491u, 1091698763u, 1073872976u, 1073872976u,
				1153564752u, 1145176144u, 1170341968u, 1161953360u, 1074921552u, 1074921552u, 1154613328u, 1146224720u, 1171390544u, 1163001936u,
				1073872977u, 1149370449u, 1166147665u, 1140981841u, 1157759057u, 1174536273u, 1074921553u, 1150419025u, 1167196241u, 1146224721u,
				1163001937u, 1179779153u, 1075970129u, 1117913169u, 1109524561u, 1077018705u, 1118961745u, 1114767441u, 1073872978u, 1149370450u,
				1166147666u, 1075970130u, 1117913170u, 1073872979u, 1149370451u, 1166147667u, 1075970131u, 1117913171u, 1073872980u, 1149370452u,
				1166147668u, 1140981844u, 1157759060u, 1174536276u, 1074921556u, 1150419028u, 1167196244u, 1146224724u, 1163001940u, 1179779156u,
				1073872981u, 1149370453u, 1166147669u, 1140981845u, 1157759061u, 1174536277u, 1074921557u, 1150419029u, 1167196245u, 1146224725u,
				1163001941u, 1179779157u, 1073872982u, 1149370454u, 1166147670u, 1140981846u, 1157759062u, 1174536278u, 1074921558u, 1150419030u,
				1167196246u, 1146224726u, 1163001942u, 1179779158u, 1073872983u, 1149370455u, 1166147671u, 1140981847u, 1157759063u, 1174536279u,
				1074921559u, 1150419031u, 1167196247u, 1146224727u, 1163001943u, 1179779159u, 1073872984u, 1149370456u, 1166147672u, 1140981848u,
				1157759064u, 1174536280u, 1074921560u, 1150419032u, 1167196248u, 1146224728u, 1163001944u, 1179779160u, 1075970136u, 1117913176u,
				1109524568u, 1077018712u, 1118961752u, 1114767448u, 1073872985u, 1149370457u, 1166147673u, 1140981849u, 1157759065u, 1174536281u,
				1074921561u, 1150419033u, 1167196249u, 1146224729u, 1163001945u, 1179779161u, 1075970137u, 1117913177u, 1109524569u, 1077018713u,
				1118961753u, 1114767449u, 1073872986u, 1149370458u, 1166147674u, 1140981850u, 1157759066u, 1174536282u, 1074921562u, 1150419034u,
				1167196250u, 1146224730u, 1163001946u, 1179779162u, 1075970138u, 1117913178u, 1109524570u, 1077018714u, 1118961754u, 1114767450u,
				1073872987u, 1149370459u, 1166147675u, 1140981851u, 1157759067u, 1174536283u, 1145176155u, 1161953371u, 1178730587u, 1074921563u,
				1150419035u, 1167196251u, 1142030427u, 1158807643u, 1175584859u, 1075970139u, 1151467611u, 1168244827u, 1143079003u, 1159856219u,
				1176633435u, 1073872988u, 1149370460u, 1166147676u, 1140981852u, 1157759068u, 1174536284u, 1074921564u, 1150419036u, 1167196252u,
				1146224732u, 1163001948u, 1179779164u, 1075970140u, 1117913180u, 1109524572u, 1077018716u, 1118961756u, 1114767452u, 1073872989u,
				1149370461u, 1166147677u, 1140981853u, 1157759069u, 1174536285u, 1074921565u, 1150419037u, 1167196253u, 1146224733u, 1163001949u,
				1179779165u, 1075970141u, 1117913181u, 1109524573u, 1077018717u, 1118961757u, 1114767453u, 1073872990u, 1149370462u, 1166147678u,
				1140981854u, 1157759070u, 1174536286u, 1074921566u, 1150419038u, 1167196254u, 1146224734u, 1163001950u, 1179779166u, 1075970142u,
				1117913182u, 1109524574u, 1077018718u, 1118961758u, 1114767454u, 1073872991u, 1149370463u, 1166147679u, 1140981855u, 1157759071u,
				1174536287u, 1074921567u, 1150419039u, 1167196255u, 1146224735u, 1163001951u, 1179779167u, 1075970143u, 1117913183u, 1109524575u,
				1077018719u, 1118961759u, 1114767455u, 1073872992u, 1074921568u, 1150419040u, 1167196256u, 1150419040u, 1167196256u, 1183973472u,
				1073872993u, 1074921569u, 1150419041u, 1167196257u, 1150419041u, 1167196257u, 1183973473u, 1073872994u, 1074921570u, 1150419042u,
				1167196258u, 1142030434u, 1158807650u, 1175584866u, 1073872995u, 1074921571u, 1150419043u, 1167196259u, 1150419043u, 1167196259u,
				1183973475u, 1073872996u, 1074921572u, 1150419044u, 1167196260u, 1150419044u, 1167196260u, 1183973476u, 1073872997u, 1074921573u,
				1150419045u, 1167196261u, 1150419045u, 1167196261u, 1183973477u, 1073872998u, 1074921574u, 1150419046u, 1167196262u, 1142030438u,
				1158807654u, 1175584870u, 1073872999u, 1074921575u, 1150419047u, 1167196263u, 1150419047u, 1167196263u, 1183973479u, 1073873000u,
				1074921576u, 1150419048u, 1167196264u, 1150419048u, 1167196264u, 1183973480u, 1073873001u, 1074921577u, 1150419049u, 1167196265u,
				1150419049u, 1167196265u, 1183973481u, 1073873002u, 1074921578u, 1150419050u, 1167196266u, 1142030442u, 1158807658u, 1175584874u,
				1073873003u, 1074921579u, 1150419051u, 1167196267u, 1142030443u, 1158807659u, 1175584875u, 1074921580u, 1150419052u, 1167196268u,
				1146224748u, 1163001964u, 1179779180u, 1074921581u, 1150419053u, 1167196269u, 1146224749u, 1163001965u, 1179779181u, 1073873006u,
				1073873006u, 1074921582u, 1074921582u, 1154613358u, 1146224750u, 1154613358u, 1146224750u, 1073873007u, 1074921583u, 1150419055u,
				1167196271u, 1142030447u, 1158807663u, 1175584879u, 1146224751u, 1163001967u, 1179779183u, 1075970159u, 1151467631u, 1168244847u,
				1143079023u, 1159856239u, 1176633455u, 1147273327u, 1164050543u, 1180827759u, 1144127599u, 1160904815u, 1177682031u, 1148321903u,
				1165099119u, 1181876335u, 1073873008u, 1074921584u, 1150419056u, 1167196272u, 1142030448u, 1158807664u, 1175584880u, 1075970160u,
				1151467632u, 1168244848u, 1151467632u, 1168244848u, 1185022064u, 1077018736u, 1152516208u, 1169293424u, 1152516208u, 1169293424u,
				1186070640u, 3489792113u, 3490840689u, 3566338161u, 3583115377u, 3566338161u, 3583115377u, 3599892593u, 3758227569u, 3759276145u,
				3834773617u, 3851550833u, 3834773617u, 3851550833u, 3868328049u, 4026663025u, 4027711601u, 4103209073u, 4119986289u, 4103209073u,
				4119986289u, 4136763505u, 3289514098u, 3306291314u, 3323068530u, 3293708402u, 3310485618u, 3327262834u, 3423731826u, 3440509042u,
				3457286258u, 3427926130u, 3444703346u, 3461480562u, 3489792114u, 3490840690u, 3566338162u, 3583115378u, 3557949554u, 3574726770u,
				3591503986u, 3758227570u, 3759276146u, 3834773618u, 3851550834u, 3826385010u, 3843162226u, 3859939442u, 3830579314u, 3847356530u,
				3864133746u, 4026663026u, 4027711602u, 4103209074u, 4119986290u, 4094820466u, 4111597682u, 4128374898u, 3489792115u, 3490840691u,
				3566338163u, 3583115379u, 3562143859u, 3578921075u, 3595698291u, 3625058419u, 3700555891u, 3717333107u, 3700555891u, 3717333107u,
				3734110323u, 4026663027u, 4027711603u, 4103209075u, 4119986291u, 4099014771u, 4115791987u, 4132569203u, 4161929331u, 4237426803u,
				4254204019u, 4237426803u, 4254204019u, 4270981235u, 1073873012u, 1074921588u, 1150419060u, 1167196276u, 1150419060u, 1167196276u,
				1183973492u, 1073873013u, 1074921589u, 1150419061u, 1167196277u, 1150419061u, 1167196277u, 1183973493u, 1073873014u, 1074921590u,
				1150419062u, 1167196278u, 1142030454u, 1158807670u, 1175584886u, 1073873015u, 1149370487u, 1166147703u, 1073873016u, 1073873016u,
				1140981880u, 1157759096u, 1174536312u, 1145176184u, 1161953400u, 1178730616u, 3222405240u, 1142030456u, 1158807672u, 1175584888u,
				1146224760u, 1163001976u, 1179779192u, 1122107512u, 1113718904u, 1077018744u, 1123156088u, 1114767480u, 1073873017u, 1073873017u,
				1140981881u, 1157759097u, 1174536313u, 1145176185u, 1161953401u, 1178730617u, 1074921593u, 1142030457u, 1158807673u, 1175584889u,
				1146224761u, 1163001977u, 1179779193u, 1122107513u, 1113718905u, 1077018745u, 1123156089u, 1114767481u, 1142030458u, 1158807674u,
				1175584890u, 1146224762u, 1163001978u, 1179779194u, 1143079034u, 1159856250u, 1176633466u, 1147273338u, 1164050554u, 1180827770u,
				1144127610u, 1160904826u, 1177682042u, 1148321914u, 1165099130u, 1181876346u, 1142030459u, 1158807675u, 1175584891u, 1146224763u,
				1163001979u, 1179779195u, 1122107515u, 1113718907u, 1123156091u, 1114767483u, 1074921596u, 1150419068u, 1167196284u, 1077018748u,
				1152516220u, 1169293436u, 1074921597u, 1150419069u, 1167196285u, 1077018749u, 1152516221u, 1169293437u, 1073873022u, 1073873022u,
				1074921598u, 1074921598u, 1154613374u, 1146224766u, 1154613374u, 1146224766u, 1075970174u, 1151467646u, 1147273342u, 1073873023u,
				1074921599u, 1150419071u, 1167196287u, 1142030463u, 1158807679u, 1175584895u, 1146224767u, 1163001983u, 1179779199u, 1075970175u,
				1151467647u, 1168244863u, 1143079039u, 1159856255u, 1176633471u, 1147273343u, 1164050559u, 1180827775u, 1144127615u, 1160904831u,
				1177682047u, 1148321919u, 1165099135u, 1181876351u, 131200u, 131200u, 131200u, 131201u, 131201u, 131201u,
				131202u, 131202u, 131202u, 131203u, 131203u, 131203u, 131204u, 131204u, 131204u, 131205u,
				131205u, 131205u, 131206u, 131206u, 131206u, 131207u, 131207u, 131207u, 131208u, 131208u,
				131208u, 131209u, 131209u, 131209u, 131210u, 131210u, 131210u, 131211u, 131211u, 131211u,
				131212u, 131212u, 131212u, 131213u, 131213u, 131213u, 131214u, 131214u, 131214u, 131215u,
				131215u, 131215u, 131216u, 131217u, 131218u, 131219u, 131220u, 131221u, 131222u, 131223u,
				131224u, 131225u, 131226u, 131227u, 131228u, 131229u, 131230u, 131231u, 1073873040u, 1078067344u,
				1074921616u, 1079115920u, 1073873041u, 1078067345u, 1074921617u, 1079115921u, 1073873042u, 1074921618u, 1089601682u, 1081213074u,
				1073873043u, 1074921619u, 1089601683u, 1081213075u, 1073873048u, 1078067352u, 1074921624u, 1079115928u, 1073873049u, 1078067353u,
				1074921625u, 1079115929u, 131232u, 131232u, 131232u, 131233u, 131233u, 131233u, 131234u, 131235u,
				131235u, 131235u, 131236u, 131236u, 131236u, 131237u, 131237u, 131237u, 1076078272u, 1076078272u,
				1076078272u, 1076078280u, 1076078280u, 1076078280u, 1076078288u, 1076078288u, 1076078288u, 131238u, 131238u, 239552u,
				239552u, 239552u, 1076078536u, 1076078536u, 1076078536u, 1076078544u, 1076078544u, 1076078544u, 1076078552u, 1076078552u,
				1076078552u, 1076078560u, 1076078560u, 1076078560u, 1076078568u, 1076078568u, 1076078568u, 131239u, 131239u, 131238u,
				131239u, 131239u, 131240u, 131240u, 131240u, 131241u, 131241u, 131241u, 131242u, 131243u,
				131243u, 131243u, 131244u, 131244u, 131244u, 131245u, 131245u, 131245u, 3221356718u, 3221356718u,
				3223453870u, 3223453870u, 3355574446u, 3355574446u, 3357671598u, 3357671598u, 3489792174u, 3491889326u, 3491889326u, 3548512430u,
				3624009902u, 3626107054u, 3626107054u, 3682730158u, 3758227630u, 3758227630u, 3760324782u, 3760324782u, 3892445358u, 3892445358u,
				3894542510u, 3894542510u, 4026663086u, 4026663086u, 4027711662u, 4027711662u, 4027711662u, 4028760238u, 4028760238u, 4028760238u,
				4028760238u, 4029808814u, 4029808814u, 4160880814u, 4161929390u, 1073983208u, 1073983209u, 1073983210u, 1073983211u, 1073983212u,
				1073983213u, 1073983214u, 1073983215u, 1073983216u, 1073983217u, 1073983218u, 1073983219u, 1073983220u, 1073983221u, 1073983222u,
				1073983223u, 1073983224u, 1073983225u, 1073983226u, 1073983227u, 1073983228u, 1073983229u, 1073983230u, 1073983231u, 1075031800u,
				131247u, 131247u, 131247u, 131248u, 131249u, 131249u, 131249u, 131250u, 131250u, 131250u,
				131251u, 131251u, 131251u, 131252u, 131252u, 131252u, 131253u, 131253u, 131253u, 131254u,
				131254u, 131254u, 131255u, 131255u, 131255u, 131256u, 131256u, 1075970232u, 1075970232u, 1075970232u,
				131257u, 131257u, 131257u, 2684485818u, 2684485818u, 2684485818u, 2818703546u, 2818703546u, 2818703546u, 2952921274u,
				2952921274u, 2952921274u, 3087139002u, 3087139002u, 3087139002u, 131259u, 131259u, 131259u, 131260u, 131260u,
				131260u, 1075970236u, 1075970236u, 1075970236u, 131261u, 131261u, 131261u, 1075970237u, 1075970237u, 1075970237u,
				131262u, 131262u, 131262u, 131263u, 131263u, 131263u, 131264u, 131265u, 131265u, 131265u,
				1073873090u, 1149370562u, 1166147778u, 1140981954u, 1157759170u, 1174536386u, 1074921666u, 1150419138u, 1167196354u, 1146224834u,
				1163002050u, 1179779266u, 1075970242u, 1117913282u, 1109524674u, 1077018818u, 1118961858u, 1114767554u, 1073873091u, 1073873091u,
				1073873092u, 1073873092u, 1074921668u, 1074921668u, 1154613444u, 1146224836u, 1154613444u, 1146224836u, 1073873093u, 1073873093u,
				1074921669u, 1074921669u, 1154613445u, 1146224837u, 1154613445u, 1146224837u, 1073873094u, 1149370566u, 1166147782u, 1140981958u,
				1157759174u, 1174536390u, 1074921670u, 1150419142u, 1167196358u, 1146224838u, 1163002054u, 1179779270u, 2281832647u, 2281832647u,
				3624009927u, 3624009927u, 3758227655u, 3758227655u, 3892445383u, 3892445383u, 4026663111u, 4027711687u, 4028760263u, 2952921287u,
				2952921287u, 2952921287u, 4160880839u, 3087139015u, 3087139015u, 3087139015u, 4162977991u, 4162977991u, 131272u, 131272u,
				131272u, 1074921680u, 1150419152u, 1167196368u, 1077018832u, 1152516304u, 1169293520u, 1073873105u, 1074921681u, 1150419153u,
				1167196369u, 1150419153u, 1167196369u, 1183973585u, 1073873106u, 1074921682u, 1150419154u, 1167196370u, 1142030546u, 1158807762u,
				1175584978u, 1073873107u, 1074921683u, 1150419155u, 1167196371u, 1146224851u, 1163002067u, 1179779283u, 1073873108u, 1074921684u,
				1150419156u, 1167196372u, 1146224852u, 1163002068u, 1179779284u, 1073873109u, 1074921685u, 1150419157u, 1167196373u, 1150419157u,
				1167196373u, 1183973589u, 1074921686u, 1150419158u, 1146224854u, 1075970262u, 1077018838u, 1073873111u, 1073873111u, 1074921687u,
				1074921687u, 1154613463u, 1146224855u, 1171390679u, 1163002071u, 1073873112u, 1074921688u, 1150419160u, 1167196376u, 1150419160u,
				1167196376u, 1183973592u, 1073873113u, 1074921689u, 1150419161u, 1167196377u, 1150419161u, 1167196377u, 1183973593u, 1073873114u,
				1074921690u, 1150419162u, 1167196378u, 1150419162u, 1167196378u, 1183973594u, 1073873115u, 1074921691u, 1150419163u, 1167196379u,
				1142030555u, 1158807771u, 1175584987u, 1146224859u, 1163002075u, 1179779291u, 1073873116u, 1074921692u, 1150419164u, 1167196380u,
				1150419164u, 1167196380u, 1183973596u, 1073873117u, 1074921693u, 1150419165u, 1167196381u, 1150419165u, 1167196381u, 1183973597u,
				1073873118u, 1074921694u, 1150419166u, 1167196382u, 1150419166u, 1167196382u, 1183973598u, 1073873119u, 1074921695u, 1150419167u,
				1167196383u, 1142030559u, 1158807775u, 1175584991u, 1146224863u, 1163002079u, 1179779295u, 1073873120u, 1074921696u, 1150419168u,
				1167196384u, 1150419168u, 1167196384u, 1183973600u, 1073873121u, 1074921697u, 1150419169u, 1167196385u, 1150419169u, 1167196385u,
				1183973601u, 1073873122u, 1074921698u, 1150419170u, 1167196386u, 1142030562u, 1158807778u, 1175584994u, 1146224866u, 1163002082u,
				1179779298u, 1073873123u, 1074921699u, 1150419171u, 1167196387u, 1150419171u, 1167196387u, 1183973603u, 1073873124u, 1074921700u,
				1150419172u, 1167196388u, 1150419172u, 1167196388u, 1183973604u, 1073873125u, 1074921701u, 1150419173u, 1167196389u, 1150419173u,
				1167196389u, 1183973605u, 1074921702u, 1150419174u, 1167196390u, 1146224870u, 1163002086u, 1179779302u, 1075970278u, 1151467750u,
				1168244966u, 1143079142u, 1159856358u, 1176633574u, 1147273446u, 1164050662u, 1180827878u, 1077018854u, 1152516326u, 1169293542u,
				1148322022u, 1165099238u, 1181876454u, 1073873127u, 1074921703u, 1150419175u, 1167196391u, 1142030567u, 1158807783u, 1175584999u,
				1073873128u, 1074921704u, 1150419176u, 1167196392u, 1150419176u, 1167196392u, 1183973608u, 1073873129u, 1074921705u, 1150419177u,
				1167196393u, 1150419177u, 1167196393u, 1183973609u, 1073873130u, 1074921706u, 1150419178u, 1167196394u, 1150419178u, 1167196394u,
				1183973610u, 1073873131u, 1074921707u, 1150419179u, 1167196395u, 1142030571u, 1158807787u, 1175585003u, 1146224875u, 1163002091u,
				1179779307u, 1073873132u, 1074921708u, 1150419180u, 1167196396u, 1150419180u, 1167196396u, 1183973612u, 1073873133u, 1074921709u,
				1150419181u, 1167196397u, 1150419181u, 1167196397u, 1183973613u, 1073873134u, 1074921710u, 1150419182u, 1167196398u, 1150419182u,
				1167196398u, 1183973614u, 1073873135u, 1074921711u, 1150419183u, 1167196399u, 1142030575u, 1158807791u, 1175585007u, 1146224879u,
				1163002095u, 1179779311u, 1077018864u, 1152516336u, 1169293552u, 1073873137u, 1074921713u, 1150419185u, 1167196401u, 1150419185u,
				1167196401u, 1183973617u, 1073873138u, 1074921714u, 1150419186u, 1167196402u, 1142030578u, 1158807794u, 1175585010u, 1073873139u,
				1074921715u, 1150419187u, 1167196403u, 1146224883u, 1163002099u, 1179779315u, 1073873140u, 1074921716u, 1150419188u, 1167196404u,
				1146224884u, 1163002100u, 1179779316u, 1073873141u, 1074921717u, 1150419189u, 1167196405u, 1150419189u, 1167196405u, 1183973621u,
				1073873142u, 1074921718u, 1150419190u, 1167196406u, 1150419190u, 1167196406u, 1183973622u, 1073873143u, 1074921719u, 1150419191u,
				1073873144u, 1074921720u, 1150419192u, 1167196408u, 1150419192u, 1167196408u, 1183973624u, 1073873145u, 1074921721u, 1150419193u,
				1167196409u, 1150419193u, 1167196409u, 1183973625u, 1073873146u, 1074921722u, 1150419194u, 1167196410u, 1142030586u, 1158807802u,
				1175585018u, 1073873147u, 1074921723u, 1150419195u, 1167196411u, 1146224891u, 1163002107u, 1179779323u, 1073873148u, 1074921724u,
				1150419196u, 1167196412u, 1150419196u, 1167196412u, 1183973628u, 1073873149u, 1074921725u, 1150419197u, 1167196413u, 1150419197u,
				1167196413u, 1183973629u, 1073873150u, 1074921726u, 1150419198u, 1167196414u, 1142030590u, 1158807806u, 1175585022u, 131327u,
				131327u, 131327u, 1074003968u, 1075052544u, 1150550016u, 1167327232u, 1150550016u, 1167327232u, 1184104448u, 1074003969u,
				1075052545u, 1150550017u, 1167327233u, 1074003970u, 1075052546u, 1150550018u, 1167327234u, 1074003971u, 1075052547u, 1150550019u,
				1167327235u, 1074003972u, 1075052548u, 1150550020u, 1167327236u, 1150550020u, 1167327236u, 1184104452u, 1074003973u, 1075052549u,
				1150550021u, 1167327237u, 1074003974u, 1075052550u, 1150550022u, 1167327238u, 1074003975u, 1075052551u, 1150550023u, 1167327239u,
				1074003976u, 1075052552u, 1150550024u, 1167327240u, 1074003977u, 1075052553u, 1150550025u, 1167327241u, 1074003978u, 1075052554u,
				1150550026u, 1167327242u, 1074003979u, 1075052555u, 1150550027u, 1167327243u, 1150550027u, 1167327243u, 1184104459u, 1142161420u,
				1158938636u, 1142161420u, 1158938636u, 1175715852u, 1142161421u, 1158938637u, 1146355725u, 1163132941u, 1179910157u, 1142161422u,
				1158938638u, 1142161423u, 1158938639u, 1075052560u, 1146355728u, 1163132944u, 1179910160u, 1143210000u, 1159987216u, 1176764432u,
				1146355729u, 1163132945u, 1179910161u, 1143210001u, 1159987217u, 1176764433u, 1146355730u, 1163132946u, 1179910162u, 1143210002u,
				1159987218u, 1176764434u, 1142161427u, 1158938643u, 1142161427u, 1158938643u, 1175715859u, 1143210003u, 1159987219u, 1176764435u,
				1075052564u, 1142161428u, 1158938644u, 1175715860u, 1146355732u, 1163132948u, 1179910164u, 1143210004u, 1159987220u, 1176764436u,
				1075052565u, 1142161429u, 1158938645u, 1175715861u, 1146355733u, 1163132949u, 1179910165u, 1143210005u, 1159987221u, 1176764437u,
				1158938646u, 1158938646u, 1175715862u, 1163132950u, 1179910166u, 1075052567u, 1150550039u, 1167327255u, 1142161432u, 1158938648u,
				1142161432u, 1158938648u, 1175715864u, 1158938649u, 1158938649u, 1175715865u, 1163132953u, 1179910169u, 1158938650u, 1158938650u,
				1175715866u, 1163132954u, 1179910170u, 1175715867u, 1179910171u, 1074003996u, 1075052572u, 1150550044u, 1167327260u, 1150550044u,
				1167327260u, 1184104476u, 1074003997u, 1075052573u, 1150550045u, 1167327261u, 1150550045u, 1167327261u, 1184104477u, 1074003998u,
				1075052574u, 1150550046u, 1167327262u, 1142161438u, 1158938654u, 1175715870u, 1146355743u, 1163132959u, 1179910175u, 1075052576u,
				1150550048u, 1167327264u, 1150550048u, 1167327264u, 1184104480u, 1143210016u, 1159987232u, 1176764448u, 1075052577u, 1150550049u,
				1167327265u, 1150550049u, 1167327265u, 1184104481u, 1143210017u, 1159987233u, 1176764449u, 1075052578u, 1150550050u, 1167327266u,
				1150550050u, 1167327266u, 1184104482u, 1143210018u, 1159987234u, 1176764450u, 1075052579u, 1150550051u, 1167327267u, 1150550051u,
				1167327267u, 1184104483u, 1143210019u, 1159987235u, 1176764451u, 1075052580u, 1150550052u, 1167327268u, 1150550052u, 1167327268u,
				1184104484u, 1143210020u, 1159987236u, 1176764452u, 1075052581u, 1150550053u, 1167327269u, 1142161445u, 1158938661u, 1175715877u,
				1143210021u, 1159987237u, 1176764453u, 1142161446u, 1158938662u, 1175715878u, 1146355750u, 1163132966u, 1179910182u, 1143210022u,
				1159987238u, 1176764454u, 1147404326u, 1164181542u, 1180958758u, 1142161447u, 1158938663u, 1175715879u, 1146355751u, 1163132967u,
				1179910183u, 1143210023u, 1159987239u, 1176764455u, 1147404327u, 1164181543u, 1180958759u, 1075052584u, 1150550056u, 1167327272u,
				1146355752u, 1163132968u, 1179910184u, 1143210024u, 1159987240u, 1176764456u, 1147404328u, 1164181544u, 1180958760u, 1075052585u,
				1150550057u, 1167327273u, 1146355753u, 1163132969u, 1179910185u, 1143210025u, 1159987241u, 1176764457u, 1147404329u, 1164181545u,
				1180958761u, 1075052586u, 1150550058u, 1167327274u, 1142161450u, 1158938666u, 1175715882u, 1147404330u, 1164181546u, 1180958762u,
				1075052587u, 1150550059u, 1167327275u, 1142161451u, 1158938667u, 1175715883u, 1142161452u, 1158938668u, 1142161452u, 1158938668u,
				1175715884u, 1146355756u, 1163132972u, 1179910188u, 1142161453u, 1158938669u, 1108607021u, 1112801325u, 1142161454u, 1158938670u,
				1142161455u, 1158938671u, 1075052592u, 1150550064u, 1167327280u, 1150550064u, 1167327280u, 1184104496u, 1143210032u, 1159987248u,
				1176764464u, 1075052593u, 1150550065u, 1167327281u, 1150550065u, 1167327281u, 1184104497u, 1143210033u, 1159987249u, 1176764465u,
				1075052594u, 1150550066u, 1167327282u, 1150550066u, 1167327282u, 1184104498u, 1143210034u, 1159987250u, 1176764466u, 1075052595u,
				1150550067u, 1167327283u, 1150550067u, 1167327283u, 1184104499u, 1143210035u, 1159987251u, 1176764467u, 1075052596u, 1150550068u,
				1167327284u, 1150550068u, 1167327284u, 1184104500u, 1143210036u, 1159987252u, 1176764468u, 1075052597u, 1150550069u, 1167327285u,
				1142161461u, 1158938677u, 1175715893u, 1143210037u, 1159987253u, 1176764469u, 1158938678u, 1158938678u, 1175715894u, 1163132982u,
				1179910198u, 1075052599u, 1150550071u, 1167327287u, 1146355767u, 1163132983u, 1179910199u, 1075052600u, 1150550072u, 1167327288u,
				1150550072u, 1167327288u, 1184104504u, 1143210040u, 1159987256u, 1176764472u, 1147404344u, 1164181560u, 1180958776u, 1075052601u,
				1150550073u, 1167327289u, 1142161465u, 1158938681u, 1175715897u, 1146355769u, 1163132985u, 1179910201u, 1143210041u, 1159987257u,
				1176764473u, 1147404345u, 1164181561u, 1180958777u, 1075052602u, 1150550074u, 1167327290u, 1150550074u, 1167327290u, 1184104506u,
				1143210042u, 1159987258u, 1176764474u, 1075052603u, 1150550075u, 1167327291u, 1142161467u, 1158938683u, 1175715899u, 1146355771u,
				1163132987u, 1179910203u, 1075052604u, 1150550076u, 1167327292u, 1150550076u, 1167327292u, 1184104508u, 1075052605u, 1150550077u,
				1167327293u, 1142161469u, 1158938685u, 1175715901u, 1146355773u, 1163132989u, 1179910205u, 1075052606u, 1150550078u, 1167327294u,
				1150550078u, 1167327294u, 1184104510u, 1075052607u, 1150550079u, 1167327295u, 1142161471u, 1158938687u, 1175715903u, 1146355775u,
				1163132991u, 1179910207u, 1075052608u, 1150550080u, 1167327296u, 1142161472u, 1158938688u, 1175715904u, 1146355776u, 1163132992u,
				1179910208u, 1075052609u, 1150550081u, 1142161474u, 1158938690u, 1175715906u, 1146355778u, 1163132994u, 1179910210u, 1108607043u,
				1112801347u, 1142161476u, 1158938692u, 1175715908u, 1146355780u, 1163132996u, 1179910212u, 1142161477u, 1158938693u, 1146355781u,
				1163132997u, 1142161477u, 1158938693u, 1175715909u, 1146355781u, 1163132997u, 1179910213u, 1142161478u, 1158938694u, 1142161478u,
				1158938694u, 1175715910u, 1146355782u, 1163132998u, 1179910214u, 1142161479u, 1158938695u, 1146355783u, 1163132999u, 1142161479u,
				1158938695u, 1175715911u, 1146355783u, 1163132999u, 1179910215u, 1142161484u, 1158938700u, 1175715916u, 1146355788u, 1163133004u,
				1179910220u, 1108607053u, 1112801357u, 1142161486u, 1158938702u, 1175715918u, 1146355790u, 1163133006u, 1179910222u, 1108607055u,
				1112801359u, 1142161488u, 1158938704u, 1175715920u, 1142161489u, 1158938705u, 1175715921u, 1142161490u, 1158938706u, 1175715922u,
				1143210066u, 1159987282u, 1176764498u, 1177813074u, 1142161491u, 1158938707u, 1175715923u, 1177813075u, 1142161492u, 1158938708u,
				1175715924u, 1146355796u, 1163133012u, 1179910228u, 1142161493u, 1158938709u, 1175715925u, 1146355797u, 1163133013u, 1179910229u,
				1142161496u, 1158938712u, 1142161496u, 1158938712u, 1175715928u, 1142161497u, 1158938713u, 1142161497u, 1158938713u, 1175715929u,
				1146355801u, 1163133017u, 1179910233u, 1158938714u, 1158938714u, 1175715930u, 1163133018u, 1179910234u, 1175715931u, 1179910235u,
				1142161506u, 1158938722u, 1175715938u, 1146355810u, 1163133026u, 1179910242u, 1142161507u, 1158938723u, 1175715939u, 1146355811u,
				1163133027u, 1179910243u, 1142161508u, 1158938724u, 1175715940u, 1146355812u, 1163133028u, 1179910244u, 1142161509u, 1158938725u,
				1175715941u, 1146355813u, 1163133029u, 1179910245u, 1142161510u, 1158938726u, 1175715942u, 1146355814u, 1163133030u, 1179910246u,
				1144258664u, 1161035880u, 1177813096u, 1148452968u, 1165230184u, 1182007400u, 1146355824u, 1163133040u, 1179910256u, 1142161521u,
				1158938737u, 1175715953u, 1146355825u, 1163133041u, 1179910257u, 1146355826u, 1163133042u, 1179910258u, 1143210098u, 1159987314u,
				1176764530u, 1144258674u, 1161035890u, 1177813106u, 1142161523u, 1158938739u, 1175715955u, 1146355827u, 1163133043u, 1179910259u,
				1142161525u, 1158938741u, 1175715957u, 1146355829u, 1163133045u, 1179910261u, 1142161526u, 1158938742u, 1175715958u, 1146355830u,
				1163133046u, 1179910262u, 1142161527u, 1158938743u, 1175715959u, 1146355831u, 1163133047u, 1179910263u, 1142161528u, 1158938744u,
				1142161528u, 1158938744u, 1175715960u, 1142161529u, 1158938745u, 1142161529u, 1158938745u, 1175715961u, 1142161530u, 1158938746u,
				1175715962u, 1142161531u, 1158938747u, 1175715963u, 1154744444u, 1171521660u, 1188298876u, 1146355836u, 1163133052u, 1179910268u,
				1142161533u, 1158938749u, 1175715965u, 1146355837u, 1163133053u, 1179910269u, 1142161534u, 1158938750u, 1175715966u, 1146355838u,
				1163133054u, 1179910270u, 1142161535u, 1158938751u, 1175715967u, 1146355839u, 1163133055u, 1179910271u, 1075052672u, 1075052672u,
				1075052673u, 1075052673u, 1075052674u, 1075052674u, 1146355843u, 1163133059u, 1179910275u, 1142161544u, 1158938760u, 1175715976u,
				1146355848u, 1163133064u, 1179910280u, 1142161545u, 1158938761u, 1175715977u, 1146355849u, 1163133065u, 1179910281u, 1142161546u,
				1158938762u, 1175715978u, 1146355850u, 1163133066u, 1179910282u, 1142161547u, 1158938763u, 1175715979u, 1146355851u, 1163133067u,
				1179910283u, 1142161548u, 1158938764u, 1146355852u, 1163133068u, 1142161549u, 1158938765u, 1175715981u, 1146355853u, 1163133069u,
				1179910285u, 1142161550u, 1158938766u, 1146355854u, 1163133070u, 1142161551u, 1158938767u, 1175715983u, 1142161552u, 1158938768u,
				1146355856u, 1163133072u, 1142161552u, 1158938768u, 1175715984u, 1146355856u, 1163133072u, 1179910288u, 1142161553u, 1158938769u,
				1146355857u, 1163133073u, 1142161553u, 1158938769u, 1175715985u, 1146355857u, 1163133073u, 1179910289u, 1142161554u, 1158938770u,
				1146355858u, 1163133074u, 1142161554u, 1158938770u, 1175715986u, 1146355858u, 1163133074u, 1179910290u, 1142161555u, 1158938771u,
				1146355859u, 1163133075u, 1142161555u, 1158938771u, 1175715987u, 1146355859u, 1163133075u, 1179910291u, 1142161558u, 1158938774u,
				1146355862u, 1163133078u, 1142161558u, 1158938774u, 1175715990u, 1146355862u, 1163133078u, 1179910294u, 1142161559u, 1158938775u,
				1146355863u, 1163133079u, 1142161559u, 1158938775u, 1175715991u, 1146355863u, 1163133079u, 1179910295u, 1142161560u, 1158938776u,
				1146355864u, 1163133080u, 1142161560u, 1158938776u, 1175715992u, 1146355864u, 1163133080u, 1179910296u, 1108607129u, 1112801433u,
				1108607129u, 1112801433u, 1142161562u, 1158938778u, 1146355866u, 1163133082u, 1142161562u, 1158938778u, 1175715994u, 1146355866u,
				1163133082u, 1179910298u, 1177813146u, 1108607131u, 1112801435u, 1108607131u, 1112801435u, 1110704283u, 1142161564u, 1158938780u,
				1146355868u, 1163133084u, 1142161564u, 1158938780u, 1175715996u, 1146355868u, 1163133084u, 1179910300u, 1108607133u, 1112801437u,
				1108607133u, 1112801437u, 1142161566u, 1158938782u, 1146355870u, 1163133086u, 1142161566u, 1158938782u, 1175715998u, 1146355870u,
				1163133086u, 1179910302u, 1108607135u, 1112801439u, 1108607135u, 1112801439u, 1142161568u, 1158938784u, 1175716000u, 1146355872u,
				1163133088u, 1179910304u, 1142161569u, 1158938785u, 1175716001u, 1146355873u, 1163133089u, 1179910305u, 1142161570u, 1158938786u,
				1175716002u, 1146355874u, 1163133090u, 1179910306u, 1142161571u, 1158938787u, 1175716003u, 1146355875u, 1163133091u, 1179910307u,
				1142161574u, 1158938790u, 1146355878u, 1163133094u, 1142161574u, 1158938790u, 1175716006u, 1146355878u, 1163133094u, 1179910310u,
				1142161575u, 1158938791u, 1146355879u, 1163133095u, 1142161575u, 1158938791u, 1175716007u, 1146355879u, 1163133095u, 1179910311u,
				1142161576u, 1158938792u, 1146355880u, 1163133096u, 1142161576u, 1158938792u, 1175716008u, 1146355880u, 1163133096u, 1179910312u,
				1108607145u, 1112801449u, 1108607145u, 1112801449u, 1142161578u, 1158938794u, 1146355882u, 1163133098u, 1142161578u, 1158938794u,
				1175716010u, 1146355882u, 1163133098u, 1179910314u, 1177813162u, 1108607147u, 1112801451u, 1108607147u, 1112801451u, 1110704299u,
				1142161580u, 1158938796u, 1146355884u, 1163133100u, 1142161580u, 1158938796u, 1175716012u, 1146355884u, 1163133100u, 1179910316u,
				1108607149u, 1112801453u, 1108607149u, 1112801453u, 1142161582u, 1158938798u, 1146355886u, 1163133102u, 1142161582u, 1158938798u,
				1175716014u, 1146355886u, 1163133102u, 1179910318u, 1108607151u, 1112801455u, 1108607151u, 1112801455u, 1146355892u, 1163133108u,
				1179910324u, 1146355893u, 1163133109u, 1179910325u, 1142161590u, 1158938806u, 1146355894u, 1163133110u, 1142161590u, 1158938806u,
				1175716022u, 1146355894u, 1163133110u, 1179910326u, 1142161591u, 1158938807u, 1146355895u, 1163133111u, 1142161591u, 1158938807u,
				1175716023u, 1146355895u, 1163133111u, 1179910327u, 1142161592u, 1158938808u, 1146355896u, 1163133112u, 1142161592u, 1158938808u,
				1175716024u, 1146355896u, 1163133112u, 1179910328u, 1108607161u, 1112801465u, 1108607161u, 1112801465u, 1142161594u, 1158938810u,
				1146355898u, 1163133114u, 1142161594u, 1158938810u, 1175716026u, 1146355898u, 1163133114u, 1179910330u, 1108607163u, 1112801467u,
				1108607163u, 1112801467u, 1142161596u, 1158938812u, 1146355900u, 1163133116u, 1142161596u, 1158938812u, 1175716028u, 1146355900u,
				1163133116u, 1179910332u, 1108607165u, 1112801469u, 1108607165u, 1112801469u, 1142161598u, 1158938814u, 1146355902u, 1163133118u,
				1142161598u, 1158938814u, 1175716030u, 1146355902u, 1163133118u, 1179910334u, 1108607167u, 1112801471u, 1108607167u, 1112801471u,
				1142161604u, 1158938820u, 1175716036u, 1146355908u, 1163133124u, 1179910340u, 3457417414u, 3461611718u, 3591635142u, 3595829446u,
				3994288326u, 3998482630u, 4128506054u, 4132700358u, 3457417415u, 3461611719u, 3591635143u, 3595829447u, 3994288327u, 3998482631u,
				4128506055u, 4132700359u, 1074004168u, 1175716040u, 1179910344u, 1074004169u, 1074004170u, 1175716042u, 1179910346u, 1074004171u,
				1108607179u, 1112801483u, 1074004172u, 1175716044u, 1179910348u, 1074004173u, 1108607181u, 1112801485u, 1075052751u, 1142161615u,
				1158938831u, 1142161615u, 1158938831u, 1175716047u, 1075052763u, 1150550235u, 1075052764u, 1150550236u, 1167327452u, 1150550236u,
				1167327452u, 1184104668u, 1075052765u, 1150550237u, 1167327453u, 1150550237u, 1167327453u, 1184104669u, 1075052766u, 1150550238u,
				1167327454u, 1150550238u, 1167327454u, 1184104670u, 1075052767u, 1150550239u, 1167327455u, 1150550239u, 1167327455u, 1184104671u,
				262384u, 262384u, 262384u, 1077149936u, 1077149936u, 262385u, 262385u, 262385u, 1077149937u, 1077149937u,
				1077149937u, 1136918770u, 1128530162u, 3418620147u, 3410231539u, 3552837875u, 3544449267u, 3687055603u, 3678666995u, 1136918773u,
				1128530165u, 1075052789u, 1075052789u, 1139015925u, 1130627317u, 1140064501u, 1131675893u, 1074004214u, 1074004214u, 1075052790u,
				1075052790u, 1076101366u, 1076101366u, 1140064502u, 1131675894u, 1136918775u, 1128530167u, 1137967351u, 1129578743u, 1139015927u,
				1130627319u, 1140064503u, 1131675895u, 1075052792u, 1075052792u, 1075052792u, 1076101368u, 1076101368u, 1076101368u, 1077149944u,
				1077149944u, 1077149944u, 1074004217u, 1074004217u, 1163264000u, 1163264000u, 1180041216u, 1163264001u, 1163264001u, 1180041217u,
				1142292482u, 1159069698u, 1142292483u, 1159069699u, 1175846915u, 1146486787u, 1163264003u, 1180041219u, 1142292484u, 1159069700u,
				1142292484u, 1159069700u, 1175846916u, 1142292485u, 1159069701u, 1146486789u, 1163264005u, 1180041221u, 1159069702u, 1075183624u,
				1150681096u, 1167458312u, 1142292488u, 1159069704u, 1175846920u, 1075183625u, 1150681097u, 1167458313u, 1146486793u, 1163264009u,
				1180041225u, 1075183626u, 1117126666u, 1108738058u, 1075183627u, 1117126667u, 1112932363u, 1075183628u, 1150681100u, 1167458316u,
				1075183629u, 1150681101u, 1167458317u, 1075183630u, 1150681102u, 1167458318u, 1074135055u, 1075183631u, 1150681103u, 1167458319u,
				1150681103u, 1167458319u, 1184235535u, 1075183636u, 1075183636u, 1154875412u, 1146486804u, 1154875412u, 1146486804u, 1075183637u,
				1075183637u, 1154875413u, 1146486805u, 1154875413u, 1146486805u, 1075183638u, 1075183638u, 1154875414u, 1146486806u, 1154875414u,
				1146486806u, 1075183639u, 1075183639u, 1154875415u, 1146486807u, 1154875415u, 1146486807u, 1159069720u, 1159069720u, 1175846936u,
				1163264024u, 1180041240u, 1159069721u, 1159069721u, 1175846937u, 1163264025u, 1180041241u, 1175846938u, 1180041242u, 1175846939u,
				1180041243u, 1142292509u, 1159069725u, 1142292509u, 1159069725u, 1175846941u, 1142292510u, 1159069726u, 1175846942u, 1146486814u,
				1163264030u, 1180041246u, 1142292511u, 1159069727u, 1175846943u, 1146486815u, 1163264031u, 1180041247u, 1075183648u, 1075183648u,
				1154875424u, 1146486816u, 1154875424u, 1146486816u, 1075183649u, 1150681121u, 1142292513u, 1075183650u, 1075183650u, 1154875426u,
				1146486818u, 1154875426u, 1146486818u, 1159069731u, 1175846947u, 1163264035u, 1180041251u, 1142292517u, 1159069733u, 1175846949u,
				1146486821u, 1163264037u, 1180041253u, 1142292518u, 1159069734u, 1175846950u, 1146486822u, 1163264038u, 1180041254u, 1108738087u,
				1112932391u, 1075183664u, 1079377968u, 1075183665u, 1079377969u, 1075183666u, 1079377970u, 1075183667u, 1079377971u, 1159069752u,
				1159069752u, 1175846968u, 1163264056u, 1180041272u, 1159069753u, 1159069753u, 1175846969u, 1163264057u, 1180041273u, 1175846970u,
				1180041274u, 1175846971u, 1180041275u, 1142292542u, 1159069758u, 1175846974u, 1146486846u, 1163264062u, 1180041278u, 1142292543u,
				1159069759u, 1175846975u, 1146486847u, 1163264063u, 1180041279u, 1075183680u, 1150681152u, 1167458368u, 1075183681u, 1150681153u,
				1075183682u, 1150681154u, 1167458370u, 1142292546u, 1159069762u, 1175846978u, 1159069763u, 1175846979u, 1163264067u, 1180041283u,
				1075183684u, 1150681156u, 1167458372u, 1150681156u, 1167458372u, 1184235588u, 1159069766u, 1142292552u, 1159069768u, 1146486856u,
				1163264072u, 1142292553u, 1159069769u, 1146486857u, 1163264073u, 1142292554u, 1159069770u, 1142292555u, 1159069771u, 1142292556u,
				1159069772u, 1142292560u, 1159069776u, 1175846992u, 1146486864u, 1163264080u, 1180041296u, 1108738129u, 1112932433u, 1142292564u,
				1159069780u, 1175846996u, 1146486868u, 1163264084u, 1180041300u, 1108738133u, 1112932437u, 1142292566u, 1159069782u, 1175846998u,
				1146486870u, 1163264086u, 1180041302u, 1108738135u, 1112932439u, 1142292572u, 1159069788u, 1146486876u, 1163264092u, 1142292573u,
				1159069789u, 1146486877u, 1163264093u, 1142292574u, 1159069790u, 1146486878u, 1163264094u, 1142292575u, 1159069791u, 1146486879u,
				1163264095u, 1075183712u, 1075183712u, 1154875488u, 1146486880u, 1075183713u, 1075183713u, 1154875489u, 1146486881u, 1075183714u,
				1150681186u, 1075183715u, 1150681187u, 1142292582u, 1159069798u, 1175847014u, 1146486886u, 1163264102u, 1180041318u, 1108738151u,
				1112932455u, 1142292584u, 1159069800u, 1146486888u, 1163264104u, 1142292585u, 1159069801u, 1146486889u, 1163264105u, 1108738154u,
				1112932458u, 1108738155u, 1112932459u, 1142292588u, 1159069804u, 1146486892u, 1163264108u, 1142292589u, 1159069805u, 1146486893u,
				1163264109u, 1108738158u, 1112932462u, 1108738159u, 1112932463u, 1146486896u, 1163264112u, 1180041328u, 1142292593u, 1159069809u,
				1175847025u, 1146486897u, 1163264113u, 1180041329u, 1146486898u, 1163264114u, 1180041330u, 1142292595u, 1159069811u, 1175847027u,
				1146486899u, 1163264115u, 1180041331u, 1142292600u, 1159069816u, 1146486904u, 1163264120u, 1142292601u, 1159069817u, 1146486905u,
				1163264121u, 1108738170u, 1112932474u, 1108738171u, 1112932475u, 1142292604u, 1159069820u, 1146486908u, 1163264124u, 1142292605u,
				1159069821u, 1146486909u, 1163264125u, 1108738174u, 1112932478u, 1108738175u, 1112932479u, 1074135244u, 1075183822u, 1146486990u,
				1163264206u, 1146486990u, 1163264206u, 1180041422u, 1075183823u, 1146486991u, 1163264207u, 1146486991u, 1163264207u, 1180041423u,
				1075183839u, 1150681311u, 1140195568u, 1131806960u, 1140850821u, 1140850822u, 1140850823u, 1140850830u, 1140850831u, 1140850837u,
				1140850838u, 1140850839u, 1140850846u, 1140850847u, 1140850850u, 1157628066u, 1145045154u, 1161822370u, 1140850851u, 1145045155u,
				1140850854u, 1140850870u, 1140850880u, 1140850881u, 1140850882u, 1140850883u, 1140850892u, 1140850893u, 1140850894u, 1140850895u,
				1140850924u, 1140850925u, 1140850926u, 1140850927u, 3368157185u, 3359768577u, 3502374913u, 3493986305u, 3636592641u, 3628204033u,
				3770810369u, 3762421761u, 3905028097u, 3896639489u, 4039245825u, 4030857217u, 4173463553u, 4165074945u, 3368157186u, 3359768578u,
				4039245826u, 4030857218u, 3233939474u, 3225550866u, 3368157202u, 3359768594u, 1140981888u, 1157759104u, 1140981889u, 1157759105u,
				1140981890u, 1140981891u, 1140981904u, 1145176208u, 1140981905u, 1145176209u, 1140981906u, 1145176210u, 1140981907u, 1145176211u,
				1140981908u, 1145176212u, 1140981909u, 1145176213u, 1140981910u, 1145176214u, 1140981911u, 1145176215u, 1140981912u, 1145176216u,
				1140981913u, 1145176217u, 1140981914u, 1145176218u, 1140981915u, 1145176219u, 1140981953u, 1140981954u, 1140981955u, 1140981958u,
				1140981959u, 1140981963u, 1140981969u, 1140981970u, 1140981971u, 1140981974u, 1140981975u, 1140981979u, 1140981985u, 1140981986u,
				1140981987u, 1086586896u, 1078198288u, 3234070546u, 3225681938u, 3368288274u, 3359899666u, 12u, 13u, 28u,
				29u, 134u, 135u, 138u, 142u, 144u, 148u, 150u, 151u, 154u,
				158u, 160u, 164u, 166u, 167u, 170u, 174u, 176u, 180u, 182u,
				183u, 187u, 191u, 1076036094u, 1077084670u, 1076036095u, 1077084671u, 1077084671u, 1077084671u, 1073938920u,
				1077084648u, 1077084649u, 1073938942u, 1073938942u, 1073938942u, 1073938943u, 2550267917u, 2684485645u, 2818703373u, 2952921101u,
				3087138829u, 131327u, 1076036057u, 1073872951u, 3288596553u, 1141197248u, 3289645129u, 1144258633u, 1142161483u, 1143210059u,
				1144258635u, 1143210076u, 1141112926u, 1142161502u, 1143210078u, 1144258654u, 122849u, 122850u, 2147614774u, 2147614775u,
				131128u, 131129u, 131130u, 131192u, 131193u, 2147614842u, 2147614843u, 2147614844u, 2147614845u, 131198u,
				131130u, 131131u, 131132u, 131133u, 131135u, 131152u, 131153u, 131154u, 131156u, 131157u,
				131160u, 131161u, 131162u, 131163u, 131164u, 131165u, 131166u, 121303u, 121314u, 121318u,
				121319u, 121852u, 122364u, 122584u, 122586u, 122588u, 122589u, 122590u, 122876u, 1074987468u,
				1074987469u, 1074987470u, 1074987471u, 3223584984u, 3357802712u, 3492020440u, 3626238168u, 1076101340u, 1076101340u, 1076101341u,
				1076101342u, 1076101343u, 1076101370u, 1076101371u, 1142161432u, 1158938648u, 1158938649u, 1077084633u, 1076036076u, 1076036077u,
				1076036078u, 1076036079u, 4028760263u, 1076359360u, 1142161488u, 1158938704u, 1142161489u, 1158938705u, 1142161490u, 1158938706u,
				1142161491u, 1158938707u, 1076078312u, 1076078312u, 1076078312u, 1076078576u, 1076078576u, 1076078576u, 4029808640u, 4029808640u,
				4029808640u, 1076036042u, 1077084618u, 1141506136u, 1158283352u, 1175060568u, 1110048856u, 1141244098u, 1158021314u, 1174798530u,
				1109786818u, 1107951663u, 1141506139u, 1158283355u, 1175060571u, 1146749018u, 1163526234u, 1180303450u, 1142554715u, 1159331931u,
				1176109147u, 1141506138u, 1158283354u, 1175060570u, 1142685715u, 1159462931u, 1176240147u, 1142554747u, 1159331963u, 1176109179u,
				1141506169u, 1158283385u, 1175060601u, 1142554745u, 1159331961u, 1176109177u, 1141506173u, 1158283389u, 1175060605u, 1142554749u,
				1159331965u, 1176109181u, 1142554653u, 1159331869u, 1176109085u, 1145700443u, 1162477659u, 1179254875u, 1115291738u, 1110048858u,
				1122631725u, 1114243117u, 1108082707u, 1122631801u, 1114243193u, 1122631722u, 1114243114u, 1107951645u, 1143603291u, 1160380507u,
				1177157723u, 1142554746u, 1159331962u, 1176109178u, 1141506168u, 1158283384u, 1175060600u, 1142554744u, 1159331960u, 1176109176u,
				1141506172u, 1158283388u, 1175060604u, 1142554748u, 1159331964u, 1176109180u, 1122631724u, 1114243116u, 1122631800u, 1114243192u,
				1144651898u, 1161429114u, 1178206330u, 1148846202u, 1165623418u, 1182400634u, 1122631803u, 1114243195u, 1144651901u, 1161429117u,
				1178206333u, 1143603325u, 1160380541u, 1177157757u, 1141506142u, 1158283358u, 1175060574u, 1110048862u, 1144782934u, 1161560150u,
				1178337366u, 1143734358u, 1160511574u, 1177288790u, 1111228503u, 1110179927u, 1144783062u, 1161560278u, 1178337494u, 1143734486u,
				1160511702u, 1177288918u, 1111228631u, 1110180055u, 1142685846u, 1159463062u, 1176240278u, 1142685862u, 1159463078u, 1176240294u,
				1142685878u, 1159463094u, 1176240310u, 1142685847u, 1159463063u, 1176240279u, 1142685863u, 1159463079u, 1176240295u, 1142685879u,
				1159463095u, 1176240311u, 1142685848u, 1159463064u, 1176240280u, 1142685864u, 1159463080u, 1176240296u, 1142685880u, 1159463096u,
				1176240312u, 1142685852u, 1159463068u, 1176240284u, 1142685868u, 1159463084u, 1176240300u, 1142685884u, 1159463100u, 1176240316u,
				1109131417u, 1109131433u, 1109131449u, 1109131421u, 1109131437u, 1109131453u, 1142685850u, 1159463066u, 1176240282u, 1142685866u,
				1159463082u, 1176240298u, 1142685882u, 1159463098u, 1176240314u, 1142685854u, 1159463070u, 1176240286u, 1142685870u, 1159463086u,
				1176240302u, 1142685886u, 1159463102u, 1176240318u, 1109131419u, 1109131435u, 1109131451u, 1109131423u, 1109131439u, 1109131455u,
				1141244006u, 1158021222u, 1174798438u, 1107689575u, 1142685762u, 1159462978u, 1176240194u, 1109131331u, 1141243942u, 1158021158u,
				1174798374u, 1107689511u, 1141506143u, 1158283359u, 1175060575u, 1110048863u, 1141506141u, 1158283357u, 1175060573u, 1110048861u,
				1110048784u, 1110048785u, 1110048784u, 1110048785u, 1155137646u, 1146749038u, 1155137662u, 1146749054u, 1141506137u, 1158283353u,
				1175060569u, 1110048857u, 1142685772u, 1159462988u, 1176240204u, 1109131341u, 1141243990u, 1158021206u, 1174798422u, 1107689559u,
				1141243912u, 1158021128u, 1174798344u, 1107689482u, 1142685774u, 1159462990u, 1176240206u, 1109131343u, 1142685740u, 1159462956u,
				1176240172u, 1109131309u, 1141506129u, 1158283345u, 1175060561u, 1110048849u, 1141506140u, 1158283356u, 1175060572u, 1110048860u,
				1107951662u, 131086u, 131087u, 1140850804u, 1140850805u, 3296854040u, 3431071768u, 3565289496u, 3699507224u, 3833724952u,
				3967942680u, 4102160408u, 4236378136u, 1140981825u, 1140981826u, 1140981827u, 1140981828u, 1140981829u, 1140981830u, 1140981831u,
				1140981832u, 1140981833u, 1140981892u, 1140981893u, 1140981904u, 1140981906u, 1140981907u, 1140981909u, 1140981911u, 1140981912u,
				4108452014u, 4100063406u, 4109500590u, 4101111982u, 4238475438u, 4239524014u, 1155662008u, 1147273400u, 1155662012u, 1147273404u,
				1156710588u, 1148321980u, 1155662013u, 1147273405u, 1143210224u, 1147404528u, 1144258800u, 1148453104u, 1144258801u, 1148453105u,
				1142292542u, 3330408472u, 3464626200u, 3598843928u, 3733061656u, 3867279384u, 4001497112u, 4135714840u, 4269932568u, 1174536232u,
				1179779112u, 1174536233u, 1179779113u, 1180827689u, 1180827689u, 1177681961u, 1177681961u, 1174536280u, 1179779160u, 1174536281u,
				1179779161u, 1174536282u, 1179779162u, 1174536284u, 1179779164u, 1175584870u, 1175584879u, 1179779183u, 1175584880u, 3591503986u,
				3859939442u, 4128374898u, 1175584886u, 1176633466u, 1175584895u, 1179779199u, 4272029870u, 4273078446u, 1174536386u, 1179779266u,
				1175584987u, 1179779291u, 1175584991u, 1179779295u, 1176633574u, 1175585003u, 1179779307u, 1175585007u, 1179779311u, 1175585018u,
				1175585022u, 1175715864u, 1179910169u, 1175715866u, 1179910171u, 1175715879u, 1175715894u, 1175715897u, 1175715899u, 1175715901u,
				1175715903u, 1175715904u, 1175715906u, 1179910210u, 1175715909u, 1175715910u, 1175715911u, 1175715912u, 1175715913u, 1175715914u,
				1175715915u, 1175715920u, 1179910224u, 1175715921u, 1175715922u, 1179910226u, 1175715923u, 1179910227u, 1175715924u, 1175715925u,
				1179910229u, 1175715926u, 1175715927u, 1175715928u, 1179910233u, 1175715930u, 1179910235u, 1175715932u, 1175715933u, 1175715934u,
				1175715935u, 1175715940u, 1179910244u, 1175715941u, 1179910245u, 1175715943u, 1175715944u, 1175715945u, 1175715946u, 1175715947u,
				1175715948u, 1175715949u, 1179910253u, 1175715950u, 1175715951u, 1175715952u, 1175715953u, 1175715954u, 1175715955u, 1175715956u,
				1175715972u, 1175715974u, 1175715975u, 1175715984u, 1179910288u, 1175715986u, 1179910290u, 1175715988u, 1179910292u, 1175715992u,
				1179910296u, 1175715994u, 1179910298u, 1175715996u, 1179910300u, 1175715998u, 1179910302u, 1175716000u, 1179910304u, 1175716002u,
				1179910306u, 1175716004u, 1175716008u, 1179910312u, 1175716010u, 1179910314u, 1175716012u, 1179910316u, 1175716014u, 1179910318u,
				1175716016u, 1175716018u, 1175716020u, 1175716021u, 1175716024u, 1179910328u, 1175716026u, 1179910330u, 1175716028u, 1179910332u,
				1175716030u, 1179910334u, 1175716032u, 3323199686u, 3327393990u, 3457417414u, 3591635142u, 3860070598u, 3864264902u, 3994288326u,
				4128506054u, 1175716040u, 1175716041u, 1175716042u, 1175716043u, 1175716044u, 1175716045u, 1175716046u, 1179910350u, 1175716047u,
				1174667472u, 1178861776u, 1175716048u, 1179910352u, 1174667473u, 1178861777u, 1175716049u, 1179910353u, 1174667474u, 1175716050u,
				1174667475u, 1174667476u, 1178861780u, 1175716052u, 1179910356u, 1174667477u, 1178861781u, 1175716053u, 1179910357u, 1174667478u,
				1175716054u, 1174667479u, 1175846915u, 1175846919u, 1175846942u, 1175846943u, 1175846950u, 1180041254u, 1175846994u, 1180041298u,
				1174798538u, 1175847114u, 1182138570u, 1174798539u, 1175847115u, 1175847120u, 1175847121u, 1182138598u, 1076078320u, 1076078320u,
				1076078320u, 1076078328u, 1076078328u, 1076078328u, 1076078304u, 1076078304u, 1076078304u, 1076078584u, 1076078584u, 1076078584u,
				1076078296u, 1076078296u, 1076078296u, 0u, 1073938886u, 1076036038u, 1077084614u, 1076036093u, 2952921112u, 3087138840u,
				1074004220u, 1074004220u, 1075052796u, 1075052796u, 1076101372u, 1076101372u, 1077149948u, 1077149948u, 1141112912u, 1157890128u,
				1143210064u, 1159987280u, 1144258640u, 1161035856u, 1141112913u, 1157890129u, 1143210065u, 1159987281u, 1144258641u, 1161035857u,
				1144258652u, 1143210098u, 1159987314u, 1141113008u, 1157890224u, 1142161584u, 1158938800u, 1143210160u, 1159987376u, 1144258736u,
				1161035952u, 1142161585u, 1158938801u, 1143210161u, 1159987377u, 1146355892u, 1163133108u, 1146355893u, 1163133109u, 1154744544u,
				1146355936u, 1154744545u, 1146355937u, 1154744546u, 1146355938u, 1154744547u, 1146355939u, 1154744548u, 1146355940u, 1154744549u,
				1146355941u, 1154744550u, 1146355942u, 1154744551u, 1146355943u, 1154744552u, 1146355944u, 1154744553u, 1146355945u, 1154744554u,
				1146355946u, 1154744555u, 1146355947u, 1154744556u, 1146355948u, 1154744557u, 1146355949u, 1154744558u, 1146355950u, 1154744559u,
				1146355951u, 1141112940u, 1142161516u, 1073938887u, 1161035979u, 1161035980u, 1161035981u, 1141113042u, 1157890258u, 1142161618u,
				1158938834u, 1143210194u, 1159987410u, 1141113043u, 1157890259u, 1142161619u, 1158938835u, 1143210195u, 1159987411u, 1141113050u,
				1142161626u, 1143210202u, 1159987418u, 1144258778u, 1161035994u, 1142292702u
			};
		}

		private static uint[] GetEncFlags3()
		{
			return new uint[4936]
			{
				196608u, 196608u, 196608u, 196608u, 196608u, 2031616u, 2031624u, 2031632u, 1966104u, 196608u,
				196616u, 196624u, 131096u, 196608u, 196616u, 196624u, 131096u, 65544u, 65552u, 65544u,
				65552u, 2031616u, 2031624u, 2031632u, 1966104u, 196608u, 196616u, 196624u, 131096u, 196608u,
				196616u, 196624u, 131096u, 65544u, 65552u, 65544u, 2031616u, 2031624u, 2031632u, 1966104u,
				196608u, 196616u, 196624u, 131096u, 196608u, 196616u, 196624u, 131096u, 65544u, 65552u,
				65544u, 65552u, 2031616u, 2031624u, 2031632u, 1966104u, 196608u, 196616u, 196624u, 131096u,
				196608u, 196616u, 196624u, 131096u, 65544u, 65552u, 65544u, 65552u, 2031616u, 2031624u,
				2031632u, 1966104u, 196608u, 196616u, 196624u, 131096u, 196608u, 196616u, 196624u, 131096u,
				65536u, 2031616u, 2031624u, 2031632u, 1966104u, 196608u, 196616u, 196624u, 131096u, 196608u,
				196616u, 196624u, 131096u, 65536u, 2031616u, 2031624u, 2031632u, 1966104u, 196608u, 196616u,
				196624u, 131096u, 196608u, 196616u, 196624u, 131096u, 65536u, 196608u, 196616u, 196624u,
				131096u, 196608u, 196616u, 196624u, 131096u, 196608u, 196616u, 196624u, 131096u, 65536u,
				65544u, 65552u, 65544u, 65552u, 196616u, 65552u, 135192u, 196616u, 65552u, 135192u,
				65544u, 65552u, 65544u, 65552u, 65544u, 65552u, 65544u, 65552u, 131080u, 131088u,
				131096u, 196616u, 65552u, 135192u, 196616u, 196624u, 131096u, 196616u, 65552u, 135192u,
				196616u, 196624u, 131096u, 2293760u, 2293768u, 2293776u, 2293760u, 2293768u, 2293776u, 25362440u,
				25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u,
				25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u,
				25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u,
				25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u,
				25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 2031616u, 2031616u, 2031616u,
				2031616u, 2031616u, 2031616u, 2031616u, 196608u, 2031624u, 2031632u, 1966104u, 2031624u, 2031632u,
				1966104u, 2031624u, 2031632u, 1966104u, 2031624u, 2031632u, 1966104u, 2031624u, 2031632u, 1966104u,
				2031624u, 2031632u, 1966104u, 2031624u, 2031632u, 1966104u, 196616u, 196624u, 131096u, 1900544u,
				1900544u, 1900544u, 1900544u, 1900544u, 1900544u, 1900544u, 65536u, 2031624u, 2031632u, 1966104u,
				2031624u, 2031632u, 1966104u, 2031624u, 2031632u, 1966104u, 2031624u, 2031632u, 1966104u, 2031624u,
				2031632u, 1966104u, 2031624u, 2031632u, 1966104u, 2031624u, 2031632u, 1966104u, 196616u, 196624u,
				131096u, 196608u, 196616u, 196624u, 131096u, 2031616u, 2031624u, 2031632u, 1966104u, 1245184u,
				1245192u, 1245200u, 1179672u, 196608u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u,
				196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 65552u, 135192u, 196616u,
				196624u, 131096u, 196616u, 196624u, 131096u, 196608u, 196616u, 196624u, 131096u, 196616u,
				196624u, 131096u, 65544u, 65552u, 196608u, 196616u, 65552u, 135192u, 196616u, 65552u,
				135192u, 196608u, 196608u, 196608u, 196616u, 196624u, 131096u, 196608u, 196616u, 196624u,
				131096u, 2293760u, 2293768u, 2293776u, 2228248u, 6488064u, 6488072u, 6488080u, 6422552u, 196608u,
				196616u, 196624u, 131096u, 2293760u, 2293768u, 2293776u, 2228248u, 2293760u, 2293768u, 2293776u,
				2228248u, 6488064u, 6488072u, 6488080u, 6422552u, 196608u, 196616u, 196624u, 131096u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196616u, 196624u, 131096u,
				196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u,
				196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u,
				131096u, 8585224u, 8454160u, 8540184u, 8585224u, 8454160u, 8540184u, 65544u, 65552u, 65544u,
				65552u, 1245184u, 196608u, 1245192u, 1245200u, 1179672u, 196616u, 196624u, 196616u, 65552u,
				135192u, 196616u, 65552u, 135192u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u,
				196608u, 196608u, 65536u, 196616u, 196624u, 131096u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u,
				196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u,
				196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196616u, 196624u, 131096u, 196616u,
				196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u,
				131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u,
				65536u, 65536u, 65536u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196616u, 196624u, 196608u, 196616u, 229384u, 196624u, 229392u,
				196608u, 229376u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 229376u, 196608u, 229376u,
				196608u, 229376u, 196608u, 229376u, 196608u, 229376u, 65536u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196616u,
				196624u, 196616u, 229384u, 196624u, 229392u, 196608u, 229376u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 229376u, 98304u, 98304u, 196608u, 196608u, 65576u, 65584u, 196680u,
				65616u, 151640u, 131176u, 151672u, 65576u, 65584u, 196680u, 65616u, 151640u, 131176u,
				151672u, 65576u, 65584u, 196680u, 65616u, 151640u, 131176u, 151672u, 65576u, 65584u,
				196680u, 65616u, 151640u, 131176u, 151672u, 196608u, 196616u, 196624u, 196608u, 196616u,
				196624u, 8585224u, 8454160u, 8540184u, 8585224u, 8454160u, 8540184u, 65544u, 65552u, 196616u,
				65552u, 151576u, 196608u, 196616u, 196624u, 196608u, 196616u, 196624u, 196608u, 196608u,
				196608u, 196608u, 196608u, 2031616u, 2031616u, 196608u, 196608u, 196608u, 196608u, 196616u,
				196624u, 131096u, 196616u, 196624u, 131096u, 2031624u, 2031632u, 1966104u, 2031624u, 2031632u,
				1966104u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u,
				196616u, 196624u, 131096u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 2031616u,
				2031616u, 2031624u, 2031632u, 1966104u, 2031624u, 2031632u, 1966104u, 42139656u, 42008592u, 42094616u,
				196616u, 196624u, 131096u, 42139656u, 42008592u, 42094616u, 196616u, 196624u, 131096u, 196616u,
				65552u, 135192u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u,
				131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u,
				65544u, 65552u, 65544u, 65552u, 131072u, 65544u, 65552u, 131072u, 65544u, 65552u,
				131072u, 65544u, 65552u, 131072u, 196616u, 196624u, 131096u, 196608u, 196616u, 196624u,
				131096u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 65568u, 196672u,
				131168u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 65568u, 196672u, 131168u, 196608u, 65568u, 196672u, 131168u, 65568u, 196672u,
				131168u, 196608u, 196608u, 196608u, 65568u, 196672u, 131168u, 196608u, 196608u, 196608u,
				196608u, 131072u, 196608u, 65568u, 196672u, 131168u, 196608u, 196608u, 65568u, 196672u,
				131168u, 196608u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 65536u, 65536u,
				196608u, 196608u, 65536u, 196608u, 131096u, 196608u, 196608u, 196608u, 65536u, 196608u,
				196616u, 196624u, 131096u, 196608u, 196608u, 196608u, 196608u, 65536u, 65544u, 65552u,
				65536u, 65544u, 65552u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u,
				196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196609u, 196609u, 1610809346u, 1610809602u,
				196608u, 196609u, 196609u, 1610809346u, 1610809730u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u,
				1610810114u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196609u, 196609u,
				1610809346u, 537067778u, 196608u, 196609u, 196609u, 1610809346u, 537067906u, 196608u, 196608u, 196609u,
				196609u, 196610u, 196994u, 196608u, 196609u, 196994u, 196608u, 196609u, 196609u, 1610809858u,
				1610809986u, 1610810114u, 196608u, 196609u, 196609u, 1610809730u, 1610809986u, 1610810114u, 196608u, 196609u,
				196994u, 196608u, 196609u, 196994u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u,
				196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196609u, 196609u, 1677919234u,
				1677919362u, 1677919490u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196609u,
				196610u, 196608u, 196609u, 196994u, 196608u, 196609u, 196994u, 196608u, 196609u, 196609u,
				1610809858u, 1610809986u, 1610810114u, 196608u, 196609u, 196994u, 196608u, 196609u, 196994u, 196616u,
				196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u,
				131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u,
				196616u, 196624u, 131096u, 196608u, 196608u, 196608u, 196608u, 196608u, 65536u, 131072u,
				65536u, 131072u, 65536u, 131072u, 196608u, 65536u, 131072u, 65536u, 131072u, 65536u,
				131072u, 196608u, 196608u, 131096u, 196608u, 196608u, 196616u, 196624u, 131096u, 65536u,
				131072u, 65536u, 131072u, 65536u, 131072u, 65536u, 131072u, 65536u, 65536u, 196608u,
				196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u,
				1610810114u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196609u, 196609u,
				1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196608u, 131096u, 196609u, 131073u, 134414594u,
				134349186u, 196608u, 131096u, 196609u, 131073u, 134414594u, 134349186u, 196608u, 196609u, 196609u,
				197122u, 197250u, 197378u, 196608u, 196609u, 196609u, 197122u, 197250u, 197378u, 196608u,
				196608u, 196608u, 196608u, 196608u, 131096u, 196609u, 131073u, 268632322u, 268566786u, 196608u,
				131096u, 196609u, 131073u, 268632450u, 268566914u, 196608u, 196608u, 196608u, 131096u, 196609u,
				131073u, 134414594u, 134349058u, 196608u, 131096u, 196609u, 131073u, 134414722u, 134349186u, 196608u,
				196609u, 268632322u, 196608u, 196609u, 268632450u, 196608u, 196608u, 196609u, 196609u, 268632322u,
				268632450u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 131096u, 196608u, 196616u,
				196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u,
				131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u,
				196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u,
				196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u,
				131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196608u, 131096u,
				196609u, 131073u, 196609u, 131073u, 196608u, 131096u, 196609u, 131073u, 196609u, 131073u,
				196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 196608u, 196609u, 196609u, 1677919618u,
				1677919746u, 1812137602u, 196608u, 196609u, 1745027330u, 196608u, 196609u, 1745027458u, 196608u, 196609u,
				196609u, 196608u, 196609u, 196608u, 196609u, 196609u, 196608u, 196609u, 196608u, 196609u,
				196609u, 1677919234u, 1677919362u, 1677919490u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u,
				196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 196608u, 196609u, 196609u, 1677919618u,
				1677919746u, 1677919874u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 196608u, 196609u,
				196609u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u,
				196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196609u, 196609u, 1677919234u,
				1677919362u, 1812137218u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1812137602u, 196608u, 196609u,
				1745027330u, 196608u, 196609u, 1745027458u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u,
				196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1812137602u, 196608u, 196609u, 1745027330u, 196608u,
				196609u, 1745027458u, 196608u, 196609u, 196609u, 1677919106u, 1677919234u, 1946354818u, 196608u, 196609u,
				196609u, 1677919618u, 1677919746u, 1812137602u, 196608u, 196609u, 1879245058u, 196608u, 196609u, 1745027458u,
				196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 196608u,
				196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u,
				1946354946u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 196608u, 196609u, 196609u,
				1677919618u, 1677919746u, 1812137602u, 196608u, 196609u, 1745027330u, 196608u, 196609u, 1745027458u, 196608u,
				196609u, 196609u, 1677919234u, 1677919362u, 1946354946u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u,
				1946355330u, 196608u, 196609u, 1879245058u, 196608u, 196609u, 1879245186u, 196608u, 196609u, 196609u,
				1677919234u, 1677919362u, 1812137218u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1812137602u, 196608u,
				196609u, 1745027330u, 196608u, 196609u, 1745027458u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u,
				1946354946u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1946355330u, 196608u, 196609u, 1879245058u,
				196608u, 196609u, 1879245186u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u,
				196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u,
				196609u, 1677919234u, 1677919362u, 1677919490u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u,
				1610810114u, 196608u, 196608u, 196609u, 196609u, 537068034u, 537068162u, 537068290u, 196608u, 196608u,
				196609u, 196609u, 537068034u, 537068162u, 537068290u, 196608u, 196608u, 196609u, 196609u, 604177410u,
				604177538u, 604177666u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u,
				196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u,
				1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u,
				196608u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 196608u, 196609u, 196609u,
				1677919618u, 1677919746u, 1677919874u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 196608u,
				131096u, 196608u, 131096u, 196609u, 131073u, 196866u, 131458u, 196608u, 196608u, 196609u,
				196609u, 1610809858u, 1610809986u, 1610810114u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196609u, 196609u,
				1610809858u, 1610809986u, 1610810114u, 1610809858u, 1610809986u, 1610810114u, 1610809858u, 1610809986u, 1610810114u, 1610809858u,
				1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 196608u,
				196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u,
				1610810114u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u,
				196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1610809858u,
				1610809986u, 1610810114u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 1677919234u, 1677919362u,
				1677919490u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u,
				1677919490u, 196608u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u,
				1677919874u, 196608u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 196608u, 196608u,
				196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196609u, 196609u, 197122u, 197250u,
				197378u, 196608u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196609u,
				196609u, 197122u, 197250u, 197378u, 196608u, 196608u, 196609u, 196609u, 537068034u, 537068162u,
				537068290u, 196608u, 196608u, 196609u, 196609u, 537068034u, 537068162u, 537068290u, 196608u, 196608u,
				196609u, 196609u, 604177410u, 604177538u, 604177666u, 196608u, 196609u, 196609u, 65536u, 131072u,
				1677919234u, 1677919362u, 1946354946u, 1677919618u, 1677919746u, 1946355330u, 196608u, 1677919106u, 1677919234u, 1946354818u,
				1677919618u, 1677919746u, 1946355330u, 268632322u, 268566786u, 196608u, 268632450u, 268566914u, 65536u, 131072u,
				1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 196608u, 1677919106u, 1677919234u, 1812137090u,
				1677919618u, 1677919746u, 1812137602u, 134414594u, 134349058u, 196608u, 134414722u, 134349186u, 1677919106u, 1677919234u,
				1946354818u, 1677919618u, 1677919746u, 1946355330u, 1677919106u, 1677919234u, 1812137090u, 1677919618u, 1677919746u, 1812137602u,
				1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 1677919106u, 1677919234u, 1812137090u, 1677919618u,
				1677919746u, 1812137602u, 134414594u, 134349186u, 134414594u, 134349186u, 196608u, 196609u, 196609u, 196608u,
				196609u, 196609u, 196608u, 196609u, 196609u, 196608u, 196609u, 196609u, 196608u, 131096u,
				196608u, 131096u, 196609u, 131073u, 196866u, 131458u, 196608u, 196609u, 196994u, 196608u,
				196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 1610809858u, 1610809986u, 1610810114u, 196608u,
				196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 1610809858u, 1610809986u, 1610810114u, 1610809858u, 1610809986u,
				1610810114u, 1610809858u, 1610809986u, 1610810114u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u,
				25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u,
				25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u,
				25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u,
				25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u, 25231376u, 25317400u, 25362440u,
				25231376u, 25317400u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 131073u,
				196609u, 196609u, 196609u, 131073u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196616u, 65552u, 135192u, 196616u, 65552u, 135192u, 196608u, 196616u,
				196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 65568u, 196672u,
				131168u, 65568u, 196672u, 131168u, 65568u, 196672u, 131168u, 65544u, 65552u, 2162720u,
				2293824u, 2228320u, 65568u, 196672u, 131168u, 65568u, 196672u, 131168u, 65568u, 196672u,
				131168u, 65568u, 196672u, 131168u, 65568u, 196672u, 131168u, 65544u, 65552u, 65536u,
				65544u, 65552u, 196616u, 65552u, 135192u, 196616u, 65552u, 135192u, 196608u, 2031624u,
				2031632u, 1966104u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196608u, 131096u,
				131072u, 131096u, 196608u, 131096u, 131072u, 131096u, 196608u, 131072u, 131096u, 196609u,
				196608u, 131072u, 131096u, 196609u, 196608u, 131096u, 196608u, 131096u, 196608u, 131096u,
				196608u, 131096u, 196608u, 131096u, 196608u, 196608u, 131096u, 196608u, 65568u, 196672u,
				131168u, 196608u, 131096u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196616u, 196624u, 131096u, 2031616u, 2031624u, 2031632u, 1966104u, 196616u, 196624u, 131096u,
				2031624u, 2031632u, 1966104u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u,
				196624u, 131096u, 196616u, 196624u, 131096u, 65544u, 65552u, 196616u, 196624u, 131096u,
				196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 2031624u, 2031632u, 1966104u, 2031624u,
				2031632u, 1966104u, 2031624u, 2031632u, 1966104u, 2031624u, 2031632u, 1966104u, 196616u, 196624u,
				131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u, 131096u,
				196616u, 196624u, 131096u, 196616u, 196624u, 131096u, 2031616u, 2031624u, 2031632u, 1966104u,
				196608u, 196609u, 196609u, 604177410u, 604177538u, 872613122u, 196608u, 196609u, 196609u, 604177794u,
				604177922u, 872613506u, 196608u, 196609u, 805503234u, 196608u, 196609u, 805503362u, 196608u, 131096u,
				196608u, 131096u, 196608u, 131096u, 196609u, 131073u, 196738u, 131202u, 196608u, 131096u,
				196608u, 131096u, 196609u, 131073u, 196610u, 131074u, 196608u, 196609u, 196609u, 1677919234u,
				1677919362u, 1677919490u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 2031616u, 393240u,
				196608u, 131096u, 196608u, 131096u, 196608u, 131096u, 196608u, 196608u, 196608u, 196616u,
				196624u, 131096u, 196608u, 196616u, 196624u, 131096u, 65536u, 131072u, 196616u, 196624u,
				131096u, 196608u, 196609u, 196609u, 196608u, 196609u, 196609u, 196608u, 196608u, 196609u,
				196609u, 1610809858u, 1610809858u, 1610809858u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809858u,
				1610809858u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809858u, 1610809858u, 196608u, 196608u,
				196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196608u, 196609u, 196609u, 1610809858u,
				1610809986u, 1610810114u, 196608u, 196609u, 196994u, 196608u, 196608u, 196608u, 131096u, 196608u,
				131096u, 196609u, 131073u, 196609u, 131073u, 196608u, 196608u, 196609u, 196609u, 1610809858u,
				1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u,
				196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u,
				1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196608u, 196609u, 196609u,
				1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u,
				196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u,
				196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196608u, 196609u,
				196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809858u,
				1610809858u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809858u, 1610809858u, 1610809858u, 1610809858u,
				1610809858u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u,
				196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1610809858u,
				1610809986u, 1610810114u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1946355330u, 196608u, 196609u,
				196609u, 1677919106u, 1677919234u, 1812137090u, 1677919618u, 1677919746u, 1812137602u, 196608u, 196609u, 196609u,
				1677919618u, 1677919746u, 1812137602u, 196608u, 196608u, 196609u, 196609u, 197122u, 197250u, 197378u,
				196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u,
				196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u,
				1610810114u, 196608u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u,
				1677919874u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u,
				196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1610809858u,
				1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u,
				1677919746u, 1677919874u, 196608u, 196609u, 196609u, 196608u, 196608u, 196609u, 196609u, 1610809858u,
				1610809858u, 1610809858u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809858u, 1610809858u, 196608u,
				196608u, 196609u, 196609u, 1610809858u, 1610809858u, 1610809858u, 196608u, 196608u, 196609u, 196609u,
				1677919618u, 1677919746u, 1677919874u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u,
				196608u, 196608u, 196609u, 196609u, 197122u, 197250u, 197378u, 196608u, 196608u, 196609u,
				196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u,
				196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u,
				1677919490u, 196608u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196608u,
				196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1610809858u,
				1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 196616u,
				196624u, 131096u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u,
				196608u, 196609u, 196609u, 196608u, 196608u, 196609u, 196609u, 196608u, 196608u, 196609u,
				196609u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196608u,
				196609u, 196609u, 196608u, 196608u, 196609u, 196609u, 196608u, 196608u, 196609u, 196609u,
				196608u, 196608u, 196609u, 196609u, 196608u, 196608u, 196609u, 196609u, 196608u, 196608u,
				196609u, 196609u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196609u,
				196609u, 1677919234u, 1677919362u, 1677919490u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 196609u,
				196609u, 196609u, 196609u, 196608u, 1610809858u, 1610809986u, 1610810114u, 1610809730u, 1610809858u, 1610809986u,
				1610809858u, 1610809986u, 1610810114u, 1610809602u, 1610809730u, 1610809858u, 1610809858u, 1610809986u, 1610810114u, 1610809474u,
				1610809602u, 1610809730u, 196609u, 196609u, 1610809730u, 1610809858u, 1879245442u, 1610809730u, 1610809858u, 1610809986u,
				196608u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 1610809602u, 1610809730u, 1610809858u,
				196608u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 1610809730u, 1610809858u, 1610809986u,
				196609u, 1677919362u, 1677919490u, 1677919746u, 1677919874u, 196608u, 196609u, 196609u, 196609u, 196609u,
				1610809602u, 1610809602u, 1610809602u, 196609u, 1610809730u, 1610809730u, 1610809730u, 1610809730u, 196609u, 1610809858u,
				1610809858u, 1610809858u, 1610809858u, 1610809986u, 1610809986u, 196608u, 196608u, 196609u, 196609u, 1610809858u,
				1610809986u, 1610810114u, 196608u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u,
				196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 196608u,
				196609u, 196609u, 1610809730u, 1610809858u, 1610809986u, 1610809730u, 1610809858u, 1610809986u, 196608u, 196609u,
				196609u, 1610809602u, 1610809730u, 1610809858u, 1610809602u, 1610809730u, 1610809858u, 196608u, 196609u, 196609u,
				1610809474u, 1610809602u, 1610809730u, 1610809474u, 1610809602u, 1610809730u, 196608u, 196609u, 196609u, 1610809730u,
				1610809858u, 1610809986u, 1610809730u, 1610809858u, 1610809986u, 196608u, 196609u, 196609u, 1610809602u, 1610809730u,
				1610809858u, 1610809602u, 1610809730u, 1610809858u, 196608u, 196609u, 196609u, 1610809730u, 1610809858u, 1610809986u,
				1610809730u, 1610809858u, 1610809986u, 537068034u, 537068162u, 537068290u, 537068034u, 537068162u, 537068290u, 537068034u,
				537068162u, 537068290u, 537068034u, 537068162u, 537068290u, 604177410u, 604177538u, 604177666u, 604177794u, 604177922u,
				604178050u, 604177410u, 604177538u, 604177666u, 604177794u, 604177922u, 604178050u, 196608u, 196609u, 196609u,
				1677919618u, 1677919746u, 1677919874u, 196610u, 196610u, 196610u, 196610u, 196610u, 196610u, 196608u,
				196609u, 196609u, 604177794u, 604177922u, 604178050u, 196610u, 196610u, 196610u, 196610u, 196610u,
				196610u, 196608u, 196609u, 196609u, 197122u, 197250u, 197378u, 196610u, 196610u, 196610u,
				196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 196609u, 196609u, 1677919234u, 1677919362u,
				1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u, 1745027330u, 1745027458u, 196609u, 196609u,
				196609u, 196609u, 196608u, 196609u, 196609u, 1610809730u, 1610809858u, 1610809986u, 1610809730u, 1610809858u,
				1610809986u, 196608u, 196609u, 196609u, 1610809602u, 1610809730u, 1610809858u, 1610809602u, 1610809730u, 1610809858u,
				196608u, 196609u, 196609u, 1610809474u, 1610809602u, 1610809730u, 1610809474u, 1610809602u, 1610809730u, 196608u,
				196609u, 196609u, 1610809730u, 1610809858u, 1610809986u, 1610809730u, 1610809858u, 1610809986u, 196608u, 196609u,
				196609u, 1610809602u, 1610809730u, 1610809858u, 1610809602u, 1610809730u, 1610809858u, 196608u, 196609u, 196609u,
				1610809730u, 1610809858u, 1610809986u, 1610809730u, 1610809858u, 1610809986u, 196609u, 1677919362u, 1677919490u, 1677919746u,
				1677919874u, 196608u, 196609u, 196609u, 604177794u, 604177922u, 604178050u, 196608u, 196609u, 196609u,
				1610809858u, 1610809986u, 1610810114u, 196610u, 196610u, 196610u, 196610u, 196610u, 196610u, 196608u,
				196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 196610u, 196610u,
				196610u, 196610u, 196610u, 196610u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u,
				196610u, 196610u, 196610u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u,
				1677919746u, 1677919874u, 196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196609u,
				196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196609u, 196609u,
				1610809858u, 1610809986u, 1610810114u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u,
				1677919746u, 1677919874u, 196608u, 196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u,
				1677919874u, 196608u, 196609u, 1677919234u, 1677919362u, 1946354946u, 1677919618u, 1677919746u, 1946355330u, 1879245058u,
				1879245186u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 196609u, 196609u, 196609u,
				196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 196609u, 196609u, 1677919234u,
				1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 196609u, 196609u, 196609u, 196609u, 1677919234u,
				1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u,
				1677919874u, 1610809602u, 1610809730u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 1610809602u,
				1610809730u, 1677919234u, 1677919362u, 1677919490u, 1677919234u, 1677919362u, 1677919490u, 1677919234u, 1677919362u, 1677919490u,
				1677919234u, 1677919362u, 1677919490u, 1610809858u, 1677919234u, 1677919362u, 1677919490u, 1610809858u, 1610809858u, 1610809986u,
				1610810114u, 1610809858u, 1610809986u, 1610810114u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u,
				196609u, 196609u, 1610809602u, 1610809602u, 1610809602u, 196609u, 196609u, 1610809730u, 1610809730u, 1610809730u,
				1610809730u, 1610809730u, 1610809730u, 196609u, 1610809858u, 1610809858u, 1610809858u, 1610809858u, 1610809986u, 1610809986u,
				1610809346u, 1610809346u, 1610809346u, 1610809474u, 1610809474u, 1610809474u, 1610809346u, 1610809346u, 1610809346u, 1610809474u,
				1610809474u, 1610809474u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 1677919234u, 1677919362u,
				1677919490u, 1677919618u, 1677919746u, 1677919874u, 1610809858u, 1610809986u, 1610810114u, 1610809858u, 1610809986u, 1610810114u,
				67306498u, 67306626u, 67306754u, 67306882u, 67307010u, 67307138u, 1610809858u, 1610809986u, 1610810114u, 1677919234u,
				1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 1610809858u, 1610809986u, 1610810114u, 1677919234u, 1677919362u,
				1677919490u, 1677919234u, 1677919362u, 1677919490u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u,
				1610809858u, 1610809986u, 1610810114u, 1610809858u, 1610809986u, 1610810114u, 1677919234u, 1677919362u, 1677919490u, 1677919618u,
				1677919746u, 1677919874u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 196609u, 196609u,
				1610809346u, 1610809346u, 1610809346u, 196609u, 196609u, 1610809474u, 1610809474u, 1610809474u, 1610809346u, 1610809346u,
				1610809346u, 1610809346u, 1610809346u, 1610809346u, 1610809346u, 1610809346u, 1610809346u, 1610743810u, 1610743810u, 1610743810u,
				1610809858u, 1610809986u, 1610810114u, 1610809858u, 1610809986u, 1610810114u, 1677919234u, 1677919362u, 1677919490u, 1677919618u,
				1677919746u, 1677919874u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 65536u, 131072u,
				65536u, 131072u, 65536u, 131072u, 1677919618u, 1677919746u, 1677919874u, 1610809602u, 1610809602u, 1610809602u,
				1610809730u, 1610809730u, 1610809730u, 1610809602u, 1610809602u, 1610809602u, 1610809730u, 1610809730u, 1610809730u, 1610809602u,
				1610809602u, 1610809602u, 1610809730u, 1610809730u, 1610809730u, 1610809602u, 1610809602u, 1610809602u, 1610809730u, 1610809730u,
				1610809730u, 196609u, 196609u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 1610809858u, 1610809986u,
				1610810114u, 196609u, 196609u, 196609u, 196609u, 537068034u, 537068162u, 537068290u, 196609u, 196609u,
				196609u, 196609u, 2684551426u, 2684551426u, 2684551426u, 2684551554u, 2684551554u, 2684551554u, 196609u, 196609u,
				196609u, 196609u, 2684551426u, 2684551426u, 2684551426u, 2684551554u, 2684551554u, 2684551554u, 196609u, 196609u,
				196609u, 196609u, 2684551426u, 2684551426u, 2684551426u, 2684551554u, 2684551554u, 2684551554u, 196609u, 196609u,
				196609u, 196609u, 2684551426u, 2684551426u, 2684551426u, 2684551554u, 2684551554u, 2684551554u, 196609u, 196609u,
				196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u,
				196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u,
				196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u,
				1745027330u, 1745027458u, 196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u,
				1677919746u, 1812137602u, 1610809858u, 196609u, 196609u, 1745027330u, 1745027458u, 1610809858u, 196609u, 196609u,
				196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u,
				1745027330u, 1745027458u, 196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u,
				1677919746u, 1812137602u, 196609u, 196609u, 1745027330u, 1745027458u, 2684551426u, 2684551426u, 2684551426u, 2684551554u,
				2684551554u, 2684551554u, 2684551426u, 2684551426u, 2684551426u, 2684551554u, 2684551554u, 2684551554u, 2684551426u, 2684551426u,
				2684551426u, 2684551554u, 2684551554u, 2684551554u, 2684551426u, 2684551426u, 2684551426u, 2684551554u, 2684551554u, 2684551554u,
				196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u,
				196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u,
				196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u,
				196609u, 196609u, 1745027330u, 1745027458u, 196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u,
				1812137218u, 1677919618u, 1677919746u, 1812137602u, 1610809858u, 196609u, 196609u, 1745027330u, 1745027458u, 1610809858u,
				196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u,
				196609u, 196609u, 1745027330u, 1745027458u, 196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u,
				1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u, 1745027330u, 1745027458u, 1677919618u, 1677919746u,
				1677919874u, 1677919618u, 1677919746u, 1677919874u, 196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u,
				1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u,
				1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u,
				1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u, 1745027330u, 1745027458u, 196609u, 196609u,
				196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u,
				1745027330u, 1745027458u, 196609u, 196609u, 196609u, 196609u, 1677919234u, 1677919362u, 1812137218u, 1677919618u,
				1677919746u, 1812137602u, 196609u, 196609u, 1745027330u, 1745027458u, 196609u, 196609u, 196609u, 196609u,
				1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 196609u, 196609u, 1745027330u, 1745027458u,
				1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 2684551426u, 2684551554u, 2684551426u, 2684551554u,
				2684551426u, 2684551554u, 2684551426u, 2684551554u, 2684551426u, 2684551554u, 2684551426u, 2684551554u, 2684551426u, 2684551554u,
				2684551426u, 2684551554u, 196608u, 1946354946u, 1946355330u, 196608u, 196608u, 1946354946u, 1946355330u, 196608u,
				1879245058u, 1879245186u, 196608u, 1946354946u, 1946355330u, 196608u, 1879245058u, 1879245186u, 196608u, 196609u,
				196609u, 1610809858u, 1610809986u, 1610810114u, 196608u, 196609u, 196608u, 196609u, 196609u, 197122u,
				197250u, 197378u, 196608u, 196609u, 196609u, 197122u, 197250u, 197378u, 196608u, 196609u,
				196609u, 197122u, 197250u, 197378u, 196608u, 196609u, 196609u, 197122u, 197250u, 197378u,
				196616u, 196624u, 131096u, 196608u, 131096u, 196616u, 196624u, 131096u, 196616u, 196624u,
				131096u, 196609u, 131073u, 196609u, 131073u, 196609u, 131073u, 196609u, 131073u, 196609u,
				131073u, 196608u, 131096u, 196609u, 131073u, 196609u, 131073u, 196608u, 131096u, 196608u,
				131096u, 196608u, 131096u, 196609u, 131073u, 196609u, 131073u, 196609u, 131073u, 196609u,
				131073u, 196609u, 131073u, 65568u, 196672u, 131168u, 65568u, 196672u, 131168u, 65568u,
				196672u, 131168u, 196608u, 131096u, 196609u, 1677919746u, 1677919874u, 196609u, 1677919746u, 1677919874u,
				196609u, 196609u, 1677919234u, 1677919362u, 1677919490u, 1677919618u, 1677919746u, 1677919874u, 196609u, 196609u,
				1677919234u, 1677919362u, 1677919490u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u, 196609u, 196608u,
				196609u, 196609u, 1677919234u, 1677919362u, 1946354946u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u,
				1946355330u, 196608u, 196609u, 1879245058u, 196608u, 196609u, 1879245186u, 196608u, 196609u, 196609u,
				196608u, 196609u, 196609u, 196608u, 196609u, 196609u, 196608u, 196608u, 196609u, 196609u,
				1610809858u, 1610809986u, 1610810114u, 196608u, 131096u, 196609u, 131073u, 196610u, 131074u, 196608u,
				131096u, 196609u, 131073u, 196738u, 131202u, 196608u, 131096u, 196609u, 131073u, 196866u,
				131458u, 196608u, 131096u, 196609u, 131073u, 196866u, 131330u, 196609u, 1610809858u, 1610809858u,
				1610809858u, 1610809858u, 196609u, 1610809858u, 1610809858u, 1610809858u, 1610809858u, 1610809986u, 1610809986u, 1610809986u,
				1610809986u, 196609u, 196609u, 1610809730u, 1610809858u, 1879245442u, 604177410u, 604177538u, 604177666u, 604177794u,
				604177922u, 604178050u, 604177410u, 604177538u, 604177666u, 604177794u, 604177922u, 604178050u, 196608u, 131096u,
				196609u, 131073u, 196610u, 131074u, 196608u, 196609u, 196866u, 196608u, 131096u, 196609u,
				131073u, 196866u, 131458u, 1677919362u, 1677919490u, 1677919746u, 1677919874u, 1677919234u, 1677919362u, 1677919490u,
				1677919618u, 1677919746u, 1677919874u, 1677919234u, 1677919362u, 1946354946u, 1677919618u, 1677919746u, 1946355330u, 1879245058u,
				1879245186u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				1610809858u, 1610809858u, 1610809858u, 1610809858u, 196609u, 1610809858u, 1610809858u, 1610809858u, 1610809858u, 1610809986u,
				1610809986u, 1610809986u, 1610809986u, 537068034u, 537068162u, 537068290u, 537068034u, 537068162u, 537068290u, 537068034u,
				537068162u, 537068290u, 537068034u, 537068162u, 537068290u, 196608u, 196609u, 196609u, 196608u, 196609u,
				196608u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 1677919362u, 1677919490u, 1677919746u, 1677919874u,
				196608u, 196609u, 196609u, 197122u, 197250u, 197378u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 1677919234u, 1677919362u, 1946354946u, 1677919618u, 1677919746u, 1946355330u, 1879245058u, 1879245186u, 1677919234u,
				1677919362u, 1946354946u, 1677919618u, 1677919746u, 1946355330u, 1879245058u, 1879245186u, 1677919234u, 1677919362u, 1946354946u,
				1677919618u, 1677919746u, 1946355330u, 1879245058u, 1879245186u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196608u, 131096u, 196609u, 131073u, 196608u, 131096u, 196609u, 131073u, 196608u,
				196609u, 196608u, 196609u, 604177410u, 604177538u, 604177666u, 604177794u, 604177922u, 604178050u, 537067778u,
				537067906u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 1610809858u, 1610809986u, 1610810114u, 1677919234u, 1677919362u,
				1677919490u, 1677919618u, 1677919746u, 1677919874u, 1610809858u, 1610809986u, 1610810114u, 1677919234u, 1677919362u, 1677919490u,
				1677919618u, 1677919746u, 1677919874u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196608u, 196608u, 196609u,
				196609u, 1677919618u, 1677919746u, 1677919874u, 196608u, 196609u, 196609u, 1677919618u, 1677919746u, 1677919874u,
				196608u, 196609u, 196609u, 131073u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u,
				196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u,
				196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u,
				196611u, 196611u, 196611u, 196611u, 196611u, 131075u, 196611u, 131075u, 196611u, 131075u,
				196611u, 131075u, 196611u, 131075u, 196611u, 131075u, 196611u, 131075u, 196611u, 131075u,
				196611u, 131075u, 196611u, 131075u, 196611u, 131075u, 196611u, 196611u, 196611u, 196611u,
				196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u,
				196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u,
				196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u,
				196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u, 196611u,
				196611u, 196611u, 131075u, 196611u, 131075u, 196611u, 131075u, 196612u, 196612u, 196612u,
				196612u, 65540u, 65540u, 196612u, 196612u, 196612u, 196612u, 196612u, 196612u, 196612u,
				196612u, 196612u, 196612u, 196612u, 196612u, 196612u, 196612u, 196612u, 196612u, 196612u,
				196612u, 196612u, 196612u, 131072u, 131072u, 131072u, 65568u, 196672u, 131168u, 196608u,
				196608u, 196608u, 65568u, 196672u, 131168u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 131096u, 131073u, 131073u, 131073u, 139265u, 131073u, 131073u,
				131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 65536u, 65536u, 65536u, 65536u,
				65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u,
				65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u,
				65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u,
				65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 65536u, 196608u,
				131072u, 131072u, 131072u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u, 196608u,
				196608u, 196608u, 196608u, 196608u, 196609u, 196609u, 196609u, 196608u, 131072u, 131072u,
				131072u, 131072u, 131072u, 196608u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 65568u, 196672u, 131168u, 65568u, 196672u, 131168u, 131080u, 131088u,
				131096u, 131072u, 131072u, 1677920258u, 1677920386u, 1812138242u, 1745027202u, 604178434u, 604178562u, 872614146u,
				805503106u, 268632194u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 1677920130u, 1677920258u,
				1812138114u, 1677920002u, 1677920130u, 1946355714u, 1677920130u, 1677920258u, 1946355842u, 1677920002u, 1677920130u, 1812137986u,
				1677920130u, 1677920258u, 1812138114u, 1677920002u, 1677920130u, 1812137986u, 1677920258u, 1677920386u, 1812138242u, 1677920258u,
				1677920386u, 1812138242u, 1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 1745027458u, 1879244930u,
				134414466u, 134348930u, 1879244930u, 134414466u, 134348930u, 134414594u, 134349186u, 1745027330u, 1677920130u, 1677920258u,
				1946355842u, 1677920002u, 1677920130u, 1946355714u, 1677920130u, 1677920258u, 1946355842u, 1677920002u, 1677920130u, 1946355714u,
				1677920258u, 1677920386u, 1946355970u, 1677920258u, 1677920386u, 1946355970u, 268632194u, 268566658u, 268632194u, 268566658u,
				1677919234u, 1677919362u, 1812137218u, 1677919618u, 1677919746u, 1812137602u, 134414594u, 134349186u, 1677920258u, 1677920386u,
				1812138242u, 1677920258u, 1677920386u, 1812138242u, 1677920258u, 1677920386u, 1812138242u, 1745027202u, 1677919234u, 1677919362u,
				1812137218u, 1677919234u, 1677919362u, 1812137218u, 1745027330u, 1745027330u, 1677919234u, 1677919362u, 1812137218u, 1677919234u,
				1677919362u, 1812137218u, 1745027330u, 1745027330u, 1677920258u, 1677920386u, 1812138242u, 1677920258u, 1677920386u, 1812138242u,
				1677920258u, 1677920386u, 1812138242u, 1677920258u, 1677920386u, 1812138242u, 1677920258u, 1677920386u, 1812138242u, 1677920258u,
				1677920386u, 1812138242u, 1677920258u, 1677920386u, 1812138242u, 1677920258u, 1677920386u, 1812138242u, 1677920258u, 1677920386u,
				1812138242u, 1677920258u, 1677920386u, 1812138242u, 1677920258u, 1677920386u, 1812138242u, 1677920258u, 1677920386u, 1812138242u,
				1745027202u, 1745027202u, 1745027202u, 1745027202u, 1745027202u, 1745027202u, 1677920258u, 1677920386u, 1812138242u, 1677920258u,
				1677920386u, 1812138242u, 1677920258u, 1677920386u, 1812138242u, 1677920258u, 1677920386u, 1812138242u, 1677920258u, 1677920386u,
				1812138242u, 1677920258u, 1677920386u, 1812138242u, 1745027202u, 1745027202u, 1745027202u, 1745027202u, 1745027202u, 1745027202u,
				604178434u, 604178562u, 604178690u, 537067650u, 1677920258u, 1677920386u, 1946355970u, 1879244930u, 1677920258u, 1677920386u,
				1946355970u, 1879244930u, 1677920258u, 1677920386u, 1946355970u, 1879244930u, 1677920258u, 1677920386u, 1946355970u, 1879244930u,
				1610809474u, 537067650u, 1610809346u, 1610809346u, 196738u, 131202u, 196738u, 131202u, 1677920258u, 1677920386u,
				1812138242u, 1745027202u, 1677920258u, 1677920386u, 1677920514u, 1610809474u, 1677920258u, 1677920386u, 1946355970u, 1879244930u,
				1677920258u, 1677920386u, 1946355970u, 1879244930u, 1677920258u, 1677920386u, 1677920514u, 1610809474u, 1677920258u, 1677920386u,
				1812138242u, 1745027202u, 1677920258u, 1677920386u, 1812138242u, 1745027202u, 1677920258u, 1677920386u, 1812138242u, 1745027202u,
				268632194u, 196608u, 196608u, 151553u, 151553u, 131073u, 131073u, 131073u, 131073u, 131073u,
				131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u,
				131073u, 131073u, 151553u, 151553u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u,
				131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u,
				131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u,
				131073u, 131077u, 131077u, 131077u, 131077u, 131077u, 131077u, 131077u, 131077u, 537001989u,
				537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 939655173u, 939655173u, 939655173u,
				939655173u, 805437445u, 939655173u, 939655173u, 939655173u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u,
				537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 131077u, 131077u, 805437445u, 805437445u,
				537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u,
				537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u,
				537001989u, 537001989u, 805437445u, 805437445u, 537001989u, 537001989u, 537001989u, 939655173u, 939655173u, 939655173u,
				939655173u, 939655173u, 939655173u, 805437445u, 805437445u, 805437445u, 805437445u, 805437445u, 939655173u, 805437445u,
				805437445u, 939655173u, 939655173u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u,
				537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u,
				537001989u, 939655173u, 939655173u, 537001989u, 537001989u, 939655173u, 939655173u, 939655173u, 939655173u, 537001989u,
				939655173u, 537001989u, 537001989u, 2684485637u, 2684485637u, 2684485637u, 2684485637u, 939655173u, 939655173u, 939655173u,
				939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 2684485637u, 2684485637u, 2684485637u,
				2684485637u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u,
				3087138821u, 3087138821u, 537001989u, 537001989u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u,
				939655173u, 939655173u, 3087138821u, 2684485637u, 2684485637u, 2684485637u, 2684485637u, 2684485637u, 2684485637u, 2684485637u,
				2684485637u, 805437445u, 805437445u, 805437445u, 805437445u, 3087138821u, 2684485637u, 939655173u, 939655173u, 939655173u,
				537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 939655173u, 939655173u,
				939655173u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 537001989u, 939655173u,
				939655173u, 939655173u, 537001989u, 537001989u, 537001989u, 537001989u, 805437445u, 805437445u, 939655173u, 939655173u,
				939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 939655173u, 65568u, 196672u,
				131168u, 65568u, 196672u, 131168u, 65568u, 196672u, 131168u, 65568u, 196672u, 131168u,
				65568u, 196672u, 131168u, 196608u, 196608u, 131072u, 131072u, 131072u, 196608u, 196608u,
				196608u, 131096u, 196608u, 131096u, 196608u, 131096u, 196608u, 131096u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				131073u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 131073u,
				131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u,
				131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u,
				131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u, 131073u,
				131073u, 131073u, 131073u, 131072u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u, 196609u,
				196609u, 196609u, 196609u, 196609u, 196609u, 196609u
			};
		}
	}
	internal delegate bool TryConvertToDisp8N(Encoder encoder, OpCodeHandler handler, in Instruction instruction, int displ, out sbyte compressedValue);
	internal abstract class OpCodeHandler
	{
		internal readonly uint OpCode;

		internal readonly bool Is2ByteOpCode;

		internal readonly int GroupIndex;

		internal readonly int RmGroupIndex;

		internal readonly bool IsSpecialInstr;

		internal readonly EncFlags3 EncFlags3;

		internal readonly CodeSize OpSize;

		internal readonly CodeSize AddrSize;

		internal readonly TryConvertToDisp8N? TryConvertToDisp8N;

		internal readonly Op[] Operands;

		protected OpCodeHandler(EncFlags2 encFlags2, EncFlags3 encFlags3, bool isSpecialInstr, TryConvertToDisp8N? tryConvertToDisp8N, Op[] operands)
		{
			EncFlags3 = encFlags3;
			OpCode = GetOpCode(encFlags2);
			Is2ByteOpCode = (encFlags2 & EncFlags2.OpCodeIs2Bytes) != 0;
			GroupIndex = ((((uint)encFlags2 & 0x80000000u) == 0) ? (-1) : ((int)(((uint)encFlags2 >> 27) & 7)));
			RmGroupIndex = (((encFlags3 & EncFlags3.HasRmGroupIndex) == 0) ? (-1) : ((int)(((uint)encFlags2 >> 27) & 7)));
			IsSpecialInstr = isSpecialInstr;
			OpSize = (CodeSize)(((uint)encFlags3 >> 3) & 3);
			AddrSize = (CodeSize)(((uint)encFlags3 >> 5) & 3);
			TryConvertToDisp8N = tryConvertToDisp8N;
			Operands = operands;
		}

		protected static uint GetOpCode(EncFlags2 encFlags2)
		{
			return (ushort)encFlags2;
		}

		public abstract void Encode(Encoder encoder, in Instruction instruction);
	}
	internal sealed class InvalidHandler : OpCodeHandler
	{
		internal const string ERROR_MESSAGE = "Can't encode an invalid instruction";

		public InvalidHandler()
			: base(EncFlags2.None, EncFlags3.Bit16or32 | EncFlags3.Bit64, isSpecialInstr: false, null, Array2.Empty<Op>())
		{
		}

		public override void Encode(Encoder encoder, in Instruction instruction)
		{
			encoder.ErrorMessage = "Can't encode an invalid instruction";
		}
	}
	internal sealed class DeclareDataHandler : OpCodeHandler
	{
		private readonly int elemLength;

		private readonly int maxLength;

		public DeclareDataHandler(Code code)
			: base(EncFlags2.None, EncFlags3.Bit16or32 | EncFlags3.Bit64, isSpecialInstr: true, null, Array2.Empty<Op>())
		{
			elemLength = code switch
			{
				Code.DeclareByte => 1, 
				Code.DeclareWord => 2, 
				Code.DeclareDword => 4, 
				Code.DeclareQword => 8, 
				_ => throw new InvalidOperationException(), 
			};
			maxLength = 16 / elemLength;
		}

		public override void Encode(Encoder encoder, in Instruction instruction)
		{
			int declareDataCount = instruction.DeclareDataCount;
			if (declareDataCount < 1 || declareDataCount > maxLength)
			{
				encoder.ErrorMessage = $"Invalid db/dw/dd/dq data count. Count = {declareDataCount}, max count = {maxLength}";
			}
			else
			{
				int num = declareDataCount * elemLength;
				for (int i = 0; i < num; i++)
				{
					encoder.WriteByteInternal(instruction.GetDeclareByteValue(i));
				}
			}
		}
	}
	internal sealed class ZeroBytesHandler : OpCodeHandler
	{
		public ZeroBytesHandler(Code code)
			: base(EncFlags2.None, EncFlags3.Bit16or32 | EncFlags3.Bit64, isSpecialInstr: true, null, Array2.Empty<Op>())
		{
		}

		public override void Encode(Encoder encoder, in Instruction instruction)
		{
		}
	}
	internal sealed class LegacyHandler : OpCodeHandler
	{
		private readonly uint tableByte1;

		private readonly uint tableByte2;

		private readonly uint mandatoryPrefix;

		private static Op[] CreateOps(EncFlags1 encFlags1)
		{
			int num = (int)(encFlags1 & EncFlags1.Legacy_OpMask);
			int num2 = (int)(((uint)encFlags1 >> 7) & 0x7F);
			int num3 = (int)(((uint)encFlags1 >> 14) & 0x7F);
			int num4 = (int)(((uint)encFlags1 >> 21) & 0x7F);
			if (num4 != 0)
			{
				return new Op[4]
				{
					OpHandlerData.LegacyOps[num - 1],
					OpHandlerData.LegacyOps[num2 - 1],
					OpHandlerData.LegacyOps[num3 - 1],
					OpHandlerData.LegacyOps[num4 - 1]
				};
			}
			if (num3 != 0)
			{
				return new Op[3]
				{
					OpHandlerData.LegacyOps[num - 1],
					OpHandlerData.LegacyOps[num2 - 1],
					OpHandlerData.LegacyOps[num3 - 1]
				};
			}
			if (num2 != 0)
			{
				return new Op[2]
				{
					OpHandlerData.LegacyOps[num - 1],
					OpHandlerData.LegacyOps[num2 - 1]
				};
			}
			if (num != 0)
			{
				return new Op[1] { OpHandlerData.LegacyOps[num - 1] };
			}
			return Array2.Empty<Op>();
		}

		public LegacyHandler(EncFlags1 encFlags1, EncFlags2 encFlags2, EncFlags3 encFlags3)
			: base(encFlags2, encFlags3, isSpecialInstr: false, null, CreateOps(encFlags1))
		{
			switch ((LegacyOpCodeTable)(((uint)encFlags2 >> 17) & 7))
			{
			case LegacyOpCodeTable.MAP0:
				tableByte1 = 0u;
				tableByte2 = 0u;
				break;
			case LegacyOpCodeTable.MAP0F:
				tableByte1 = 15u;
				tableByte2 = 0u;
				break;
			case LegacyOpCodeTable.MAP0F38:
				tableByte1 = 15u;
				tableByte2 = 56u;
				break;
			case LegacyOpCodeTable.MAP0F3A:
				tableByte1 = 15u;
				tableByte2 = 58u;
				break;
			default:
				throw new InvalidOperationException();
			}
			mandatoryPrefix = (MandatoryPrefixByte)(((uint)encFlags2 >> 20) & 3) switch
			{
				MandatoryPrefixByte.None => 0u, 
				MandatoryPrefixByte.P66 => 102u, 
				MandatoryPrefixByte.PF3 => 243u, 
				MandatoryPrefixByte.PF2 => 242u, 
				_ => throw new InvalidOperationException(), 
			};
		}

		public override void Encode(Encoder encoder, in Instruction instruction)
		{
			uint num = mandatoryPrefix;
			encoder.WritePrefixes(in instruction, num != 243);
			if (num != 0)
			{
				encoder.WriteByteInternal(num);
			}
			num = (uint)encoder.EncoderFlags;
			num &= 0x4F;
			if (num != 0)
			{
				if ((encoder.EncoderFlags & EncoderFlags.HighLegacy8BitRegs) != EncoderFlags.None)
				{
					encoder.ErrorMessage = "Registers AH, CH, DH, BH can't be used if there's a REX prefix. Use AL, CL, DL, BL, SPL, BPL, SIL, DIL, R8L-R15L instead.";
				}
				num |= 0x40;
				encoder.WriteByteInternal(num);
			}
			if ((num = tableByte1) != 0)
			{
				encoder.WriteByteInternal(num);
				if ((num = tableByte2) != 0)
				{
					encoder.WriteByteInternal(num);
				}
			}
		}
	}
	internal sealed class VexHandler : OpCodeHandler
	{
		private readonly uint table;

		private readonly uint lastByte;

		private readonly uint mask_W_L;

		private readonly uint mask_L;

		private readonly uint W1;

		private static Op[] CreateOps(EncFlags1 encFlags1)
		{
			int num = (int)(encFlags1 & EncFlags1.VEX_OpMask);
			int num2 = (int)(((uint)encFlags1 >> 6) & 0x3F);
			int num3 = (int)(((uint)encFlags1 >> 12) & 0x3F);
			int num4 = (int)(((uint)encFlags1 >> 18) & 0x3F);
			int num5 = (int)(((uint)encFlags1 >> 24) & 0x3F);
			if (num5 != 0)
			{
				return new Op[5]
				{
					OpHandlerData.VexOps[num - 1],
					OpHandlerData.VexOps[num2 - 1],
					OpHandlerData.VexOps[num3 - 1],
					OpHandlerData.VexOps[num4 - 1],
					OpHandlerData.VexOps[num5 - 1]
				};
			}
			if (num4 != 0)
			{
				return new Op[4]
				{
					OpHandlerData.VexOps[num - 1],
					OpHandlerData.VexOps[num2 - 1],
					OpHandlerData.VexOps[num3 - 1],
					OpHandlerData.VexOps[num4 - 1]
				};
			}
			if (num3 != 0)
			{
				return new Op[3]
				{
					OpHandlerData.VexOps[num - 1],
					OpHandlerData.VexOps[num2 - 1],
					OpHandlerData.VexOps[num3 - 1]
				};
			}
			if (num2 != 0)
			{
				return new Op[2]
				{
					OpHandlerData.VexOps[num - 1],
					OpHandlerData.VexOps[num2 - 1]
				};
			}
			if (num != 0)
			{
				return new Op[1] { OpHandlerData.VexOps[num - 1] };
			}
			return Array2.Empty<Op>();
		}

		public VexHandler(EncFlags1 encFlags1, EncFlags2 encFlags2, EncFlags3 encFlags3)
			: base(encFlags2, encFlags3, isSpecialInstr: false, null, CreateOps(encFlags1))
		{
			table = ((uint)encFlags2 >> 17) & 7;
			WBit wBit = (WBit)(((uint)encFlags2 >> 22) & 3);
			W1 = ((wBit == WBit.W1) ? uint.MaxValue : 0u);
			LBit lBit = (LBit)(((uint)encFlags2 >> 24) & 7);
			if (lBit == LBit.L1 || lBit == LBit.L256)
			{
				lastByte = 4u;
			}
			if (W1 != 0)
			{
				lastByte |= 128u;
			}
			lastByte |= ((uint)encFlags2 >> 20) & 3;
			if (wBit == WBit.WIG)
			{
				mask_W_L |= 128u;
			}
			if (lBit == LBit.LIG)
			{
				mask_W_L |= 4u;
				mask_L |= 4u;
			}
		}

		public override void Encode(Encoder encoder, in Instruction instruction)
		{
			encoder.WritePrefixes(in instruction);
			uint encoderFlags = (uint)encoder.EncoderFlags;
			uint num = lastByte;
			num |= (~encoderFlags >> 24) & 0x78;
			if ((encoder.Internal_PreventVEX2 | W1 | (table - 1) | (encoderFlags & 0xB)) != 0)
			{
				encoder.WriteByteInternal(196u);
				uint num2 = table;
				num2 |= (~encoderFlags & 7) << 5;
				encoder.WriteByteInternal(num2);
				num |= mask_W_L & encoder.Internal_VEX_WIG_LIG;
				encoder.WriteByteInternal(num);
			}
			else
			{
				encoder.WriteByteInternal(197u);
				num |= (~encoderFlags & 4) << 5;
				num |= mask_L & encoder.Internal_VEX_LIG;
				encoder.WriteByteInternal(num);
			}
		}
	}
	internal sealed class XopHandler : OpCodeHandler
	{
		private readonly uint table;

		private readonly uint lastByte;

		private static Op[] CreateOps(EncFlags1 encFlags1)
		{
			int num = (int)(encFlags1 & EncFlags1.XOP_OpMask);
			int num2 = (int)(((uint)encFlags1 >> 5) & 0x1F);
			int num3 = (int)(((uint)encFlags1 >> 10) & 0x1F);
			int num4 = (int)(((uint)encFlags1 >> 15) & 0x1F);
			if (num4 != 0)
			{
				return new Op[4]
				{
					OpHandlerData.XopOps[num - 1],
					OpHandlerData.XopOps[num2 - 1],
					OpHandlerData.XopOps[num3 - 1],
					OpHandlerData.XopOps[num4 - 1]
				};
			}
			if (num3 != 0)
			{
				return new Op[3]
				{
					OpHandlerData.XopOps[num - 1],
					OpHandlerData.XopOps[num2 - 1],
					OpHandlerData.XopOps[num3 - 1]
				};
			}
			if (num2 != 0)
			{
				return new Op[2]
				{
					OpHandlerData.XopOps[num - 1],
					OpHandlerData.XopOps[num2 - 1]
				};
			}
			if (num != 0)
			{
				return new Op[1] { OpHandlerData.XopOps[num - 1] };
			}
			return Array2.Empty<Op>();
		}

		public XopHandler(EncFlags1 encFlags1, EncFlags2 encFlags2, EncFlags3 encFlags3)
			: base(encFlags2, encFlags3, isSpecialInstr: false, null, CreateOps(encFlags1))
		{
			table = 8 + (((uint)encFlags2 >> 17) & 7);
			LBit lBit = (LBit)(((uint)encFlags2 >> 24) & 7);
			if (lBit == LBit.L1 || lBit == LBit.L256)
			{
				lastByte = 4u;
			}
			if ((((uint)encFlags2 >> 22) & 3) == 1)
			{
				lastByte |= 128u;
			}
			lastByte |= ((uint)encFlags2 >> 20) & 3;
		}

		public override void Encode(Encoder encoder, in Instruction instruction)
		{
			encoder.WritePrefixes(in instruction);
			encoder.WriteByteInternal(143u);
			uint encoderFlags = (uint)encoder.EncoderFlags;
			uint num = table;
			num |= (~encoderFlags & 7) << 5;
			encoder.WriteByteInternal(num);
			num = lastByte;
			num |= (~encoderFlags >> 24) & 0x78;
			encoder.WriteByteInternal(num);
		}
	}
	internal sealed class EvexHandler : OpCodeHandler
	{
		private sealed class TryConvertToDisp8NImpl
		{
			public static bool TryConvertToDisp8N(Encoder encoder, OpCodeHandler handler, in Instruction instruction, int displ, out sbyte compressedValue)
			{
				int disp8N = (int)TupleTypeTable.GetDisp8N(((EvexHandler)handler).tupleType, (encoder.EncoderFlags & EncoderFlags.Broadcast) != 0);
				int num = displ / disp8N;
				if (num * disp8N == displ && -128 <= num && num <= 127)
				{
					compressedValue = (sbyte)num;
					return true;
				}
				compressedValue = 0;
				return false;
			}
		}

		private readonly WBit wbit;

		private readonly TupleType tupleType;

		private readonly uint table;

		private readonly uint p1Bits;

		private readonly uint llBits;

		private readonly uint mask_W;

		private readonly uint mask_LL;

		private static readonly TryConvertToDisp8N tryConvertToDisp8N = TryConvertToDisp8NImpl.TryConvertToDisp8N;

		private static Op[] CreateOps(EncFlags1 encFlags1)
		{
			int num = (int)(encFlags1 & EncFlags1.XOP_OpMask);
			int num2 = (int)(((uint)encFlags1 >> 5) & 0x1F);
			int num3 = (int)(((uint)encFlags1 >> 10) & 0x1F);
			int num4 = (int)(((uint)encFlags1 >> 15) & 0x1F);
			if (num4 != 0)
			{
				return new Op[4]
				{
					OpHandlerData.EvexOps[num - 1],
					OpHandlerData.EvexOps[num2 - 1],
					OpHandlerData.EvexOps[num3 - 1],
					OpHandlerData.EvexOps[num4 - 1]
				};
			}
			if (num3 != 0)
			{
				return new Op[3]
				{
					OpHandlerData.EvexOps[num - 1],
					OpHandlerData.EvexOps[num2 - 1],
					OpHandlerData.EvexOps[num3 - 1]
				};
			}
			if (num2 != 0)
			{
				return new Op[2]
				{
					OpHandlerData.EvexOps[num - 1],
					OpHandlerData.EvexOps[num2 - 1]
				};
			}
			if (num != 0)
			{
				return new Op[1] { OpHandlerData.EvexOps[num - 1] };
			}
			return Array2.Empty<Op>();
		}

		public EvexHandler(EncFlags1 encFlags1, EncFlags2 encFlags2, EncFlags3 encFlags3)
			: base(encFlags2, encFlags3, isSpecialInstr: false, tryConvertToDisp8N, CreateOps(encFlags1))
		{
			tupleType = (TupleType)(((uint)encFlags3 >> 7) & 0x1F);
			table = ((uint)encFlags2 >> 17) & 7;
			p1Bits = 4 | (((uint)encFlags2 >> 20) & 3);
			wbit = (WBit)(((uint)encFlags2 >> 22) & 3);
			if (wbit == WBit.W1)
			{
				p1Bits |= 128u;
			}
			switch ((LBit)(((uint)encFlags2 >> 24) & 7))
			{
			case LBit.LIG:
				llBits = 0u;
				mask_LL = 96u;
				break;
			case LBit.L0:
			case LBit.LZ:
			case LBit.L128:
				llBits = 0u;
				break;
			case LBit.L1:
			case LBit.L256:
				llBits = 32u;
				break;
			case LBit.L512:
				llBits = 64u;
				break;
			default:
				throw new InvalidOperationException();
			}
			if (wbit == WBit.WIG)
			{
				mask_W |= 128u;
			}
		}

		public override void Encode(Encoder encoder, in Instruction instruction)
		{
			encoder.WritePrefixes(in instruction);
			uint encoderFlags = (uint)encoder.EncoderFlags;
			encoder.WriteByteInternal(98u);
			uint num = table;
			num |= (encoderFlags & 7) << 5;
			num |= (encoderFlags >> 5) & 0x10;
			num ^= 0xFFFFFFF0u;
			encoder.WriteByteInternal(num);
			num = p1Bits;
			num |= (~encoderFlags >> 24) & 0x78;
			num |= mask_W & encoder.Internal_EVEX_WIG;
			encoder.WriteByteInternal(num);
			num = instruction.InternalOpMask;
			if (num != 0)
			{
				if ((EncFlags3 & EncFlags3.OpMaskRegister) == 0)
				{
					encoder.ErrorMessage = "The instruction doesn't support opmask registers";
				}
			}
			else if (((uint)EncFlags3 & 0x80000000u) != 0)
			{
				encoder.ErrorMessage = "The instruction must use an opmask register";
			}
			num |= (encoderFlags >> 28) & 8;
			if (instruction.SuppressAllExceptions)
			{
				if ((EncFlags3 & EncFlags3.SuppressAllExceptions) == 0)
				{
					encoder.ErrorMessage = "The instruction doesn't support suppress-all-exceptions";
				}
				num |= 0x10;
			}
			RoundingControl roundingControl = instruction.RoundingControl;
			if (roundingControl != RoundingControl.None)
			{
				if ((EncFlags3 & EncFlags3.RoundingControl) == 0)
				{
					encoder.ErrorMessage = "The instruction doesn't support rounding control";
				}
				num |= 0x10;
				num |= (uint)((int)(roundingControl - 1) << 5);
			}
			else if ((EncFlags3 & EncFlags3.SuppressAllExceptions) == 0 || !instruction.SuppressAllExceptions)
			{
				num |= llBits;
			}
			if ((encoderFlags & 0x400) != 0)
			{
				num |= 0x10;
			}
			else if (instruction.IsBroadcast)
			{
				encoder.ErrorMessage = "The instruction doesn't support broadcasting";
			}
			if (instruction.ZeroingMasking)
			{
				if ((EncFlags3 & EncFlags3.ZeroingMasking) == 0)
				{
					encoder.ErrorMessage = "The instruction doesn't support zeroing masking";
				}
				num |= 0x80;
			}
			num ^= 8;
			num |= mask_LL & encoder.Internal_EVEX_LIG;
			encoder.WriteByteInternal(num);
		}
	}
	internal sealed class D3nowHandler : OpCodeHandler
	{
		private static readonly Op[] operands = new Op[2]
		{
			new OpModRM_reg(Register.MM0, Register.MM7),
			new OpModRM_rm(Register.MM0, Register.MM7)
		};

		private readonly uint immediate;

		public D3nowHandler(EncFlags2 encFlags2, EncFlags3 encFlags3)
			: base((EncFlags2)(((ulong)encFlags2 & 0xFFFFFFFFFFFF0000uL) | 0xF), encFlags3, isSpecialInstr: false, null, operands)
		{
			immediate = OpCodeHandler.GetOpCode(encFlags2);
		}

		public override void Encode(Encoder encoder, in Instruction instruction)
		{
			encoder.WritePrefixes(in instruction);
			encoder.WriteByteInternal(15u);
			encoder.ImmSize = ImmSize.Size1OpCode;
			encoder.Immediate = immediate;
		}
	}
	internal enum DisplSize
	{
		None,
		Size1,
		Size2,
		Size4,
		Size8,
		RipRelSize4_Target32,
		RipRelSize4_Target64
	}
	internal enum ImmSize
	{
		None,
		Size1,
		Size2,
		Size4,
		Size8,
		Size2_1,
		Size1_1,
		Size2_2,
		Size4_2,
		RipRelSize1_Target16,
		RipRelSize1_Target32,
		RipRelSize1_Target64,
		RipRelSize2_Target16,
		RipRelSize2_Target32,
		RipRelSize2_Target64,
		RipRelSize4_Target32,
		RipRelSize4_Target64,
		SizeIbReg,
		Size1OpCode
	}
	[Flags]
	internal enum EncoderFlags : uint
	{
		None = 0u,
		B = 1u,
		X = 2u,
		R = 4u,
		W = 8u,
		ModRM = 0x10u,
		Sib = 0x20u,
		REX = 0x40u,
		P66 = 0x80u,
		P67 = 0x100u,
		R2 = 0x200u,
		Broadcast = 0x400u,
		HighLegacy8BitRegs = 0x800u,
		Displ = 0x1000u,
		PF0 = 0x2000u,
		RegIsMemory = 0x4000u,
		MustUseSib = 0x8000u,
		VvvvvShift = 0x1Bu,
		VvvvvMask = 0x1Fu
	}
	internal enum LegacyOpCodeTable
	{
		MAP0,
		MAP0F,
		MAP0F38,
		MAP0F3A
	}
	internal enum VexOpCodeTable
	{
		MAP0,
		MAP0F,
		MAP0F38,
		MAP0F3A
	}
	internal enum XopOpCodeTable
	{
		MAP8,
		MAP9,
		MAP10
	}
	internal enum EvexOpCodeTable
	{
		MAP0F = 1,
		MAP0F38 = 2,
		MAP0F3A = 3,
		MAP5 = 5,
		MAP6 = 6
	}
	internal enum MvexOpCodeTable
	{
		MAP0F = 1,
		MAP0F38,
		MAP0F3A
	}
	[Flags]
	internal enum EncFlags1 : uint
	{
		None = 0u,
		Legacy_OpMask = 0x7Fu,
		Legacy_Op0Shift = 0u,
		Legacy_Op1Shift = 7u,
		Legacy_Op2Shift = 0xEu,
		Legacy_Op3Shift = 0x15u,
		VEX_OpMask = 0x3Fu,
		VEX_Op0Shift = 0u,
		VEX_Op1Shift = 6u,
		VEX_Op2Shift = 0xCu,
		VEX_Op3Shift = 0x12u,
		VEX_Op4Shift = 0x18u,
		XOP_OpMask = 0x1Fu,
		XOP_Op0Shift = 0u,
		XOP_Op1Shift = 5u,
		XOP_Op2Shift = 0xAu,
		XOP_Op3Shift = 0xFu,
		EVEX_OpMask = 0x1Fu,
		EVEX_Op0Shift = 0u,
		EVEX_Op1Shift = 5u,
		EVEX_Op2Shift = 0xAu,
		EVEX_Op3Shift = 0xFu,
		MVEX_OpMask = 0xFu,
		MVEX_Op0Shift = 0u,
		MVEX_Op1Shift = 4u,
		MVEX_Op2Shift = 8u,
		MVEX_Op3Shift = 0xCu,
		IgnoresRoundingControl = 0x40000000u,
		AmdLockRegBit = 0x80000000u
	}
	[Flags]
	internal enum EncFlags2 : uint
	{
		None = 0u,
		OpCodeShift = 0u,
		OpCodeIs2Bytes = 0x10000u,
		TableShift = 0x11u,
		TableMask = 7u,
		MandatoryPrefixShift = 0x14u,
		MandatoryPrefixMask = 3u,
		WBitShift = 0x16u,
		WBitMask = 3u,
		LBitShift = 0x18u,
		LBitMask = 7u,
		GroupIndexShift = 0x1Bu,
		GroupIndexMask = 7u,
		HasMandatoryPrefix = 0x40000000u,
		HasGroupIndex = 0x80000000u
	}
	[Flags]
	internal enum EncFlags3 : uint
	{
		None = 0u,
		EncodingShift = 0u,
		EncodingMask = 7u,
		OperandSizeShift = 3u,
		OperandSizeMask = 3u,
		AddressSizeShift = 5u,
		AddressSizeMask = 3u,
		TupleTypeShift = 7u,
		TupleTypeMask = 0x1Fu,
		DefaultOpSize64 = 0x1000u,
		HasRmGroupIndex = 0x2000u,
		IntelForceOpSize64 = 0x4000u,
		Fwait = 0x8000u,
		Bit16or32 = 0x10000u,
		Bit64 = 0x20000u,
		Lock = 0x40000u,
		Xacquire = 0x80000u,
		Xrelease = 0x100000u,
		Rep = 0x200000u,
		Repne = 0x400000u,
		Bnd = 0x800000u,
		HintTaken = 0x1000000u,
		Notrack = 0x2000000u,
		Broadcast = 0x4000000u,
		RoundingControl = 0x8000000u,
		SuppressAllExceptions = 0x10000000u,
		OpMaskRegister = 0x20000000u,
		ZeroingMasking = 0x40000000u,
		RequireOpMaskRegister = 0x80000000u
	}
	internal enum WBit : uint
	{
		W0,
		W1,
		WIG,
		WIG32
	}
	internal enum LBit : uint
	{
		L0,
		L1,
		LIG,
		LZ,
		L128,
		L256,
		L512
	}
	internal static class OpCodeHandlers
	{
		public static readonly OpCodeHandler[] Handlers;

		static OpCodeHandlers()
		{
			uint[] encFlags = EncoderData.EncFlags1;
			uint[] encFlags2 = EncoderData.EncFlags2;
			uint[] encFlags3 = EncoderData.EncFlags3;
			OpCodeHandler[] array = new OpCodeHandler[4936];
			int i = 0;
			InvalidHandler invalidHandler = new InvalidHandler();
			for (; i < encFlags.Length; i++)
			{
				EncFlags3 encFlags4 = (EncFlags3)encFlags3[i];
				OpCodeHandler opCodeHandler;
				switch ((EncodingKind)(encFlags4 & EncFlags3.EncodingMask))
				{
				case EncodingKind.Legacy:
				{
					Code code = (Code)i;
					opCodeHandler = ((code != Code.INVALID) ? ((code > Code.DeclareQword) ? ((code != Code.Zero_bytes) ? ((OpCodeHandler)new LegacyHandler((EncFlags1)encFlags[i], (EncFlags2)encFlags2[i], encFlags4)) : ((OpCodeHandler)new ZeroBytesHandler(code))) : new DeclareDataHandler(code)) : invalidHandler);
					break;
				}
				case EncodingKind.VEX:
					opCodeHandler = new VexHandler((EncFlags1)encFlags[i], (EncFlags2)encFlags2[i], encFlags4);
					break;
				case EncodingKind.EVEX:
					opCodeHandler = new EvexHandler((EncFlags1)encFlags[i], (EncFlags2)encFlags2[i], encFlags4);
					break;
				case EncodingKind.XOP:
					opCodeHandler = new XopHandler((EncFlags1)encFlags[i], (EncFlags2)encFlags2[i], encFlags4);
					break;
				case EncodingKind.D3NOW:
					opCodeHandler = new D3nowHandler((EncFlags2)encFlags2[i], encFlags4);
					break;
				case EncodingKind.MVEX:
					opCodeHandler = invalidHandler;
					break;
				default:
					throw new InvalidOperationException();
				}
				array[i] = opCodeHandler;
			}
			if (i != array.Length)
			{
				throw new InvalidOperationException();
			}
			Handlers = array;
		}
	}
	internal abstract class Op
	{
		public abstract void Encode(Encoder encoder, in Instruction instruction, int operand);

		public virtual OpKind GetImmediateOpKind()
		{
			return (OpKind)(-1);
		}

		public virtual OpKind GetNearBranchOpKind()
		{
			return (OpKind)(-1);
		}

		public virtual OpKind GetFarBranchOpKind()
		{
			return (OpKind)(-1);
		}
	}
	internal sealed class OpModRM_rm_mem_only : Op
	{
		private readonly bool mustUseSib;

		public OpModRM_rm_mem_only(bool mustUseSib)
		{
			this.mustUseSib = mustUseSib;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			if (mustUseSib)
			{
				encoder.EncoderFlags |= EncoderFlags.MustUseSib;
			}
			encoder.AddRegOrMem(in instruction, operand, Register.None, Register.None, allowMemOp: true, allowRegOp: false);
		}
	}
	internal sealed class OpModRM_rm : Op
	{
		private readonly Register regLo;

		private readonly Register regHi;

		public OpModRM_rm(Register regLo, Register regHi)
		{
			this.regLo = regLo;
			this.regHi = regHi;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.AddRegOrMem(in instruction, operand, regLo, regHi, allowMemOp: true, allowRegOp: true);
		}
	}
	internal sealed class OpRegEmbed8 : Op
	{
		private readonly Register regLo;

		private readonly Register regHi;

		public OpRegEmbed8(Register regLo, Register regHi)
		{
			this.regLo = regLo;
			this.regHi = regHi;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.AddReg(in instruction, operand, regLo, regHi);
		}
	}
	internal sealed class OpModRM_rm_reg_only : Op
	{
		private readonly Register regLo;

		private readonly Register regHi;

		public OpModRM_rm_reg_only(Register regLo, Register regHi)
		{
			this.regLo = regLo;
			this.regHi = regHi;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.AddRegOrMem(in instruction, operand, regLo, regHi, allowMemOp: false, allowRegOp: true);
		}
	}
	internal sealed class OpModRM_reg : Op
	{
		private readonly Register regLo;

		private readonly Register regHi;

		public OpModRM_reg(Register regLo, Register regHi)
		{
			this.regLo = regLo;
			this.regHi = regHi;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.AddModRMRegister(in instruction, operand, regLo, regHi);
		}
	}
	internal sealed class OpModRM_reg_mem : Op
	{
		private readonly Register regLo;

		private readonly Register regHi;

		public OpModRM_reg_mem(Register regLo, Register regHi)
		{
			this.regLo = regLo;
			this.regHi = regHi;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.AddModRMRegister(in instruction, operand, regLo, regHi);
			encoder.EncoderFlags |= EncoderFlags.RegIsMemory;
		}
	}
	internal sealed class OpModRM_regF0 : Op
	{
		private readonly Register regLo;

		private readonly Register regHi;

		public OpModRM_regF0(Register regLo, Register regHi)
		{
			this.regLo = regLo;
			this.regHi = regHi;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			if (encoder.Bitness != 64 && instruction.GetOpKind(operand) == OpKind.Register && instruction.GetOpRegister(operand) >= regLo + 8 && instruction.GetOpRegister(operand) <= regLo + 15)
			{
				encoder.EncoderFlags |= EncoderFlags.PF0;
				encoder.AddModRMRegister(in instruction, operand, regLo + 8, regLo + 15);
			}
			else
			{
				encoder.AddModRMRegister(in instruction, operand, regLo, regHi);
			}
		}
	}
	internal sealed class OpReg : Op
	{
		private readonly Register register;

		public OpReg(Register register)
		{
			this.register = register;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.Verify(operand, OpKind.Register, instruction.GetOpKind(operand));
			encoder.Verify(operand, register, instruction.GetOpRegister(operand));
		}
	}
	internal sealed class OpRegSTi : Op
	{
		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			if (encoder.Verify(operand, OpKind.Register, instruction.GetOpKind(operand)))
			{
				Register opRegister = instruction.GetOpRegister(operand);
				if (encoder.Verify(operand, opRegister, Register.ST0, Register.ST7))
				{
					encoder.OpCode |= (uint)(opRegister - 217);
				}
			}
		}
	}
	internal sealed class OprDI : Op
	{
		private static int GetRegSize(OpKind opKind)
		{
			return opKind switch
			{
				OpKind.MemorySegRDI => 8, 
				OpKind.MemorySegEDI => 4, 
				OpKind.MemorySegDI => 2, 
				_ => 0, 
			};
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			int regSize = GetRegSize(instruction.GetOpKind(operand));
			if (regSize == 0)
			{
				encoder.ErrorMessage = $"Operand {operand}: expected OpKind = {"MemorySegDI"}, {"MemorySegEDI"} or {"MemorySegRDI"}";
			}
			else
			{
				encoder.SetAddrSize(regSize);
			}
		}
	}
	internal sealed class OpIb : Op
	{
		private readonly OpKind opKind;

		public OpIb(OpKind opKind)
		{
			this.opKind = opKind;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			switch (encoder.ImmSize)
			{
			case ImmSize.Size1:
				if (encoder.Verify(operand, OpKind.Immediate8_2nd, instruction.GetOpKind(operand)))
				{
					encoder.ImmSize = ImmSize.Size1_1;
					encoder.ImmediateHi = instruction.Immediate8_2nd;
				}
				return;
			case ImmSize.Size2:
				if (encoder.Verify(operand, OpKind.Immediate8_2nd, instruction.GetOpKind(operand)))
				{
					encoder.ImmSize = ImmSize.Size2_1;
					encoder.ImmediateHi = instruction.Immediate8_2nd;
				}
				return;
			}
			OpKind actual = instruction.GetOpKind(operand);
			if (encoder.Verify(operand, opKind, actual))
			{
				encoder.ImmSize = ImmSize.Size1;
				encoder.Immediate = instruction.Immediate8;
			}
		}

		public override OpKind GetImmediateOpKind()
		{
			return opKind;
		}
	}
	internal sealed class OpIw : Op
	{
		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			if (encoder.Verify(operand, OpKind.Immediate16, instruction.GetOpKind(operand)))
			{
				encoder.ImmSize = ImmSize.Size2;
				encoder.Immediate = instruction.Immediate16;
			}
		}

		public override OpKind GetImmediateOpKind()
		{
			return OpKind.Immediate16;
		}
	}
	internal sealed class OpId : Op
	{
		private readonly OpKind opKind;

		public OpId(OpKind opKind)
		{
			this.opKind = opKind;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			OpKind actual = instruction.GetOpKind(operand);
			if (encoder.Verify(operand, opKind, actual))
			{
				encoder.ImmSize = ImmSize.Size4;
				encoder.Immediate = instruction.Immediate32;
			}
		}

		public override OpKind GetImmediateOpKind()
		{
			return opKind;
		}
	}
	internal sealed class OpIq : Op
	{
		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			if (encoder.Verify(operand, OpKind.Immediate64, instruction.GetOpKind(operand)))
			{
				encoder.ImmSize = ImmSize.Size8;
				ulong immediate = instruction.Immediate64;
				encoder.Immediate = (uint)immediate;
				encoder.ImmediateHi = (uint)(immediate >> 32);
			}
		}

		public override OpKind GetImmediateOpKind()
		{
			return OpKind.Immediate64;
		}
	}
	internal sealed class OpI4 : Op
	{
		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			OpKind opKind = instruction.GetOpKind(operand);
			if (encoder.Verify(operand, OpKind.Immediate8, opKind))
			{
				if (instruction.Immediate8 > 15)
				{
					encoder.ErrorMessage = $"Operand {operand}: Immediate value must be 0-15, but value is 0x{instruction.Immediate8:X2}";
				}
				else
				{
					encoder.ImmSize = ImmSize.Size1;
					encoder.Immediate |= instruction.Immediate8;
				}
			}
		}

		public override OpKind GetImmediateOpKind()
		{
			return OpKind.Immediate8;
		}
	}
	internal sealed class OpX : Op
	{
		internal static int GetXRegSize(OpKind opKind)
		{
			return opKind switch
			{
				OpKind.MemorySegRSI => 8, 
				OpKind.MemorySegESI => 4, 
				OpKind.MemorySegSI => 2, 
				_ => 0, 
			};
		}

		internal static int GetYRegSize(OpKind opKind)
		{
			return opKind switch
			{
				OpKind.MemoryESRDI => 8, 
				OpKind.MemoryESEDI => 4, 
				OpKind.MemoryESDI => 2, 
				_ => 0, 
			};
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			int xRegSize = GetXRegSize(instruction.GetOpKind(operand));
			if (xRegSize == 0)
			{
				encoder.ErrorMessage = $"Operand {operand}: expected OpKind = {"MemorySegSI"}, {"MemorySegESI"} or {"MemorySegRSI"}";
				return;
			}
			Code code = instruction.Code;
			if ((uint)(code - 331) <= 3u)
			{
				int yRegSize = GetYRegSize(instruction.Op0Kind);
				if (xRegSize != yRegSize)
				{
					encoder.ErrorMessage = $"Same sized register must be used: reg #1 size = {yRegSize * 8}, reg #2 size = {xRegSize * 8}";
					return;
				}
			}
			encoder.SetAddrSize(xRegSize);
		}
	}
	internal sealed class OpY : Op
	{
		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			int yRegSize = OpX.GetYRegSize(instruction.GetOpKind(operand));
			if (yRegSize == 0)
			{
				encoder.ErrorMessage = $"Operand {operand}: expected OpKind = {"MemoryESDI"}, {"MemoryESEDI"} or {"MemoryESRDI"}";
				return;
			}
			Code code = instruction.Code;
			if ((uint)(code - 335) <= 3u)
			{
				int xRegSize = OpX.GetXRegSize(instruction.Op0Kind);
				if (xRegSize != yRegSize)
				{
					encoder.ErrorMessage = $"Same sized register must be used: reg #1 size = {xRegSize * 8}, reg #2 size = {yRegSize * 8}";
					return;
				}
			}
			encoder.SetAddrSize(yRegSize);
		}
	}
	internal sealed class OpMRBX : Op
	{
		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			if (encoder.Verify(operand, OpKind.Memory, instruction.GetOpKind(operand)))
			{
				Register memoryBase = instruction.MemoryBase;
				if (instruction.MemoryDisplSize != 0 || instruction.MemoryDisplacement64 != 0L || instruction.MemoryIndexScale != 1 || instruction.MemoryIndex != Register.AL || (memoryBase != Register.BX && memoryBase != Register.EBX && memoryBase != Register.RBX))
				{
					encoder.ErrorMessage = $"Operand {operand}: Operand must be [bx+al], [ebx+al], or [rbx+al]";
				}
				else
				{
					encoder.SetAddrSize(memoryBase switch
					{
						Register.RBX => 8, 
						Register.EBX => 4, 
						_ => 2, 
					});
				}
			}
		}
	}
	internal sealed class OpJ : Op
	{
		private readonly OpKind opKind;

		private readonly int immSize;

		public OpJ(OpKind opKind, int immSize)
		{
			this.opKind = opKind;
			this.immSize = immSize;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.AddBranch(opKind, immSize, in instruction, operand);
		}

		public override OpKind GetNearBranchOpKind()
		{
			return opKind;
		}
	}
	internal sealed class OpJx : Op
	{
		private readonly int immSize;

		public OpJx(int immSize)
		{
			this.immSize = immSize;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.AddBranchX(immSize, in instruction, operand);
		}

		public override OpKind GetNearBranchOpKind()
		{
			return base.GetNearBranchOpKind();
		}
	}
	internal sealed class OpJdisp : Op
	{
		private readonly int displSize;

		public OpJdisp(int displSize)
		{
			this.displSize = displSize;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.AddBranchDisp(displSize, in instruction, operand);
		}

		public override OpKind GetNearBranchOpKind()
		{
			if (displSize != 2)
			{
				return OpKind.NearBranch32;
			}
			return OpKind.NearBranch16;
		}
	}
	internal sealed class OpA : Op
	{
		private readonly int size;

		public OpA(int size)
		{
			this.size = size;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.AddFarBranch(in instruction, operand, size);
		}

		public override OpKind GetFarBranchOpKind()
		{
			if (size != 2)
			{
				return OpKind.FarBranch32;
			}
			return OpKind.FarBranch16;
		}
	}
	internal sealed class OpO : Op
	{
		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.AddAbsMem(in instruction, operand);
		}
	}
	internal sealed class OpImm : Op
	{
		private readonly byte value;

		public OpImm(byte value)
		{
			this.value = value;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			if (encoder.Verify(operand, OpKind.Immediate8, instruction.GetOpKind(operand)) && instruction.Immediate8 != value)
			{
				encoder.ErrorMessage = $"Operand {operand}: Expected 0x{value:X2}, actual: 0x{instruction.Immediate8:X2}";
			}
		}

		public override OpKind GetImmediateOpKind()
		{
			return OpKind.Immediate8;
		}
	}
	internal sealed class OpHx : Op
	{
		private readonly Register regLo;

		private readonly Register regHi;

		public OpHx(Register regLo, Register regHi)
		{
			this.regLo = regLo;
			this.regHi = regHi;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			if (encoder.Verify(operand, OpKind.Register, instruction.GetOpKind(operand)))
			{
				Register opRegister = instruction.GetOpRegister(operand);
				if (encoder.Verify(operand, opRegister, regLo, regHi))
				{
					encoder.EncoderFlags |= (EncoderFlags)(opRegister - regLo << 27);
				}
			}
		}
	}
	internal sealed class OpVsib : Op
	{
		private readonly Register vsibIndexRegLo;

		private readonly Register vsibIndexRegHi;

		public OpVsib(Register regLo, Register regHi)
		{
			vsibIndexRegLo = regLo;
			vsibIndexRegHi = regHi;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			encoder.EncoderFlags |= EncoderFlags.MustUseSib;
			encoder.AddRegOrMem(in instruction, operand, Register.None, Register.None, vsibIndexRegLo, vsibIndexRegHi, allowMemOp: true, allowRegOp: false);
		}
	}
	internal sealed class OpIsX : Op
	{
		private readonly Register regLo;

		private readonly Register regHi;

		public OpIsX(Register regLo, Register regHi)
		{
			this.regLo = regLo;
			this.regHi = regHi;
		}

		public override void Encode(Encoder encoder, in Instruction instruction, int operand)
		{
			if (encoder.Verify(operand, OpKind.Register, instruction.GetOpKind(operand)))
			{
				Register opRegister = instruction.GetOpRegister(operand);
				if (encoder.Verify(operand, opRegister, regLo, regHi))
				{
					encoder.ImmSize = ImmSize.SizeIbReg;
					encoder.Immediate = (uint)(opRegister - regLo << 4);
				}
			}
		}
	}
	internal static class OpHandlerData
	{
		public static readonly Op[] LegacyOps = new Op[75]
		{
			new OpA(2),
			new OpA(4),
			new OpO(),
			new OpModRM_rm_mem_only(mustUseSib: false),
			new OpModRM_rm_mem_only(mustUseSib: false),
			new OpModRM_rm_mem_only(mustUseSib: false),
			new OpModRM_rm(Register.AL, Register.R15L),
			new OpModRM_rm(Register.AX, Register.R15W),
			new OpModRM_rm(Register.EAX, Register.R15D),
			new OpModRM_rm(Register.EAX, Register.R15D),
			new OpModRM_rm(Register.RAX, Register.R15),
			new OpModRM_rm(Register.RAX, Register.R15),
			new OpModRM_rm(Register.MM0, Register.MM7),
			new OpModRM_rm(Register.XMM0, Register.XMM15),
			new OpModRM_rm(Register.BND0, Register.BND3),
			new OpModRM_reg(Register.AL, Register.R15L),
			new OpRegEmbed8(Register.AL, Register.R15L),
			new OpModRM_reg(Register.AX, Register.R15W),
			new OpModRM_reg_mem(Register.AX, Register.R15W),
			new OpModRM_rm_reg_only(Register.AX, Register.R15W),
			new OpRegEmbed8(Register.AX, Register.R15W),
			new OpModRM_reg(Register.EAX, Register.R15D),
			new OpModRM_reg_mem(Register.EAX, Register.R15D),
			new OpModRM_rm_reg_only(Register.EAX, Register.R15D),
			new OpRegEmbed8(Register.EAX, Register.R15D),
			new OpModRM_reg(Register.RAX, Register.R15),
			new OpModRM_reg_mem(Register.RAX, Register.R15),
			new OpModRM_rm_reg_only(Register.RAX, Register.R15),
			new OpRegEmbed8(Register.RAX, Register.R15),
			new OpModRM_reg(Register.ES, Register.GS),
			new OpModRM_reg(Register.MM0, Register.MM7),
			new OpModRM_rm_reg_only(Register.MM0, Register.MM7),
			new OpModRM_reg(Register.XMM0, Register.XMM15),
			new OpModRM_rm_reg_only(Register.XMM0, Register.XMM15),
			new OpModRM_regF0(Register.CR0, Register.CR15),
			new OpModRM_reg(Register.DR0, Register.DR15),
			new OpModRM_reg(Register.TR0, Register.TR7),
			new OpModRM_reg(Register.BND0, Register.BND3),
			new OpReg(Register.ES),
			new OpReg(Register.CS),
			new OpReg(Register.SS),
			new OpReg(Register.DS),
			new OpReg(Register.FS),
			new OpReg(Register.GS),
			new OpReg(Register.AL),
			new OpReg(Register.CL),
			new OpReg(Register.AX),
			new OpReg(Register.DX),
			new OpReg(Register.EAX),
			new OpReg(Register.RAX),
			new OpReg(Register.ST0),
			new OpRegSTi(),
			new OpIb(OpKind.Immediate8),
			new OpImm(1),
			new OpIb(OpKind.Immediate8to16),
			new OpIb(OpKind.Immediate8to32),
			new OpIb(OpKind.Immediate8to64),
			new OpIw(),
			new OpId(OpKind.Immediate32),
			new OpId(OpKind.Immediate32to64),
			new OpIq(),
			new OpX(),
			new OpY(),
			new OprDI(),
			new OpMRBX(),
			new OpJ(OpKind.NearBranch16, 1),
			new OpJ(OpKind.NearBranch32, 1),
			new OpJ(OpKind.NearBranch64, 1),
			new OpJ(OpKind.NearBranch16, 2),
			new OpJ(OpKind.NearBranch32, 4),
			new OpJ(OpKind.NearBranch64, 4),
			new OpJx(2),
			new OpJx(4),
			new OpJdisp(2),
			new OpJdisp(4)
		};

		public static readonly Op[] VexOps = new Op[38]
		{
			new OpModRM_rm_mem_only(mustUseSib: false),
			new OpVsib(Register.XMM0, Register.XMM15),
			new OpVsib(Register.XMM0, Register.XMM15),
			new OpVsib(Register.YMM0, Register.YMM15),
			new OpVsib(Register.YMM0, Register.YMM15),
			new OpModRM_rm(Register.EAX, Register.R15D),
			new OpModRM_rm(Register.RAX, Register.R15),
			new OpModRM_rm(Register.XMM0, Register.XMM15),
			new OpModRM_rm(Register.YMM0, Register.YMM15),
			new OpModRM_rm(Register.K0, Register.K7),
			new OpModRM_reg(Register.EAX, Register.R15D),
			new OpModRM_rm_reg_only(Register.EAX, Register.R15D),
			new OpHx(Register.EAX, Register.R15D),
			new OpModRM_reg(Register.RAX, Register.R15),
			new OpModRM_rm_reg_only(Register.RAX, Register.R15),
			new OpHx(Register.RAX, Register.R15),
			new OpModRM_reg(Register.K0, Register.K7),
			new OpModRM_rm_reg_only(Register.K0, Register.K7),
			new OpHx(Register.K0, Register.K7),
			new OpModRM_reg(Register.XMM0, Register.XMM15),
			new OpModRM_rm_reg_only(Register.XMM0, Register.XMM15),
			new OpHx(Register.XMM0, Register.XMM15),
			new OpIsX(Register.XMM0, Register.XMM15),
			new OpIsX(Register.XMM0, Register.XMM15),
			new OpModRM_reg(Register.YMM0, Register.YMM15),
			new OpModRM_rm_reg_only(Register.YMM0, Register.YMM15),
			new OpHx(Register.YMM0, Register.YMM15),
			new OpIsX(Register.YMM0, Register.YMM15),
			new OpIsX(Register.YMM0, Register.YMM15),
			new OpI4(),
			new OpIb(OpKind.Immediate8),
			new OprDI(),
			new OpJ(OpKind.NearBranch64, 1),
			new OpJ(OpKind.NearBranch64, 4),
			new OpModRM_rm_mem_only(mustUseSib: true),
			new OpModRM_reg(Register.TMM0, Register.TMM7),
			new OpModRM_rm_reg_only(Register.TMM0, Register.TMM7),
			new OpHx(Register.TMM0, Register.TMM7)
		};

		public static readonly Op[] XopOps = new Op[18]
		{
			new OpModRM_rm(Register.EAX, Register.R15D),
			new OpModRM_rm(Register.RAX, Register.R15),
			new OpModRM_rm(Register.XMM0, Register.XMM15),
			new OpModRM_rm(Register.YMM0, Register.YMM15),
			new OpModRM_reg(Register.EAX, Register.R15D),
			new OpModRM_rm_reg_only(Register.EAX, Register.R15D),
			new OpHx(Register.EAX, Register.R15D),
			new OpModRM_reg(Register.RAX, Register.R15),
			new OpModRM_rm_reg_only(Register.RAX, Register.R15),
			new OpHx(Register.RAX, Register.R15),
			new OpModRM_reg(Register.XMM0, Register.XMM15),
			new OpHx(Register.XMM0, Register.XMM15),
			new OpIsX(Register.XMM0, Register.XMM15),
			new OpModRM_reg(Register.YMM0, Register.YMM15),
			new OpHx(Register.YMM0, Register.YMM15),
			new OpIsX(Register.YMM0, Register.YMM15),
			new OpIb(OpKind.Immediate8),
			new OpId(OpKind.Immediate32)
		};

		public static readonly Op[] EvexOps = new Op[31]
		{
			new OpModRM_rm_mem_only(mustUseSib: false),
			new OpVsib(Register.XMM0, Register.XMM31),
			new OpVsib(Register.XMM0, Register.XMM31),
			new OpVsib(Register.YMM0, Register.YMM31),
			new OpVsib(Register.YMM0, Register.YMM31),
			new OpVsib(Register.ZMM0, Register.ZMM31),
			new OpVsib(Register.ZMM0, Register.ZMM31),
			new OpModRM_rm(Register.EAX, Register.R15D),
			new OpModRM_rm(Register.RAX, Register.R15),
			new OpModRM_rm(Register.XMM0, Register.XMM31),
			new OpModRM_rm(Register.YMM0, Register.YMM31),
			new OpModRM_rm(Register.ZMM0, Register.ZMM31),
			new OpModRM_reg(Register.EAX, Register.R15D),
			new OpModRM_rm_reg_only(Register.EAX, Register.R15D),
			new OpModRM_reg(Register.RAX, Register.R15),
			new OpModRM_rm_reg_only(Register.RAX, Register.R15),
			new OpModRM_reg(Register.K0, Register.K7),
			new OpModRM_reg(Register.K0, Register.K7),
			new OpModRM_rm_reg_only(Register.K0, Register.K7),
			new OpModRM_reg(Register.XMM0, Register.XMM31),
			new OpModRM_rm_reg_only(Register.XMM0, Register.XMM31),
			new OpHx(Register.XMM0, Register.XMM31),
			new OpHx(Register.XMM0, Register.XMM31),
			new OpModRM_reg(Register.YMM0, Register.YMM31),
			new OpModRM_rm_reg_only(Register.YMM0, Register.YMM31),
			new OpHx(Register.YMM0, Register.YMM31),
			new OpModRM_reg(Register.ZMM0, Register.ZMM31),
			new OpModRM_rm_reg_only(Register.ZMM0, Register.ZMM31),
			new OpHx(Register.ZMM0, Register.ZMM31),
			new OpHx(Register.ZMM0, Register.ZMM31),
			new OpIb(OpKind.Immediate8)
		};
	}
}
namespace Iced.Intel.DecoderInternal
{
	internal enum EvexOpCodeHandlerKind : byte
	{
		Invalid,
		Invalid2,
		Dup,
		HandlerReference,
		ArrayReference,
		RM,
		Group,
		W,
		MandatoryPrefix2,
		VectorLength,
		VectorLength_er,
		Ed_V_Ib,
		Ev_VX,
		Ev_VX_Ib,
		Gv_W_er,
		GvM_VX_Ib,
		HkWIb_3,
		HkWIb_3b,
		HWIb,
		KkHW_3,
		KkHW_3b,
		KkHWIb_sae_3,
		KkHWIb_sae_3b,
		KkHWIb_3,
		KkHWIb_3b,
		KkWIb_3,
		KkWIb_3b,
		KP1HW,
		KR,
		MV,
		V_H_Ev_er,
		V_H_Ev_Ib,
		VHM,
		VHW_3,
		VHW_4,
		VHWIb,
		VK,
		Vk_VSIB,
		VkEv_REXW_2,
		VkEv_REXW_3,
		VkHM,
		VkHW_3,
		VkHW_3b,
		VkHW_5,
		VkHW_er_4,
		VkHW_er_4b,
		VkHWIb_3,
		VkHWIb_3b,
		VkHWIb_5,
		VkHWIb_er_4,
		VkHWIb_er_4b,
		VkM,
		VkW_3,
		VkW_3b,
		VkW_4,
		VkW_4b,
		VkW_er_4,
		VkW_er_5,
		VkW_er_6,
		VkWIb_3,
		VkWIb_3b,
		VkWIb_er,
		VM,
		VSIB_k1,
		VSIB_k1_VX,
		VW,
		VW_er,
		VX_Ev,
		WkHV,
		WkV_3,
		WkV_4a,
		WkV_4b,
		WkVIb,
		WkVIb_er,
		WV,
		VkHW_er_ur_3,
		VkHW_er_ur_3b
	}
	internal sealed class EvexOpCodeHandlerReader : OpCodeHandlerReader
	{
		public override int ReadHandlers(ref TableDeserializer deserializer, OpCodeHandler?[] result, int resultIndex)
		{
			ref OpCodeHandler reference = ref result[resultIndex];
			switch (deserializer.ReadEvexOpCodeHandlerKind())
			{
			case EvexOpCodeHandlerKind.Invalid:
				reference = OpCodeHandler_Invalid.Instance;
				return 1;
			case EvexOpCodeHandlerKind.Invalid2:
				result[resultIndex] = OpCodeHandler_Invalid.Instance;
				result[resultIndex + 1] = OpCodeHandler_Invalid.Instance;
				return 2;
			case EvexOpCodeHandlerKind.Dup:
			{
				int num = deserializer.ReadInt32();
				OpCodeHandler opCodeHandler = deserializer.ReadHandler();
				for (int i = 0; i < num; i++)
				{
					result[resultIndex + i] = opCodeHandler;
				}
				return num;
			}
			case EvexOpCodeHandlerKind.HandlerReference:
				reference = deserializer.ReadHandlerReference();
				return 1;
			case EvexOpCodeHandlerKind.ArrayReference:
				throw new InvalidOperationException();
			case EvexOpCodeHandlerKind.RM:
				reference = new OpCodeHandler_RM(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case EvexOpCodeHandlerKind.Group:
				reference = new OpCodeHandler_Group(deserializer.ReadArrayReference(4u));
				return 1;
			case EvexOpCodeHandlerKind.W:
				reference = new OpCodeHandler_W(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case EvexOpCodeHandlerKind.MandatoryPrefix2:
				reference = new OpCodeHandler_MandatoryPrefix2(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case EvexOpCodeHandlerKind.VectorLength:
				reference = new OpCodeHandler_VectorLength_EVEX(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case EvexOpCodeHandlerKind.VectorLength_er:
				reference = new OpCodeHandler_VectorLength_EVEX_er(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case EvexOpCodeHandlerKind.Ed_V_Ib:
			{
				Code code;
				reference = new OpCodeHandler_EVEX_Ed_V_Ib(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1, deserializer.ReadTupleType(), deserializer.ReadTupleType());
				return 1;
			}
			case EvexOpCodeHandlerKind.Ev_VX:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_EVEX_Ev_VX(code, code + 1, deserializer.ReadTupleType(), deserializer.ReadTupleType());
				return 1;
			}
			case EvexOpCodeHandlerKind.Ev_VX_Ib:
			{
				Code code;
				reference = new OpCodeHandler_EVEX_Ev_VX_Ib(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case EvexOpCodeHandlerKind.Gv_W_er:
			{
				Code code;
				reference = new OpCodeHandler_EVEX_Gv_W_er(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1, deserializer.ReadTupleType(), deserializer.ReadBoolean());
				return 1;
			}
			case EvexOpCodeHandlerKind.GvM_VX_Ib:
			{
				Code code;
				reference = new OpCodeHandler_EVEX_GvM_VX_Ib(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1, deserializer.ReadTupleType(), deserializer.ReadTupleType());
				return 1;
			}
			case EvexOpCodeHandlerKind.HkWIb_3:
				reference = new OpCodeHandler_EVEX_HkWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.HkWIb_3b:
				reference = new OpCodeHandler_EVEX_HkWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.HWIb:
				reference = new OpCodeHandler_EVEX_HWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.KkHW_3:
				reference = new OpCodeHandler_EVEX_KkHW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.KkHW_3b:
				reference = new OpCodeHandler_EVEX_KkHW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.KkHWIb_sae_3:
				reference = new OpCodeHandler_EVEX_KkHWIb_sae(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.KkHWIb_sae_3b:
				reference = new OpCodeHandler_EVEX_KkHWIb_sae(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.KkHWIb_3:
				reference = new OpCodeHandler_EVEX_KkHWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.KkHWIb_3b:
				reference = new OpCodeHandler_EVEX_KkHWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.KkWIb_3:
				reference = new OpCodeHandler_EVEX_KkWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.KkWIb_3b:
				reference = new OpCodeHandler_EVEX_KkWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.KP1HW:
				reference = new OpCodeHandler_EVEX_KP1HW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.KR:
				reference = new OpCodeHandler_EVEX_KR(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case EvexOpCodeHandlerKind.MV:
				reference = new OpCodeHandler_EVEX_MV(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.V_H_Ev_er:
			{
				Code code;
				reference = new OpCodeHandler_EVEX_V_H_Ev_er(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1, deserializer.ReadTupleType(), deserializer.ReadTupleType());
				return 1;
			}
			case EvexOpCodeHandlerKind.V_H_Ev_Ib:
			{
				Code code;
				reference = new OpCodeHandler_EVEX_V_H_Ev_Ib(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1, deserializer.ReadTupleType(), deserializer.ReadTupleType());
				return 1;
			}
			case EvexOpCodeHandlerKind.VHM:
				reference = new OpCodeHandler_EVEX_VHM(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VHW_3:
				reference = new OpCodeHandler_EVEX_VHW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VHW_4:
				reference = new OpCodeHandler_EVEX_VHW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VHWIb:
				reference = new OpCodeHandler_EVEX_VHWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VK:
				reference = new OpCodeHandler_EVEX_VK(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case EvexOpCodeHandlerKind.Vk_VSIB:
				reference = new OpCodeHandler_EVEX_Vk_VSIB(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VkEv_REXW_2:
				reference = new OpCodeHandler_EVEX_VkEv_REXW(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case EvexOpCodeHandlerKind.VkEv_REXW_3:
				reference = new OpCodeHandler_EVEX_VkEv_REXW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadCode());
				return 1;
			case EvexOpCodeHandlerKind.VkHM:
				reference = new OpCodeHandler_EVEX_VkHM(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VkHW_3:
				reference = new OpCodeHandler_EVEX_VkHW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.VkHW_3b:
				reference = new OpCodeHandler_EVEX_VkHW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.VkHW_5:
				reference = new OpCodeHandler_EVEX_VkHW(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.VkHW_er_4:
				reference = new OpCodeHandler_EVEX_VkHW_er(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), deserializer.ReadBoolean(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.VkHW_er_4b:
				reference = new OpCodeHandler_EVEX_VkHW_er(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), deserializer.ReadBoolean(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.VkHW_er_ur_3:
				reference = new OpCodeHandler_EVEX_VkHW_er_ur(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.VkHW_er_ur_3b:
				reference = new OpCodeHandler_EVEX_VkHW_er_ur(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.VkHWIb_3:
				reference = new OpCodeHandler_EVEX_VkHWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.VkHWIb_3b:
				reference = new OpCodeHandler_EVEX_VkHWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.VkHWIb_5:
				reference = new OpCodeHandler_EVEX_VkHWIb(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.VkHWIb_er_4:
				reference = new OpCodeHandler_EVEX_VkHWIb_er(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.VkHWIb_er_4b:
				reference = new OpCodeHandler_EVEX_VkHWIb_er(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.VkM:
				reference = new OpCodeHandler_EVEX_VkM(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VkW_3:
				reference = new OpCodeHandler_EVEX_VkW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.VkW_3b:
				reference = new OpCodeHandler_EVEX_VkW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.VkW_4:
				reference = new OpCodeHandler_EVEX_VkW(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.VkW_4b:
				reference = new OpCodeHandler_EVEX_VkW(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.VkW_er_4:
				reference = new OpCodeHandler_EVEX_VkW_er(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), deserializer.ReadBoolean());
				return 1;
			case EvexOpCodeHandlerKind.VkW_er_5:
				reference = new OpCodeHandler_EVEX_VkW_er(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), deserializer.ReadBoolean());
				return 1;
			case EvexOpCodeHandlerKind.VkW_er_6:
				reference = new OpCodeHandler_EVEX_VkW_er(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), deserializer.ReadBoolean(), deserializer.ReadBoolean());
				return 1;
			case EvexOpCodeHandlerKind.VkWIb_3:
				reference = new OpCodeHandler_EVEX_VkWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: false);
				return 1;
			case EvexOpCodeHandlerKind.VkWIb_3b:
				reference = new OpCodeHandler_EVEX_VkWIb(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), canBroadcast: true);
				return 1;
			case EvexOpCodeHandlerKind.VkWIb_er:
				reference = new OpCodeHandler_EVEX_VkWIb_er(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VM:
				reference = new OpCodeHandler_EVEX_VM(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VSIB_k1:
				reference = new OpCodeHandler_EVEX_VSIB_k1(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VSIB_k1_VX:
				reference = new OpCodeHandler_EVEX_VSIB_k1_VX(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VW:
				reference = new OpCodeHandler_EVEX_VW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VW_er:
				reference = new OpCodeHandler_EVEX_VW_er(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.VX_Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_EVEX_VX_Ev(code, code + 1, deserializer.ReadTupleType(), deserializer.ReadTupleType());
				return 1;
			}
			case EvexOpCodeHandlerKind.WkHV:
				reference = new OpCodeHandler_EVEX_WkHV(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case EvexOpCodeHandlerKind.WkV_3:
				reference = new OpCodeHandler_EVEX_WkV(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.WkV_4a:
				reference = new OpCodeHandler_EVEX_WkV(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.WkV_4b:
				reference = new OpCodeHandler_EVEX_WkV(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType(), deserializer.ReadBoolean());
				return 1;
			case EvexOpCodeHandlerKind.WkVIb:
				reference = new OpCodeHandler_EVEX_WkVIb(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.WkVIb_er:
				reference = new OpCodeHandler_EVEX_WkVIb_er(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			case EvexOpCodeHandlerKind.WV:
				reference = new OpCodeHandler_EVEX_WV(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadTupleType());
				return 1;
			default:
				throw new InvalidOperationException();
			}
		}
	}
	[Flags]
	internal enum HandlerFlags : uint
	{
		None = 0u,
		Xacquire = 1u,
		Xrelease = 2u,
		XacquireXreleaseNoLock = 4u,
		Lock = 8u
	}
	[Flags]
	internal enum LegacyHandlerFlags : uint
	{
		HandlerReg = 1u,
		HandlerMem = 2u,
		Handler66Reg = 4u,
		Handler66Mem = 8u,
		HandlerF3Reg = 0x10u,
		HandlerF3Mem = 0x20u,
		HandlerF2Reg = 0x40u,
		HandlerF2Mem = 0x80u
	}
	internal enum LegacyOpCodeHandlerKind : byte
	{
		Bitness,
		Bitness_DontReadModRM,
		Invalid,
		Invalid_NoModRM,
		Invalid2,
		Dup,
		Null,
		HandlerReference,
		ArrayReference,
		RM,
		Options3,
		Options5,
		Options_DontReadModRM,
		AnotherTable,
		Group,
		Group8x64,
		Group8x8,
		MandatoryPrefix,
		MandatoryPrefix4,
		Ev_REXW_1a,
		MandatoryPrefix_NoModRM,
		MandatoryPrefix3,
		D3NOW,
		EVEX,
		VEX2,
		VEX3,
		XOP,
		AL_DX,
		Ap,
		B_BM,
		B_Ev,
		B_MIB,
		BM_B,
		BranchIw,
		BranchSimple,
		C_R_3a,
		C_R_3b,
		DX_AL,
		DX_eAX,
		eAX_DX,
		Eb_1,
		Eb_2,
		Eb_CL,
		Eb_Gb_1,
		Eb_Gb_2,
		Eb_Ib_1,
		Eb_Ib_2,
		Eb1,
		Ed_V_Ib,
		Ep,
		Ev_3a,
		Ev_3b,
		Ev_4,
		Ev_CL,
		Ev_Gv_32_64,
		Ev_Gv_3a,
		Ev_Gv_3b,
		Ev_Gv_4,
		Ev_Gv_CL,
		Ev_Gv_Ib,
		Ev_Gv_REX,
		Ev_Ib_3,
		Ev_Ib_4,
		Ev_Ib2_3,
		Ev_Ib2_4,
		Ev_Iz_3,
		Ev_Iz_4,
		Ev_P,
		Ev_REXW,
		Ev_Sw,
		Ev_VX,
		Ev1,
		Evj,
		Evw,
		Ew,
		Gb_Eb,
		Gdq_Ev,
		Gv_Eb,
		Gv_Eb_REX,
		Gv_Ev_32_64,
		Gv_Ev_3a,
		Gv_Ev_3b,
		Gv_Ev_Ib,
		Gv_Ev_Ib_REX,
		Gv_Ev_Iz,
		Gv_Ev_REX,
		Gv_Ev2,
		Gv_Ev3,
		Gv_Ew,
		Gv_M,
		Gv_M_as,
		Gv_Ma,
		Gv_Mp_2,
		Gv_Mp_3,
		Gv_Mv,
		Gv_N,
		Gv_N_Ib_REX,
		Gv_RX,
		Gv_W,
		GvM_VX_Ib,
		Ib,
		Ib3,
		IbReg,
		IbReg2,
		Iw_Ib,
		Jb,
		Jb2,
		Jdisp,
		Jx,
		Jz,
		M_1,
		M_2,
		M_REXW_2,
		M_REXW_4,
		MemBx,
		Mf_1,
		Mf_2a,
		Mf_2b,
		MIB_B,
		MP,
		Ms,
		MV,
		Mv_Gv,
		Mv_Gv_REXW,
		NIb,
		Ob_Reg,
		Ov_Reg,
		P_Ev,
		P_Ev_Ib,
		P_Q,
		P_Q_Ib,
		P_R,
		P_W,
		PushEv,
		PushIb2,
		PushIz,
		PushOpSizeReg_4a,
		PushOpSizeReg_4b,
		PushSimple2,
		PushSimpleReg,
		Q_P,
		R_C_3a,
		R_C_3b,
		rDI_P_N,
		rDI_VX_RX,
		Reg,
		Reg_Ib2,
		Reg_Iz,
		Reg_Ob,
		Reg_Ov,
		Reg_Xb,
		Reg_Xv,
		Reg_Xv2,
		Reg_Yb,
		Reg_Yv,
		RegIb,
		RegIb3,
		RegIz2,
		Reservednop,
		RIb,
		RIbIb,
		Rv,
		Rv_32_64,
		RvMw_Gw,
		Simple,
		Simple_ModRM,
		Simple2_3a,
		Simple2_3b,
		Simple2Iw,
		Simple3,
		Simple4,
		Simple5,
		Simple5_ModRM_as,
		SimpleReg,
		ST_STi,
		STi,
		STi_ST,
		Sw_Ev,
		V_Ev,
		VM,
		VN,
		VQ,
		VRIbIb,
		VW_2,
		VW_3,
		VWIb_2,
		VWIb_3,
		VX_E_Ib,
		VX_Ev,
		Wbinvd,
		WV,
		Xb_Yb,
		Xchg_Reg_rAX,
		Xv_Yv,
		Yb_Reg,
		Yb_Xb,
		Yv_Reg,
		Yv_Reg2,
		Yv_Xv,
		Simple4b,
		Options1632_1,
		Options1632_2,
		M_Sw,
		Sw_M,
		Rq,
		Gd_Rd,
		PrefixEsCsSsDs,
		PrefixFsGs,
		Prefix66,
		Prefix67,
		PrefixF0,
		PrefixF2,
		PrefixF3,
		PrefixREX,
		Simple5_a32
	}
	internal sealed class LegacyOpCodeHandlerReader : OpCodeHandlerReader
	{
		public override int ReadHandlers(ref TableDeserializer deserializer, OpCodeHandler?[] result, int resultIndex)
		{
			ref OpCodeHandler reference = ref result[resultIndex];
			switch (deserializer.ReadLegacyOpCodeHandlerKind())
			{
			case LegacyOpCodeHandlerKind.Bitness:
				reference = new OpCodeHandler_Bitness(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case LegacyOpCodeHandlerKind.Bitness_DontReadModRM:
				reference = new OpCodeHandler_Bitness_DontReadModRM(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case LegacyOpCodeHandlerKind.Invalid:
				reference = OpCodeHandler_Invalid.Instance;
				return 1;
			case LegacyOpCodeHandlerKind.Invalid_NoModRM:
				reference = OpCodeHandler_Invalid_NoModRM.Instance;
				return 1;
			case LegacyOpCodeHandlerKind.Invalid2:
				result[resultIndex] = OpCodeHandler_Invalid.Instance;
				result[resultIndex + 1] = OpCodeHandler_Invalid.Instance;
				return 2;
			case LegacyOpCodeHandlerKind.Dup:
			{
				int num = deserializer.ReadInt32();
				OpCodeHandler opCodeHandler = deserializer.ReadHandlerOrNull();
				for (int i = 0; i < num; i++)
				{
					result[resultIndex + i] = opCodeHandler;
				}
				return num;
			}
			case LegacyOpCodeHandlerKind.Null:
				reference = null;
				return 1;
			case LegacyOpCodeHandlerKind.HandlerReference:
				reference = deserializer.ReadHandlerReference();
				return 1;
			case LegacyOpCodeHandlerKind.ArrayReference:
				throw new InvalidOperationException();
			case LegacyOpCodeHandlerKind.RM:
				reference = new OpCodeHandler_RM(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case LegacyOpCodeHandlerKind.Options1632_1:
				reference = new OpCodeHandler_Options1632(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadDecoderOptions());
				return 1;
			case LegacyOpCodeHandlerKind.Options1632_2:
				reference = new OpCodeHandler_Options1632(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadDecoderOptions(), deserializer.ReadHandler(), deserializer.ReadDecoderOptions());
				return 1;
			case LegacyOpCodeHandlerKind.Options3:
				reference = new OpCodeHandler_Options(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadDecoderOptions());
				return 1;
			case LegacyOpCodeHandlerKind.Options5:
				reference = new OpCodeHandler_Options(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadDecoderOptions(), deserializer.ReadHandler(), deserializer.ReadDecoderOptions());
				return 1;
			case LegacyOpCodeHandlerKind.Options_DontReadModRM:
				reference = new OpCodeHandler_Options_DontReadModRM(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadDecoderOptions());
				return 1;
			case LegacyOpCodeHandlerKind.AnotherTable:
				reference = new OpCodeHandler_AnotherTable(deserializer.ReadArrayReference(8u));
				return 1;
			case LegacyOpCodeHandlerKind.Group:
				reference = new OpCodeHandler_Group(deserializer.ReadArrayReference(8u));
				return 1;
			case LegacyOpCodeHandlerKind.Group8x64:
				reference = new OpCodeHandler_Group8x64(deserializer.ReadArrayReference(8u), deserializer.ReadArrayReference(8u));
				return 1;
			case LegacyOpCodeHandlerKind.Group8x8:
				reference = new OpCodeHandler_Group8x8(deserializer.ReadArrayReference(8u), deserializer.ReadArrayReference(8u));
				return 1;
			case LegacyOpCodeHandlerKind.MandatoryPrefix:
				reference = new OpCodeHandler_MandatoryPrefix(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case LegacyOpCodeHandlerKind.MandatoryPrefix4:
				reference = new OpCodeHandler_MandatoryPrefix4(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), (uint)deserializer.ReadInt32());
				return 1;
			case LegacyOpCodeHandlerKind.MandatoryPrefix_NoModRM:
				reference = new OpCodeHandler_MandatoryPrefix_NoModRM(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case LegacyOpCodeHandlerKind.MandatoryPrefix3:
				reference = new OpCodeHandler_MandatoryPrefix3(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadLegacyHandlerFlags());
				return 1;
			case LegacyOpCodeHandlerKind.D3NOW:
				reference = new OpCodeHandler_D3NOW();
				return 1;
			case LegacyOpCodeHandlerKind.EVEX:
				reference = new OpCodeHandler_EVEX(deserializer.ReadHandler());
				return 1;
			case LegacyOpCodeHandlerKind.VEX2:
				reference = new OpCodeHandler_VEX2(deserializer.ReadHandler());
				return 1;
			case LegacyOpCodeHandlerKind.VEX3:
				reference = new OpCodeHandler_VEX3(deserializer.ReadHandler());
				return 1;
			case LegacyOpCodeHandlerKind.XOP:
				reference = new OpCodeHandler_XOP(deserializer.ReadHandler());
				return 1;
			case LegacyOpCodeHandlerKind.AL_DX:
				reference = new OpCodeHandler_AL_DX(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Ap:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ap(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.B_BM:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_B_BM(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.B_Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_B_Ev(code, code + 1, deserializer.ReadBoolean());
				return 1;
			}
			case LegacyOpCodeHandlerKind.B_MIB:
				reference = new OpCodeHandler_B_MIB(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.BM_B:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_BM_B(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.BranchIw:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_BranchIw(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.BranchSimple:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_BranchSimple(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.C_R_3a:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_C_R(code, code + 1, deserializer.ReadRegister());
				return 1;
			}
			case LegacyOpCodeHandlerKind.C_R_3b:
				reference = new OpCodeHandler_C_R(deserializer.ReadCode(), Code.INVALID, deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.DX_AL:
				reference = new OpCodeHandler_DX_AL(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.DX_eAX:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_DX_eAX(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.eAX_DX:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_eAX_DX(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Eb_1:
				reference = new OpCodeHandler_Eb(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Eb_2:
				reference = new OpCodeHandler_Eb(deserializer.ReadCode(), deserializer.ReadHandlerFlags());
				return 1;
			case LegacyOpCodeHandlerKind.Eb_CL:
				reference = new OpCodeHandler_Eb_CL(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Eb_Gb_1:
				reference = new OpCodeHandler_Eb_Gb(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Eb_Gb_2:
				reference = new OpCodeHandler_Eb_Gb(deserializer.ReadCode(), deserializer.ReadHandlerFlags());
				return 1;
			case LegacyOpCodeHandlerKind.Eb_Ib_1:
				reference = new OpCodeHandler_Eb_Ib(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Eb_Ib_2:
				reference = new OpCodeHandler_Eb_Ib(deserializer.ReadCode(), deserializer.ReadHandlerFlags());
				return 1;
			case LegacyOpCodeHandlerKind.Eb1:
				reference = new OpCodeHandler_Eb_1(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Ed_V_Ib:
			{
				Code code;
				reference = new OpCodeHandler_Ed_V_Ib(code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ep:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ep(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_3a:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_3b:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev(code, code + 1, Code.INVALID);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_4:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev(code, code + 1, code + 2, deserializer.ReadHandlerFlags());
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_CL:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_CL(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Gv_32_64:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Gv_32_64(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Gv_3a:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Gv(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Gv_3b:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Gv(code, code + 1, Code.INVALID);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Gv_4:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Gv(code, code + 1, code + 2, deserializer.ReadHandlerFlags());
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Gv_CL:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Gv_CL(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Gv_Ib:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Gv_Ib(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Gv_REX:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Gv_REX(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Ib_3:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Ib(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Ib_4:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Ib(code, code + 1, code + 2, deserializer.ReadHandlerFlags());
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Ib2_3:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Ib2(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Ib2_4:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Ib2(code, code + 1, code + 2, deserializer.ReadHandlerFlags());
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Iz_3:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Iz(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Iz_4:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Iz(code, code + 1, code + 2, deserializer.ReadHandlerFlags());
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_P:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_P(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_REXW_1a:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_REXW(code, Code.INVALID, (uint)deserializer.ReadInt32());
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_REXW:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_REXW(code, code + 1, (uint)deserializer.ReadInt32());
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_Sw:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_Sw(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev_VX:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_VX(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ev1:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ev_1(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Evj:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Evj(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Evw:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Evw(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ew:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ew(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gb_Eb:
				reference = new OpCodeHandler_Gb_Eb(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Gdq_Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gdq_Ev(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Eb:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Eb(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Eb_REX:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Eb_REX(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ev_32_64:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Ev_32_64(code, code + 1, deserializer.ReadBoolean(), deserializer.ReadBoolean());
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ev_3a:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Ev(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ev_3b:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Ev(code, code + 1, Code.INVALID);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ev_Ib:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Ev_Ib(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ev_Ib_REX:
			{
				Code code;
				reference = new OpCodeHandler_Gv_Ev_Ib_REX(code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ev_Iz:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Ev_Iz(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ev_REX:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Ev_REX(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ev2:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Ev2(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ev3:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Ev3(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ew:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Ew(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_M:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_M(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_M_as:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_M_as(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Ma:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Ma(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Mp_2:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Mp(code, code + 1, Code.INVALID);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Mp_3:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Mp(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_Mv:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_Mv(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_N:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_N(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_N_Ib_REX:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Gv_N_Ib_REX(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_RX:
			{
				Code code;
				reference = new OpCodeHandler_Gv_RX(code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Gv_W:
			{
				Code code;
				reference = new OpCodeHandler_Gv_W(code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.GvM_VX_Ib:
			{
				Code code;
				reference = new OpCodeHandler_GvM_VX_Ib(code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Ib:
				reference = new OpCodeHandler_Ib(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Ib3:
				reference = new OpCodeHandler_Ib3(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.IbReg:
				reference = new OpCodeHandler_IbReg(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.IbReg2:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_IbReg2(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Iw_Ib:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Iw_Ib(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Jb:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Jb(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Jb2:
				reference = new OpCodeHandler_Jb2(deserializer.ReadCode(), deserializer.ReadCode(), deserializer.ReadCode(), deserializer.ReadCode(), deserializer.ReadCode(), deserializer.ReadCode(), deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Jdisp:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Jdisp(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Jx:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Jx(code, code + 1, deserializer.ReadCode());
				return 1;
			}
			case LegacyOpCodeHandlerKind.Jz:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Jz(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.M_1:
				reference = new OpCodeHandler_M(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.M_2:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_M(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.M_REXW_2:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_M_REXW(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.M_REXW_4:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_M_REXW(code, code + 1, deserializer.ReadHandlerFlags(), deserializer.ReadHandlerFlags());
				return 1;
			}
			case LegacyOpCodeHandlerKind.MemBx:
				reference = new OpCodeHandler_MemBx(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Mf_1:
				reference = new OpCodeHandler_Mf(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Mf_2a:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Mf(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Mf_2b:
				reference = new OpCodeHandler_Mf(deserializer.ReadCode(), deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.MIB_B:
				reference = new OpCodeHandler_MIB_B(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.MP:
				reference = new OpCodeHandler_MP(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Ms:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ms(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.MV:
				reference = new OpCodeHandler_MV(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Mv_Gv:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Mv_Gv(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Mv_Gv_REXW:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Mv_Gv_REXW(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.NIb:
				reference = new OpCodeHandler_NIb(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Ob_Reg:
				reference = new OpCodeHandler_Ob_Reg(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.Ov_Reg:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Ov_Reg(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.P_Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_P_Ev(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.P_Ev_Ib:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_P_Ev_Ib(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.P_Q:
				reference = new OpCodeHandler_P_Q(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.P_Q_Ib:
				reference = new OpCodeHandler_P_Q_Ib(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.P_R:
				reference = new OpCodeHandler_P_R(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.P_W:
				reference = new OpCodeHandler_P_W(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.PushEv:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_PushEv(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.PushIb2:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_PushIb2(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.PushIz:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_PushIz(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.PushOpSizeReg_4a:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_PushOpSizeReg(code, code + 1, code + 2, deserializer.ReadRegister());
				return 1;
			}
			case LegacyOpCodeHandlerKind.PushOpSizeReg_4b:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_PushOpSizeReg(code, code + 1, Code.INVALID, deserializer.ReadRegister());
				return 1;
			}
			case LegacyOpCodeHandlerKind.PushSimple2:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_PushSimple2(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.PushSimpleReg:
			{
				Code code;
				reference = new OpCodeHandler_PushSimpleReg(deserializer.ReadInt32(), code = deserializer.ReadCode(), code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Q_P:
				reference = new OpCodeHandler_Q_P(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.R_C_3a:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_R_C(code, code + 1, deserializer.ReadRegister());
				return 1;
			}
			case LegacyOpCodeHandlerKind.R_C_3b:
				reference = new OpCodeHandler_R_C(deserializer.ReadCode(), Code.INVALID, deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.rDI_P_N:
				reference = new OpCodeHandler_rDI_P_N(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.rDI_VX_RX:
				reference = new OpCodeHandler_rDI_VX_RX(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Reg:
				reference = new OpCodeHandler_Reg(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.Reg_Ib2:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Reg_Ib2(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Reg_Iz:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Reg_Iz(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Reg_Ob:
				reference = new OpCodeHandler_Reg_Ob(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.Reg_Ov:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Reg_Ov(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Reg_Xb:
				reference = new OpCodeHandler_Reg_Xb(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.Reg_Xv:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Reg_Xv(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Reg_Xv2:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Reg_Xv2(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Reg_Yb:
				reference = new OpCodeHandler_Reg_Yb(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.Reg_Yv:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Reg_Yv(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.RegIb:
				reference = new OpCodeHandler_RegIb(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.RegIb3:
				reference = new OpCodeHandler_RegIb3(deserializer.ReadInt32());
				return 1;
			case LegacyOpCodeHandlerKind.RegIz2:
				reference = new OpCodeHandler_RegIz2(deserializer.ReadInt32());
				return 1;
			case LegacyOpCodeHandlerKind.Reservednop:
				reference = new OpCodeHandler_Reservednop(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case LegacyOpCodeHandlerKind.RIb:
				reference = new OpCodeHandler_RIb(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.RIbIb:
				reference = new OpCodeHandler_RIbIb(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Rv:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Rv(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Rv_32_64:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Rv_32_64(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.RvMw_Gw:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_RvMw_Gw(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Simple:
				reference = new OpCodeHandler_Simple(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Simple_ModRM:
				reference = new OpCodeHandler_Simple_ModRM(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Simple2_3a:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Simple2(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Simple2_3b:
				reference = new OpCodeHandler_Simple2(deserializer.ReadCode(), deserializer.ReadCode(), deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Simple2Iw:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Simple2Iw(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Simple3:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Simple3(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Simple4:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Simple4(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Simple4b:
			{
				Code code = deserializer.ReadCode();
				Code code2 = deserializer.ReadCode();
				reference = new OpCodeHandler_Simple4(code, code2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Simple5:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Simple5(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Simple5_a32:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Simple5_a32(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Simple5_ModRM_as:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Simple5_ModRM_as(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.SimpleReg:
				reference = new OpCodeHandler_SimpleReg(deserializer.ReadCode(), deserializer.ReadInt32());
				return 1;
			case LegacyOpCodeHandlerKind.ST_STi:
				reference = new OpCodeHandler_ST_STi(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.STi:
				reference = new OpCodeHandler_STi(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.STi_ST:
				reference = new OpCodeHandler_STi_ST(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Sw_Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Sw_Ev(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.V_Ev:
			{
				Code code;
				reference = new OpCodeHandler_V_Ev(code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.VM:
				reference = new OpCodeHandler_VM(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.VN:
				reference = new OpCodeHandler_VN(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.VQ:
				reference = new OpCodeHandler_VQ(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.VRIbIb:
				reference = new OpCodeHandler_VRIbIb(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.VW_2:
				reference = new OpCodeHandler_VW(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.VW_3:
				reference = new OpCodeHandler_VW(deserializer.ReadCode(), deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.VWIb_2:
				reference = new OpCodeHandler_VWIb(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.VWIb_3:
			{
				Code code;
				reference = new OpCodeHandler_VWIb(code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.VX_E_Ib:
			{
				Code code;
				reference = new OpCodeHandler_VX_E_Ib(code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.VX_Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VX_Ev(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Wbinvd:
				reference = new OpCodeHandler_Wbinvd();
				return 1;
			case LegacyOpCodeHandlerKind.WV:
				reference = new OpCodeHandler_WV(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Xb_Yb:
				reference = new OpCodeHandler_Xb_Yb(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Xchg_Reg_rAX:
				reference = new OpCodeHandler_Xchg_Reg_rAX(deserializer.ReadInt32());
				return 1;
			case LegacyOpCodeHandlerKind.Xv_Yv:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Xv_Yv(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Yb_Reg:
				reference = new OpCodeHandler_Yb_Reg(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.Yb_Xb:
				reference = new OpCodeHandler_Yb_Xb(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Yv_Reg:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Yv_Reg(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Yv_Reg2:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Yv_Reg2(code, code + 1);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Yv_Xv:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Yv_Xv(code, code + 1, code + 2);
				return 1;
			}
			case LegacyOpCodeHandlerKind.M_Sw:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_M_Sw(code);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Sw_M:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_Sw_M(code);
				return 1;
			}
			case LegacyOpCodeHandlerKind.Rq:
				reference = new OpCodeHandler_Rq(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.Gd_Rd:
				reference = new OpCodeHandler_Gd_Rd(deserializer.ReadCode());
				return 1;
			case LegacyOpCodeHandlerKind.PrefixEsCsSsDs:
				reference = new OpCodeHandler_PrefixEsCsSsDs(deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.PrefixFsGs:
				reference = new OpCodeHandler_PrefixFsGs(deserializer.ReadRegister());
				return 1;
			case LegacyOpCodeHandlerKind.Prefix66:
				reference = new OpCodeHandler_Prefix66();
				return 1;
			case LegacyOpCodeHandlerKind.Prefix67:
				reference = new OpCodeHandler_Prefix67();
				return 1;
			case LegacyOpCodeHandlerKind.PrefixF0:
				reference = new OpCodeHandler_PrefixF0();
				return 1;
			case LegacyOpCodeHandlerKind.PrefixF2:
				reference = new OpCodeHandler_PrefixF2();
				return 1;
			case LegacyOpCodeHandlerKind.PrefixF3:
				reference = new OpCodeHandler_PrefixF3();
				return 1;
			case LegacyOpCodeHandlerKind.PrefixREX:
				reference = new OpCodeHandler_PrefixREX(deserializer.ReadHandler(), (uint)deserializer.ReadInt32());
				return 1;
			default:
				throw new InvalidOperationException();
			}
		}
	}
	internal abstract class OpCodeHandler
	{
		public readonly bool HasModRM;

		protected OpCodeHandler()
		{
		}

		protected OpCodeHandler(bool hasModRM)
		{
			HasModRM = hasModRM;
		}

		public abstract void Decode(Decoder decoder, ref Instruction instruction);
	}
	internal abstract class OpCodeHandlerModRM : OpCodeHandler
	{
		protected OpCodeHandlerModRM()
			: base(hasModRM: true)
		{
		}
	}
	internal sealed class OpCodeHandler_Invalid : OpCodeHandlerModRM
	{
		public static readonly OpCodeHandler_Invalid Instance = new OpCodeHandler_Invalid();

		private OpCodeHandler_Invalid()
		{
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.SetInvalidInstruction();
		}
	}
	internal sealed class OpCodeHandler_Invalid_NoModRM : OpCodeHandler
	{
		public static readonly OpCodeHandler_Invalid_NoModRM Instance = new OpCodeHandler_Invalid_NoModRM();

		private OpCodeHandler_Invalid_NoModRM()
		{
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.SetInvalidInstruction();
		}
	}
	internal sealed class OpCodeHandler_Simple : OpCodeHandler
	{
		private readonly Code code;

		public OpCodeHandler_Simple(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
		}
	}
	internal sealed class OpCodeHandler_Simple_ModRM : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_Simple_ModRM(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
		}
	}
	internal sealed class OpCodeHandler_Group8x8 : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler[] tableLow;

		private readonly OpCodeHandler[] tableHigh;

		public OpCodeHandler_Group8x8(OpCodeHandler[] tableLow, OpCodeHandler[] tableHigh)
		{
			if (tableLow.Length != 8)
			{
				throw new ArgumentOutOfRangeException("tableLow");
			}
			if (tableHigh.Length != 8)
			{
				throw new ArgumentOutOfRangeException("tableHigh");
			}
			this.tableLow = tableLow;
			this.tableHigh = tableHigh;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			OpCodeHandler opCodeHandler = ((decoder.state.mod != 3) ? tableLow[decoder.state.reg] : tableHigh[decoder.state.reg]);
			opCodeHandler.Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Group8x64 : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler[] tableLow;

		private readonly OpCodeHandler[] tableHigh;

		public OpCodeHandler_Group8x64(OpCodeHandler[] tableLow, OpCodeHandler?[] tableHigh)
		{
			if (tableLow.Length != 8)
			{
				throw new ArgumentOutOfRangeException("tableLow");
			}
			if (tableHigh.Length != 64)
			{
				throw new ArgumentOutOfRangeException("tableHigh");
			}
			this.tableLow = tableLow;
			this.tableHigh = tableHigh;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			OpCodeHandler opCodeHandler = ((decoder.state.mod != 3) ? tableLow[decoder.state.reg] : (tableHigh[decoder.state.modrm & 0x3F] ?? tableLow[decoder.state.reg]));
			opCodeHandler.Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Group : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler[] groupHandlers;

		public OpCodeHandler_Group(OpCodeHandler[] groupHandlers)
		{
			this.groupHandlers = groupHandlers ?? throw new ArgumentNullException("groupHandlers");
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			groupHandlers[decoder.state.reg].Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_AnotherTable : OpCodeHandler
	{
		private readonly OpCodeHandler[] otherTable;

		public OpCodeHandler_AnotherTable(OpCodeHandler[] otherTable)
		{
			this.otherTable = otherTable ?? throw new ArgumentNullException("otherTable");
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.DecodeTable(otherTable, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_MandatoryPrefix2 : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler[] handlers;

		public OpCodeHandler_MandatoryPrefix2(OpCodeHandler handler)
			: this(handler, OpCodeHandler_Invalid.Instance, OpCodeHandler_Invalid.Instance, OpCodeHandler_Invalid.Instance)
		{
		}

		public OpCodeHandler_MandatoryPrefix2(OpCodeHandler handler, OpCodeHandler handler66, OpCodeHandler handlerF3, OpCodeHandler handlerF2)
		{
			handlers = new OpCodeHandler[4]
			{
				handler ?? throw new ArgumentNullException("handler"),
				handler66 ?? throw new ArgumentNullException("handler66"),
				handlerF3 ?? throw new ArgumentNullException("handlerF3"),
				handlerF2 ?? throw new ArgumentNullException("handlerF2")
			};
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			handlers[(uint)decoder.state.zs.mandatoryPrefix].Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_MandatoryPrefix2_NoModRM : OpCodeHandler
	{
		private readonly OpCodeHandler[] handlers;

		public OpCodeHandler_MandatoryPrefix2_NoModRM(OpCodeHandler handler, OpCodeHandler handler66, OpCodeHandler handlerF3, OpCodeHandler handlerF2)
		{
			handlers = new OpCodeHandler[4]
			{
				handler ?? throw new ArgumentNullException("handler"),
				handler66 ?? throw new ArgumentNullException("handler66"),
				handlerF3 ?? throw new ArgumentNullException("handlerF3"),
				handlerF2 ?? throw new ArgumentNullException("handlerF2")
			};
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			handlers[(uint)decoder.state.zs.mandatoryPrefix].Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_W : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler handlerW0;

		private readonly OpCodeHandler handlerW1;

		public OpCodeHandler_W(OpCodeHandler handlerW0, OpCodeHandler handlerW1)
		{
			this.handlerW0 = handlerW0 ?? throw new ArgumentNullException("handlerW0");
			this.handlerW1 = handlerW1 ?? throw new ArgumentNullException("handlerW1");
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			(((decoder.state.zs.flags & StateFlags.W) != 0) ? handlerW1 : handlerW0).Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Bitness : OpCodeHandler
	{
		private readonly OpCodeHandler handler1632;

		private readonly OpCodeHandler handler64;

		public OpCodeHandler_Bitness(OpCodeHandler handler1632, OpCodeHandler handler64)
		{
			this.handler1632 = handler1632;
			this.handler64 = handler64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			OpCodeHandler opCodeHandler = ((!decoder.is64bMode) ? handler1632 : handler64);
			if (opCodeHandler.HasModRM)
			{
				decoder.ReadModRM();
			}
			opCodeHandler.Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Bitness_DontReadModRM : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler handler1632;

		private readonly OpCodeHandler handler64;

		public OpCodeHandler_Bitness_DontReadModRM(OpCodeHandler handler1632, OpCodeHandler handler64)
		{
			this.handler1632 = handler1632;
			this.handler64 = handler64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			OpCodeHandler opCodeHandler = ((!decoder.is64bMode) ? handler1632 : handler64);
			opCodeHandler.Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_RM : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler reg;

		private readonly OpCodeHandler mem;

		public OpCodeHandler_RM(OpCodeHandler reg, OpCodeHandler mem)
		{
			this.reg = reg ?? throw new ArgumentNullException("reg");
			this.mem = mem ?? throw new ArgumentNullException("mem");
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			((decoder.state.mod == 3) ? reg : mem).Decode(decoder, ref instruction);
		}
	}
	internal readonly struct HandlerOptions
	{
		public readonly OpCodeHandler handler;

		public readonly DecoderOptions options;

		public HandlerOptions(OpCodeHandler handler, DecoderOptions options)
		{
			this.handler = handler;
			this.options = options;
		}
	}
	internal sealed class OpCodeHandler_Options1632 : OpCodeHandler
	{
		private readonly OpCodeHandler defaultHandler;

		private readonly HandlerOptions[] infos;

		private readonly DecoderOptions infoOptions;

		public OpCodeHandler_Options1632(OpCodeHandler defaultHandler, OpCodeHandler handler1, DecoderOptions options1)
		{
			this.defaultHandler = defaultHandler ?? throw new ArgumentNullException("defaultHandler");
			infos = new HandlerOptions[1]
			{
				new HandlerOptions(handler1, options1)
			};
			infoOptions = options1;
		}

		public OpCodeHandler_Options1632(OpCodeHandler defaultHandler, OpCodeHandler handler1, DecoderOptions options1, OpCodeHandler handler2, DecoderOptions options2)
		{
			this.defaultHandler = defaultHandler ?? throw new ArgumentNullException("defaultHandler");
			infos = new HandlerOptions[2]
			{
				new HandlerOptions(handler1 ?? throw new ArgumentNullException("handler1"), options1),
				new HandlerOptions(handler2 ?? throw new ArgumentNullException("handler2"), options2)
			};
			infoOptions = options1 | options2;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			OpCodeHandler handler = defaultHandler;
			DecoderOptions options = decoder.options;
			if (!decoder.is64bMode && (decoder.options & infoOptions) != DecoderOptions.None)
			{
				HandlerOptions[] array = infos;
				for (int i = 0; i < array.Length; i++)
				{
					HandlerOptions handlerOptions = array[i];
					if ((options & handlerOptions.options) != DecoderOptions.None)
					{
						handler = handlerOptions.handler;
						break;
					}
				}
			}
			if (handler.HasModRM)
			{
				decoder.ReadModRM();
			}
			handler.Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Options : OpCodeHandler
	{
		private readonly OpCodeHandler defaultHandler;

		private readonly HandlerOptions[] infos;

		private readonly DecoderOptions infoOptions;

		public OpCodeHandler_Options(OpCodeHandler defaultHandler, OpCodeHandler handler1, DecoderOptions options1)
		{
			this.defaultHandler = defaultHandler ?? throw new ArgumentNullException("defaultHandler");
			infos = new HandlerOptions[1]
			{
				new HandlerOptions(handler1, options1)
			};
			infoOptions = options1;
		}

		public OpCodeHandler_Options(OpCodeHandler defaultHandler, OpCodeHandler handler1, DecoderOptions options1, OpCodeHandler handler2, DecoderOptions options2)
		{
			this.defaultHandler = defaultHandler ?? throw new ArgumentNullException("defaultHandler");
			infos = new HandlerOptions[2]
			{
				new HandlerOptions(handler1 ?? throw new ArgumentNullException("handler1"), options1),
				new HandlerOptions(handler2 ?? throw new ArgumentNullException("handler2"), options2)
			};
			infoOptions = options1 | options2;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			OpCodeHandler handler = defaultHandler;
			DecoderOptions options = decoder.options;
			if ((decoder.options & infoOptions) != DecoderOptions.None)
			{
				HandlerOptions[] array = infos;
				for (int i = 0; i < array.Length; i++)
				{
					HandlerOptions handlerOptions = array[i];
					if ((options & handlerOptions.options) != DecoderOptions.None)
					{
						handler = handlerOptions.handler;
						break;
					}
				}
			}
			if (handler.HasModRM)
			{
				decoder.ReadModRM();
			}
			handler.Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Options_DontReadModRM : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler defaultHandler;

		private readonly HandlerOptions[] infos;

		public OpCodeHandler_Options_DontReadModRM(OpCodeHandler defaultHandler, OpCodeHandler handler1, DecoderOptions options1)
		{
			this.defaultHandler = defaultHandler ?? throw new ArgumentNullException("defaultHandler");
			infos = new HandlerOptions[1]
			{
				new HandlerOptions(handler1, options1)
			};
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			OpCodeHandler handler = defaultHandler;
			DecoderOptions options = decoder.options;
			HandlerOptions[] array = infos;
			for (int i = 0; i < array.Length; i++)
			{
				HandlerOptions handlerOptions = array[i];
				if ((options & handlerOptions.options) != DecoderOptions.None)
				{
					handler = handlerOptions.handler;
					break;
				}
			}
			handler.Decode(decoder, ref instruction);
		}
	}
	internal static class OpCodeHandlersTables_EVEX
	{
		internal static readonly OpCodeHandler[] Handlers_0F;

		internal static readonly OpCodeHandler[] Handlers_0F38;

		internal static readonly OpCodeHandler[] Handlers_0F3A;

		internal static readonly OpCodeHandler[] Handlers_MAP5;

		internal static readonly OpCodeHandler[] Handlers_MAP6;

		private const int MaxIdNames = 10;

		private const uint Handlers_0FIndex = 9u;

		private const uint Handlers_0F38Index = 5u;

		private const uint Handlers_0F3AIndex = 6u;

		private const uint Handlers_MAP5Index = 7u;

		private const uint Handlers_MAP6Index = 8u;

		static OpCodeHandlersTables_EVEX()
		{
			EvexOpCodeHandlerReader handlerReader = new EvexOpCodeHandlerReader();
			TableDeserializer tableDeserializer = new TableDeserializer(handlerReader, 10, GetSerializedTables());
			tableDeserializer.Deserialize();
			Handlers_0F = tableDeserializer.GetTable(9u);
			Handlers_0F38 = tableDeserializer.GetTable(5u);
			Handlers_0F3A = tableDeserializer.GetTable(6u);
			Handlers_MAP5 = tableDeserializer.GetTable(7u);
			Handlers_MAP6 = tableDeserializer.GetTable(8u);
		}

		private static ReadOnlySpan<byte> GetSerializedTables()
		{
			return new byte[12430]
			{
				1, 8, 1, 8, 0, 9, 16, 77, 227, 12,
				4, 16, 109, 228, 12, 5, 16, 141, 229, 12,
				6, 0, 0, 0, 8, 0, 9, 16, 77, 234,
				12, 4, 16, 109, 235, 12, 5, 16, 141, 236,
				12, 6, 0, 0, 0, 8, 0, 9, 16, 77,
				241, 12, 4, 16, 109, 242, 12, 5, 16, 141,
				243, 12, 6, 0, 0, 0, 1, 8, 8, 0,
				7, 9, 17, 77, 244, 12, 8, 17, 109, 245,
				12, 9, 17, 141, 246, 12, 10, 9, 17, 77,
				247, 12, 11, 17, 109, 248, 12, 12, 17, 141,
				249, 12, 13, 0, 0, 8, 0, 7, 9, 17,
				77, 250, 12, 8, 17, 109, 251, 12, 9, 17,
				141, 252, 12, 10, 9, 17, 77, 253, 12, 11,
				17, 109, 254, 12, 12, 17, 141, 255, 12, 13,
				0, 0, 8, 0, 7, 9, 17, 77, 132, 13,
				8, 17, 109, 133, 13, 9, 17, 141, 134, 13,
				10, 0, 0, 0, 0, 8, 0, 7, 9, 17,
				77, 139, 13, 8, 17, 109, 140, 13, 9, 17,
				141, 141, 13, 10, 9, 17, 77, 142, 13, 11,
				17, 109, 143, 13, 12, 17, 141, 144, 13, 13,
				0, 0, 0, 8, 0, 7, 9, 17, 77, 149,
				13, 8, 17, 109, 150, 13, 9, 17, 141, 151,
				13, 10, 0, 0, 0, 0, 1, 8, 1, 8,
				0, 7, 0, 9, 17, 77, 156, 13, 11, 17,
				109, 157, 13, 12, 17, 141, 158, 13, 13, 0,
				0, 8, 0, 9, 18, 77, 162, 13, 4, 18,
				109, 163, 13, 5, 18, 141, 164, 13, 6, 0,
				0, 1, 8, 0, 7, 0, 9, 17, 77, 169,
				13, 11, 17, 109, 170, 13, 12, 17, 141, 171,
				13, 13, 0, 0, 8, 0, 9, 18, 77, 175,
				13, 4, 18, 109, 176, 13, 5, 18, 141, 177,
				13, 6, 0, 0, 1, 8, 0, 8, 0, 7,
				9, 0, 0, 63, 141, 140, 28, 2, 9, 0,
				0, 63, 109, 141, 28, 3, 0, 0, 8, 0,
				7, 9, 0, 0, 63, 141, 142, 28, 2, 9,
				0, 0, 63, 109, 143, 28, 3, 0, 0, 1,
				8, 0, 7, 9, 0, 0, 63, 141, 144, 28,
				2, 9, 0, 0, 63, 109, 145, 28, 3, 0,
				0, 8, 0, 7, 9, 0, 0, 63, 141, 146,
				28, 2, 9, 0, 0, 63, 109, 147, 28, 3,
				0, 0, 0, 1, 8, 0, 8, 0, 7, 9,
				0, 0, 63, 141, 148, 28, 2, 9, 0, 0,
				63, 141, 149, 28, 3, 0, 0, 8, 0, 7,
				9, 0, 0, 63, 141, 150, 28, 2, 9, 0,
				0, 63, 141, 151, 28, 3, 0, 0, 1, 8,
				0, 7, 9, 0, 0, 63, 141, 152, 28, 2,
				9, 0, 0, 63, 141, 153, 28, 3, 0, 0,
				8, 0, 7, 9, 0, 0, 63, 141, 154, 28,
				2, 9, 0, 0, 63, 141, 155, 28, 3, 0,
				0, 0, 1, 128, 2, 8, 0, 9, 41, 77,
				134, 20, 4, 41, 109, 135, 20, 5, 41, 141,
				136, 20, 6, 0, 0, 2, 3, 0, 8, 0,
				9, 41, 77, 153, 20, 4, 41, 109, 154, 20,
				5, 41, 141, 155, 20, 6, 0, 0, 2, 6,
				0, 8, 0, 9, 41, 77, 184, 20, 4, 41,
				109, 185, 20, 5, 41, 141, 186, 20, 6, 0,
				0, 8, 0, 7, 9, 42, 77, 189, 20, 8,
				42, 109, 190, 20, 9, 42, 141, 191, 20, 10,
				0, 0, 0, 8, 0, 7, 0, 9, 42, 77,
				194, 20, 11, 42, 109, 195, 20, 12, 42, 141,
				196, 20, 13, 0, 0, 1, 8, 0, 7, 0,
				9, 41, 77, 202, 20, 4, 41, 109, 203, 20,
				5, 41, 141, 204, 20, 6, 7, 9, 70, 77,
				77, 205, 20, 3, 70, 77, 109, 206, 20, 4,
				70, 109, 141, 207, 20, 5, 0, 0, 8, 0,
				7, 0, 9, 41, 77, 208, 20, 4, 41, 109,
				209, 20, 5, 41, 141, 210, 20, 6, 7, 9,
				70, 77, 77, 211, 20, 2, 70, 77, 109, 212,
				20, 3, 70, 77, 141, 213, 20, 4, 0, 0,
				8, 0, 7, 0, 9, 41, 77, 214, 20, 4,
				41, 109, 215, 20, 5, 41, 141, 216, 20, 6,
				7, 9, 70, 77, 77, 217, 20, 1, 70, 77,
				109, 218, 20, 2, 70, 77, 141, 219, 20, 3,
				0, 0, 8, 0, 7, 10, 58, 77, 77, 222,
				20, 3, 1, 0, 58, 109, 77, 223, 20, 4,
				1, 0, 58, 141, 109, 224, 20, 5, 1, 0,
				0, 7, 9, 70, 77, 77, 225, 20, 3, 70,
				77, 109, 226, 20, 4, 70, 109, 141, 227, 20,
				5, 0, 0, 8, 0, 7, 9, 42, 77, 229,
				20, 8, 42, 109, 230, 20, 9, 42, 141, 231,
				20, 10, 9, 42, 77, 232, 20, 11, 42, 109,
				233, 20, 12, 42, 141, 234, 20, 13, 7, 9,
				70, 77, 77, 235, 20, 2, 70, 77, 109, 236,
				20, 3, 70, 77, 141, 237, 20, 4, 0, 0,
				8, 0, 7, 9, 42, 77, 239, 20, 8, 42,
				109, 240, 20, 9, 42, 141, 241, 20, 10, 9,
				42, 77, 242, 20, 11, 42, 109, 243, 20, 12,
				42, 141, 244, 20, 13, 7, 9, 70, 77, 77,
				245, 20, 3, 70, 77, 109, 246, 20, 4, 70,
				109, 141, 247, 20, 5, 0, 0, 8, 0, 7,
				9, 0, 42, 109, 249, 20, 9, 42, 141, 250,
				20, 10, 9, 0, 42, 109, 251, 20, 12, 42,
				141, 252, 20, 13, 0, 0, 0, 8, 0, 7,
				9, 54, 77, 77, 130, 21, 2, 54, 109, 77,
				131, 21, 2, 54, 141, 77, 132, 21, 2, 0,
				0, 0, 8, 0, 7, 9, 0, 54, 109, 77,
				134, 21, 3, 54, 141, 77, 135, 21, 3, 9,
				0, 54, 109, 77, 136, 21, 3, 54, 141, 77,
				137, 21, 3, 0, 0, 8, 0, 7, 9, 0,
				51, 109, 139, 21, 4, 51, 141, 140, 21, 4,
				9, 0, 51, 109, 141, 21, 4, 51, 141, 142,
				21, 4, 0, 0, 8, 0, 7, 9, 0, 0,
				51, 141, 143, 21, 5, 9, 0, 0, 51, 141,
				144, 21, 5, 0, 0, 8, 0, 9, 52, 77,
				149, 21, 4, 52, 109, 150, 21, 5, 52, 141,
				151, 21, 6, 0, 0, 8, 0, 9, 52, 77,
				156, 21, 4, 52, 109, 157, 21, 5, 52, 141,
				158, 21, 6, 0, 0, 8, 0, 7, 9, 53,
				77, 163, 21, 8, 53, 109, 164, 21, 9, 53,
				141, 165, 21, 10, 0, 0, 0, 8, 0, 7,
				0, 9, 53, 77, 166, 21, 11, 53, 109, 167,
				21, 12, 53, 141, 168, 21, 13, 0, 0, 8,
				0, 9, 54, 77, 77, 172, 21, 3, 54, 109,
				77, 173, 21, 4, 54, 141, 109, 174, 21, 5,
				7, 9, 70, 77, 77, 175, 21, 3, 70, 77,
				109, 176, 21, 4, 70, 109, 141, 177, 21, 5,
				0, 0, 8, 0, 9, 54, 77, 77, 181, 21,
				2, 54, 109, 77, 182, 21, 3, 54, 141, 77,
				183, 21, 4, 7, 9, 70, 77, 77, 184, 21,
				2, 70, 77, 109, 185, 21, 3, 70, 77, 141,
				186, 21, 4, 0, 0, 8, 0, 9, 54, 77,
				77, 190, 21, 1, 54, 109, 77, 191, 21, 2,
				54, 141, 77, 192, 21, 3, 7, 9, 70, 77,
				77, 193, 21, 1, 70, 77, 109, 194, 21, 2,
				70, 77, 141, 195, 21, 3, 0, 0, 8, 0,
				9, 54, 77, 77, 199, 21, 3, 54, 109, 77,
				200, 21, 4, 54, 141, 109, 201, 21, 5, 7,
				9, 70, 77, 77, 202, 21, 3, 70, 77, 109,
				203, 21, 4, 70, 109, 141, 204, 21, 5, 0,
				0, 8, 0, 9, 54, 77, 77, 208, 21, 2,
				54, 109, 77, 209, 21, 3, 54, 141, 77, 210,
				21, 4, 7, 9, 70, 77, 77, 211, 21, 2,
				70, 77, 109, 212, 21, 3, 70, 77, 141, 213,
				21, 4, 0, 0, 8, 0, 7, 9, 54, 77,
				77, 217, 21, 3, 54, 109, 77, 218, 21, 4,
				54, 141, 109, 219, 21, 5, 0, 7, 9, 70,
				77, 77, 220, 21, 3, 70, 77, 109, 221, 21,
				4, 70, 109, 141, 222, 21, 5, 0, 0, 8,
				0, 7, 9, 19, 77, 223, 21, 4, 19, 109,
				224, 21, 5, 19, 141, 225, 21, 6, 9, 19,
				77, 226, 21, 4, 19, 109, 227, 21, 5, 19,
				141, 228, 21, 6, 7, 9, 19, 77, 229, 21,
				4, 19, 109, 230, 21, 5, 19, 141, 231, 21,
				6, 9, 19, 77, 232, 21, 4, 19, 109, 233,
				21, 5, 19, 141, 234, 21, 6, 0, 8, 0,
				7, 9, 20, 77, 235, 21, 8, 20, 109, 236,
				21, 9, 20, 141, 237, 21, 10, 9, 20, 77,
				238, 21, 11, 20, 109, 239, 21, 12, 20, 141,
				240, 21, 13, 7, 9, 20, 77, 241, 21, 8,
				20, 109, 242, 21, 9, 20, 141, 243, 21, 10,
				9, 20, 77, 244, 21, 11, 20, 109, 245, 21,
				12, 20, 141, 246, 21, 13, 0, 8, 0, 7,
				0, 9, 42, 77, 250, 21, 11, 42, 109, 251,
				21, 12, 42, 141, 252, 21, 13, 7, 9, 36,
				77, 253, 21, 36, 109, 254, 21, 36, 141, 255,
				21, 9, 36, 77, 128, 22, 36, 109, 129, 22,
				36, 141, 130, 22, 0, 8, 0, 7, 0, 9,
				20, 77, 134, 22, 11, 20, 109, 135, 22, 12,
				20, 141, 136, 22, 13, 7, 9, 28, 77, 137,
				22, 28, 109, 138, 22, 28, 141, 139, 22, 9,
				28, 77, 140, 22, 28, 109, 141, 22, 28, 141,
				142, 22, 0, 8, 0, 7, 9, 62, 77, 146,
				22, 4, 62, 109, 147, 22, 5, 62, 141, 148,
				22, 6, 0, 7, 0, 9, 36, 77, 149, 22,
				36, 109, 150, 22, 36, 141, 151, 22, 0, 8,
				0, 7, 9, 42, 77, 155, 22, 8, 42, 109,
				156, 22, 9, 42, 141, 157, 22, 10, 0, 0,
				0, 8, 0, 7, 10, 45, 77, 160, 22, 8,
				0, 45, 109, 161, 22, 9, 0, 45, 141, 162,
				22, 10, 0, 10, 45, 77, 163, 22, 11, 0,
				45, 109, 164, 22, 12, 0, 45, 141, 165, 22,
				13, 0, 0, 0, 8, 0, 7, 44, 77, 168,
				22, 2, 0, 44, 77, 169, 22, 3, 0, 0,
				0, 1, 8, 0, 9, 54, 77, 77, 177, 22,
				3, 54, 109, 77, 178, 22, 4, 54, 141, 109,
				179, 22, 5, 7, 9, 70, 77, 77, 180, 22,
				3, 70, 77, 109, 181, 22, 4, 70, 109, 141,
				182, 22, 5, 0, 0, 8, 0, 9, 54, 77,
				77, 186, 22, 2, 54, 109, 77, 187, 22, 3,
				54, 141, 77, 188, 22, 4, 7, 9, 70, 77,
				77, 189, 22, 2, 70, 77, 109, 190, 22, 3,
				70, 77, 141, 191, 22, 4, 0, 0, 8, 0,
				9, 54, 77, 77, 195, 22, 1, 54, 109, 77,
				196, 22, 2, 54, 141, 77, 197, 22, 3, 7,
				9, 70, 77, 77, 198, 22, 1, 70, 77, 109,
				199, 22, 2, 70, 77, 141, 200, 22, 3, 0,
				0, 8, 0, 9, 54, 77, 77, 204, 22, 3,
				54, 109, 77, 205, 22, 4, 54, 141, 109, 206,
				22, 5, 7, 9, 70, 77, 77, 207, 22, 3,
				70, 77, 109, 208, 22, 4, 70, 109, 141, 209,
				22, 5, 0, 0, 8, 0, 9, 54, 77, 77,
				213, 22, 2, 54, 109, 77, 214, 22, 3, 54,
				141, 77, 215, 22, 4, 7, 9, 70, 77, 77,
				216, 22, 2, 70, 77, 109, 217, 22, 3, 70,
				77, 141, 218, 22, 4, 0, 0, 8, 0, 7,
				9, 54, 77, 77, 222, 22, 3, 54, 109, 77,
				223, 22, 4, 54, 141, 109, 224, 22, 5, 0,
				7, 9, 70, 77, 77, 225, 22, 3, 70, 77,
				109, 226, 22, 4, 70, 109, 141, 227, 22, 5,
				0, 0, 8, 0, 7, 9, 0, 42, 109, 229,
				22, 9, 42, 141, 230, 22, 10, 9, 0, 42,
				109, 231, 22, 12, 42, 141, 232, 22, 13, 0,
				0, 8, 0, 7, 0, 9, 20, 77, 236, 22,
				11, 20, 109, 237, 22, 12, 20, 141, 238, 22,
				13, 0, 0, 8, 0, 9, 41, 77, 242, 22,
				4, 41, 109, 243, 22, 5, 41, 141, 244, 22,
				6, 7, 9, 36, 77, 245, 22, 36, 109, 246,
				22, 36, 141, 247, 22, 9, 36, 77, 248, 22,
				36, 109, 249, 22, 36, 141, 250, 22, 0, 8,
				0, 7, 9, 42, 77, 254, 22, 8, 42, 109,
				255, 22, 9, 42, 141, 128, 23, 10, 9, 42,
				77, 129, 23, 11, 42, 109, 130, 23, 12, 42,
				141, 131, 23, 13, 7, 9, 28, 77, 132, 23,
				28, 109, 133, 23, 28, 141, 134, 23, 9, 28,
				77, 135, 23, 28, 109, 136, 23, 28, 141, 137,
				23, 0, 8, 0, 9, 41, 77, 141, 23, 4,
				41, 109, 142, 23, 5, 41, 141, 143, 23, 6,
				7, 9, 36, 77, 144, 23, 36, 109, 145, 23,
				36, 141, 146, 23, 0, 0, 8, 0, 7, 9,
				42, 77, 150, 23, 8, 42, 109, 151, 23, 9,
				42, 141, 152, 23, 10, 9, 42, 77, 153, 23,
				11, 42, 109, 154, 23, 12, 42, 141, 155, 23,
				13, 0, 0, 8, 0, 9, 41, 77, 159, 23,
				4, 41, 109, 160, 23, 5, 41, 141, 161, 23,
				6, 0, 0, 8, 0, 7, 9, 42, 77, 165,
				23, 8, 42, 109, 166, 23, 9, 42, 141, 167,
				23, 10, 9, 42, 77, 168, 23, 11, 42, 109,
				169, 23, 12, 42, 141, 170, 23, 13, 0, 0,
				8, 0, 9, 41, 77, 174, 23, 4, 41, 109,
				175, 23, 5, 41, 141, 176, 23, 6, 0, 0,
				8, 0, 7, 9, 42, 77, 180, 23, 8, 42,
				109, 181, 23, 9, 42, 141, 182, 23, 10, 9,
				42, 77, 183, 23, 11, 42, 109, 184, 23, 12,
				42, 141, 185, 23, 13, 0, 0, 8, 0, 7,
				9, 42, 77, 189, 23, 8, 42, 109, 190, 23,
				9, 42, 141, 191, 23, 10, 9, 42, 77, 192,
				23, 11, 42, 109, 193, 23, 12, 42, 141, 194,
				23, 13, 0, 0, 0, 8, 0, 7, 10, 56,
				77, 197, 23, 8, 1, 56, 109, 198, 23, 9,
				1, 56, 141, 199, 23, 10, 1, 10, 56, 77,
				200, 23, 11, 1, 56, 109, 201, 23, 12, 1,
				56, 141, 202, 23, 13, 1, 0, 0, 8, 0,
				7, 44, 77, 203, 23, 2, 1, 44, 77, 204,
				23, 3, 1, 0, 0, 8, 0, 7, 9, 53,
				77, 205, 23, 8, 53, 109, 206, 23, 9, 53,
				141, 207, 23, 10, 9, 53, 77, 208, 23, 11,
				53, 109, 209, 23, 12, 53, 141, 210, 23, 13,
				0, 0, 8, 0, 7, 9, 42, 77, 215, 23,
				8, 42, 109, 216, 23, 9, 42, 141, 217, 23,
				10, 9, 42, 77, 218, 23, 11, 42, 109, 219,
				23, 12, 42, 141, 220, 23, 13, 0, 0, 8,
				0, 7, 9, 42, 77, 223, 23, 8, 42, 109,
				224, 23, 9, 42, 141, 225, 23, 10, 9, 42,
				77, 226, 23, 11, 42, 109, 227, 23, 12, 42,
				141, 228, 23, 13, 0, 0, 8, 0, 7, 9,
				42, 77, 233, 23, 8, 42, 109, 234, 23, 9,
				42, 141, 235, 23, 10, 9, 42, 77, 236, 23,
				11, 42, 109, 237, 23, 12, 42, 141, 238, 23,
				13, 0, 0, 2, 4, 0, 8, 0, 7, 9,
				53, 77, 239, 23, 8, 53, 109, 240, 23, 9,
				53, 141, 241, 23, 10, 9, 53, 77, 242, 23,
				11, 53, 109, 243, 23, 12, 53, 141, 244, 23,
				13, 0, 0, 8, 0, 7, 41, 77, 245, 23,
				2, 41, 77, 246, 23, 3, 0, 0, 8, 0,
				7, 9, 53, 77, 247, 23, 8, 53, 109, 248,
				23, 9, 53, 141, 249, 23, 10, 9, 53, 77,
				250, 23, 11, 53, 109, 251, 23, 12, 53, 141,
				252, 23, 13, 0, 0, 8, 0, 7, 41, 77,
				253, 23, 2, 41, 77, 254, 23, 3, 0, 0,
				8, 0, 7, 9, 42, 77, 255, 23, 8, 42,
				109, 128, 24, 9, 42, 141, 129, 24, 10, 0,
				0, 0, 8, 0, 7, 9, 42, 77, 130, 24,
				8, 42, 109, 131, 24, 9, 42, 141, 132, 24,
				10, 0, 0, 0, 8, 0, 7, 9, 42, 77,
				133, 24, 8, 42, 109, 134, 24, 9, 42, 141,
				135, 24, 10, 0, 7, 9, 42, 77, 136, 24,
				8, 42, 109, 137, 24, 9, 42, 141, 138, 24,
				10, 0, 7, 9, 0, 0, 40, 141, 139, 24,
				4, 0, 8, 0, 7, 9, 42, 77, 140, 24,
				8, 42, 109, 141, 24, 9, 42, 141, 142, 24,
				10, 0, 0, 7, 9, 0, 0, 40, 141, 143,
				24, 4, 0, 8, 0, 7, 9, 52, 77, 144,
				24, 4, 52, 109, 145, 24, 5, 52, 141, 146,
				24, 6, 9, 52, 77, 147, 24, 4, 52, 109,
				148, 24, 5, 52, 141, 149, 24, 6, 0, 0,
				8, 0, 7, 9, 53, 77, 150, 24, 8, 53,
				109, 151, 24, 9, 53, 141, 152, 24, 10, 9,
				53, 77, 153, 24, 11, 53, 109, 154, 24, 12,
				53, 141, 155, 24, 13, 0, 0, 1, 8, 0,
				7, 9, 54, 77, 77, 158, 24, 2, 54, 109,
				77, 159, 24, 2, 54, 141, 77, 160, 24, 2,
				0, 0, 0, 8, 0, 7, 9, 54, 77, 77,
				163, 24, 3, 54, 109, 77, 164, 24, 3, 54,
				141, 77, 165, 24, 3, 9, 54, 77, 77, 166,
				24, 3, 54, 109, 77, 167, 24, 3, 54, 141,
				77, 168, 24, 3, 0, 0, 8, 0, 7, 9,
				0, 51, 109, 170, 24, 4, 51, 141, 171, 24,
				4, 9, 0, 51, 109, 172, 24, 4, 51, 141,
				173, 24, 4, 0, 0, 8, 0, 7, 9, 0,
				0, 51, 141, 174, 24, 5, 9, 0, 0, 51,
				141, 175, 24, 5, 0, 0, 2, 6, 0, 8,
				0, 7, 9, 52, 77, 176, 24, 0, 52, 109,
				177, 24, 0, 52, 141, 178, 24, 0, 9, 52,
				77, 179, 24, 1, 52, 109, 180, 24, 1, 52,
				141, 181, 24, 1, 0, 0, 8, 0, 7, 9,
				69, 77, 182, 24, 0, 69, 109, 183, 24, 0,
				69, 141, 184, 24, 0, 9, 69, 77, 185, 24,
				1, 69, 109, 186, 24, 1, 69, 141, 187, 24,
				1, 0, 0, 8, 0, 7, 9, 42, 77, 188,
				24, 8, 42, 109, 189, 24, 9, 42, 141, 190,
				24, 10, 9, 42, 77, 191, 24, 11, 42, 109,
				192, 24, 12, 42, 141, 193, 24, 13, 0, 0,
				8, 0, 7, 9, 42, 77, 194, 24, 8, 42,
				109, 195, 24, 9, 42, 141, 196, 24, 10, 9,
				42, 77, 197, 24, 11, 42, 109, 198, 24, 12,
				42, 141, 199, 24, 13, 0, 0, 8, 0, 7,
				9, 41, 77, 200, 24, 4, 41, 109, 201, 24,
				5, 41, 141, 202, 24, 6, 9, 41, 77, 203,
				24, 4, 41, 109, 204, 24, 5, 41, 141, 205,
				24, 6, 0, 0, 0, 8, 0, 0, 0, 7,
				9, 27, 77, 206, 24, 8, 27, 109, 207, 24,
				9, 27, 141, 208, 24, 10, 9, 27, 77, 209,
				24, 11, 27, 109, 210, 24, 12, 27, 141, 211,
				24, 13, 2, 7, 0, 8, 0, 7, 0, 9,
				41, 77, 212, 24, 4, 41, 109, 213, 24, 5,
				41, 141, 214, 24, 6, 0, 0, 8, 0, 7,
				9, 42, 77, 215, 24, 8, 42, 109, 216, 24,
				9, 42, 141, 217, 24, 10, 9, 42, 77, 218,
				24, 11, 42, 109, 219, 24, 12, 42, 141, 220,
				24, 13, 0, 0, 8, 0, 7, 0, 9, 41,
				77, 221, 24, 4, 41, 109, 222, 24, 5, 41,
				141, 223, 24, 6, 7, 9, 55, 77, 77, 224,
				24, 8, 55, 77, 109, 225, 24, 9, 55, 109,
				141, 226, 24, 10, 0, 7, 9, 42, 77, 227,
				24, 8, 42, 109, 228, 24, 9, 42, 141, 229,
				24, 10, 0, 8, 0, 7, 9, 42, 77, 230,
				24, 8, 42, 109, 231, 24, 9, 42, 141, 232,
				24, 10, 9, 42, 77, 233, 24, 11, 42, 109,
				234, 24, 12, 42, 141, 235, 24, 13, 0, 0,
				0, 8, 0, 7, 9, 41, 77, 236, 24, 4,
				41, 109, 237, 24, 5, 41, 141, 238, 24, 6,
				9, 41, 77, 239, 24, 4, 41, 109, 240, 24,
				5, 41, 141, 241, 24, 6, 0, 0, 8, 0,
				7, 9, 42, 77, 242, 24, 8, 42, 109, 243,
				24, 9, 42, 141, 244, 24, 10, 9, 42, 77,
				245, 24, 11, 42, 109, 246, 24, 12, 42, 141,
				247, 24, 13, 0, 0, 8, 0, 7, 9, 42,
				77, 248, 24, 8, 42, 109, 249, 24, 9, 42,
				141, 250, 24, 10, 9, 42, 77, 251, 24, 11,
				42, 109, 252, 24, 12, 42, 141, 253, 24, 13,
				0, 0, 8, 0, 7, 9, 54, 77, 77, 128,
				25, 0, 54, 109, 77, 129, 25, 0, 54, 141,
				77, 130, 25, 0, 0, 0, 0, 8, 0, 7,
				9, 54, 77, 77, 133, 25, 1, 54, 109, 77,
				134, 25, 1, 54, 141, 77, 135, 25, 1, 0,
				0, 0, 8, 0, 7, 9, 38, 77, 136, 25,
				38, 109, 137, 25, 38, 141, 138, 25, 0, 0,
				0, 8, 0, 7, 9, 38, 77, 139, 25, 38,
				109, 140, 25, 38, 141, 141, 25, 0, 0, 0,
				8, 0, 9, 39, 77, 142, 25, 145, 25, 39,
				109, 143, 25, 146, 25, 39, 141, 144, 25, 147,
				25, 0, 0, 8, 0, 7, 9, 41, 77, 148,
				25, 4, 41, 109, 149, 25, 5, 41, 141, 150,
				25, 6, 9, 41, 77, 151, 25, 4, 41, 109,
				152, 25, 5, 41, 141, 153, 25, 6, 0, 0,
				8, 0, 7, 9, 42, 77, 154, 25, 8, 42,
				109, 155, 25, 9, 42, 141, 156, 25, 10, 9,
				42, 77, 157, 25, 11, 42, 109, 158, 25, 12,
				42, 141, 159, 25, 13, 0, 0, 8, 0, 7,
				9, 42, 77, 160, 25, 8, 42, 109, 161, 25,
				9, 42, 141, 162, 25, 10, 9, 42, 77, 163,
				25, 11, 42, 109, 164, 25, 12, 42, 141, 165,
				25, 13, 0, 0, 2, 3, 0, 8, 0, 7,
				0, 9, 42, 77, 172, 25, 11, 42, 109, 173,
				25, 12, 42, 141, 174, 25, 13, 0, 0, 2,
				4, 0, 8, 0, 7, 9, 52, 77, 175, 25,
				2, 52, 109, 176, 25, 2, 52, 141, 177, 25,
				2, 9, 52, 77, 178, 25, 3, 52, 109, 179,
				25, 3, 52, 141, 180, 25, 3, 0, 0, 8,
				0, 7, 9, 52, 77, 181, 25, 2, 52, 109,
				182, 25, 2, 52, 141, 183, 25, 2, 9, 52,
				77, 184, 25, 3, 52, 109, 185, 25, 3, 52,
				141, 186, 25, 3, 0, 0, 8, 0, 7, 9,
				69, 77, 187, 25, 2, 69, 109, 188, 25, 2,
				69, 141, 189, 25, 2, 9, 69, 77, 190, 25,
				3, 69, 109, 191, 25, 3, 69, 141, 192, 25,
				3, 0, 0, 8, 0, 7, 9, 69, 77, 193,
				25, 2, 69, 109, 194, 25, 2, 69, 141, 195,
				25, 2, 9, 69, 77, 196, 25, 3, 69, 109,
				197, 25, 3, 69, 141, 198, 25, 3, 0, 0,
				0, 8, 0, 7, 9, 41, 77, 203, 25, 4,
				41, 109, 204, 25, 5, 41, 141, 205, 25, 6,
				9, 41, 77, 206, 25, 4, 41, 109, 207, 25,
				5, 41, 141, 208, 25, 6, 0, 0, 0, 8,
				0, 7, 9, 19, 77, 213, 25, 4, 19, 109,
				214, 25, 5, 19, 141, 215, 25, 6, 0, 0,
				0, 8, 0, 7, 9, 37, 77, 77, 220, 25,
				2, 37, 109, 109, 221, 25, 2, 37, 141, 141,
				222, 25, 2, 9, 37, 77, 77, 223, 25, 3,
				37, 109, 77, 224, 25, 3, 37, 141, 109, 225,
				25, 3, 0, 0, 8, 0, 7, 9, 37, 77,
				77, 230, 25, 2, 37, 77, 109, 231, 25, 2,
				37, 109, 141, 232, 25, 2, 9, 37, 77, 77,
				233, 25, 3, 37, 109, 109, 234, 25, 3, 37,
				141, 141, 235, 25, 3, 0, 0, 8, 0, 7,
				9, 37, 77, 77, 240, 25, 2, 37, 109, 109,
				241, 25, 2, 37, 141, 141, 242, 25, 2, 9,
				37, 77, 77, 243, 25, 3, 37, 109, 77, 244,
				25, 3, 37, 141, 109, 245, 25, 3, 0, 0,
				8, 0, 7, 9, 37, 77, 77, 250, 25, 2,
				37, 77, 109, 251, 25, 2, 37, 109, 141, 252,
				25, 2, 9, 37, 77, 77, 253, 25, 3, 37,
				109, 109, 254, 25, 3, 37, 141, 141, 255, 25,
				3, 0, 0, 1, 8, 0, 7, 10, 45, 77,
				132, 26, 8, 0, 45, 109, 133, 26, 9, 0,
				45, 141, 134, 26, 10, 0, 10, 45, 77, 135,
				26, 11, 0, 45, 109, 136, 26, 12, 0, 45,
				141, 137, 26, 13, 0, 0, 0, 8, 0, 7,
				10, 45, 77, 142, 26, 8, 0, 45, 109, 143,
				26, 9, 0, 45, 141, 144, 26, 10, 0, 10,
				45, 77, 145, 26, 11, 0, 45, 109, 146, 26,
				12, 0, 45, 141, 147, 26, 13, 0, 0, 0,
				8, 0, 7, 10, 45, 77, 152, 26, 8, 0,
				45, 109, 153, 26, 9, 0, 45, 141, 154, 26,
				10, 0, 10, 45, 77, 155, 26, 11, 0, 45,
				109, 156, 26, 12, 0, 45, 141, 157, 26, 13,
				0, 0, 0, 8, 0, 7, 44, 77, 160, 26,
				2, 0, 44, 77, 161, 26, 3, 0, 0, 0,
				8, 0, 7, 10, 45, 77, 166, 26, 8, 0,
				45, 109, 167, 26, 9, 0, 45, 141, 168, 26,
				10, 0, 10, 45, 77, 169, 26, 11, 0, 45,
				109, 170, 26, 12, 0, 45, 141, 171, 26, 13,
				0, 0, 7, 9, 0, 0, 40, 141, 172, 26,
				4, 0, 8, 0, 7, 44, 77, 175, 26, 2,
				0, 44, 77, 176, 26, 3, 0, 0, 7, 40,
				77, 177, 26, 4, 0, 8, 0, 7, 10, 45,
				77, 182, 26, 8, 0, 45, 109, 183, 26, 9,
				0, 45, 141, 184, 26, 10, 0, 10, 45, 77,
				185, 26, 11, 0, 45, 109, 186, 26, 12, 0,
				45, 141, 187, 26, 13, 0, 0, 0, 8, 0,
				7, 44, 77, 190, 26, 2, 0, 44, 77, 191,
				26, 3, 0, 0, 0, 8, 0, 7, 10, 45,
				77, 196, 26, 8, 0, 45, 109, 197, 26, 9,
				0, 45, 141, 198, 26, 10, 0, 10, 45, 77,
				199, 26, 11, 0, 45, 109, 200, 26, 12, 0,
				45, 141, 201, 26, 13, 0, 0, 0, 8, 0,
				7, 44, 77, 204, 26, 2, 0, 44, 77, 205,
				26, 3, 0, 0, 0, 8, 0, 7, 9, 64,
				77, 77, 206, 26, 2, 64, 109, 109, 207, 26,
				2, 64, 141, 141, 208, 26, 2, 9, 64, 77,
				77, 209, 26, 3, 64, 77, 109, 210, 26, 3,
				64, 109, 141, 211, 26, 3, 0, 0, 8, 0,
				7, 9, 64, 77, 77, 212, 26, 2, 64, 109,
				77, 213, 26, 2, 64, 141, 109, 214, 26, 2,
				9, 64, 77, 77, 215, 26, 3, 64, 109, 109,
				216, 26, 3, 64, 141, 141, 217, 26, 3, 0,
				0, 8, 0, 7, 9, 64, 77, 77, 218, 26,
				2, 64, 109, 109, 219, 26, 2, 64, 141, 141,
				220, 26, 2, 9, 64, 77, 77, 221, 26, 3,
				64, 77, 109, 222, 26, 3, 64, 109, 141, 223,
				26, 3, 0, 0, 8, 0, 7, 9, 64, 77,
				77, 224, 26, 2, 64, 109, 77, 225, 26, 2,
				64, 141, 109, 226, 26, 2, 9, 64, 77, 77,
				227, 26, 3, 64, 109, 109, 228, 26, 3, 64,
				141, 141, 229, 26, 3, 0, 0, 1, 8, 0,
				7, 10, 45, 77, 234, 26, 8, 0, 45, 109,
				235, 26, 9, 0, 45, 141, 236, 26, 10, 0,
				10, 45, 77, 237, 26, 11, 0, 45, 109, 238,
				26, 12, 0, 45, 141, 239, 26, 13, 0, 0,
				0, 8, 0, 7, 10, 45, 77, 244, 26, 8,
				0, 45, 109, 245, 26, 9, 0, 45, 141, 246,
				26, 10, 0, 10, 45, 77, 247, 26, 11, 0,
				45, 109, 248, 26, 12, 0, 45, 141, 249, 26,
				13, 0, 0, 0, 8, 0, 7, 10, 45, 77,
				254, 26, 8, 0, 45, 109, 255, 26, 9, 0,
				45, 141, 128, 27, 10, 0, 10, 45, 77, 129,
				27, 11, 0, 45, 109, 130, 27, 12, 0, 45,
				141, 131, 27, 13, 0, 0, 0, 8, 0, 7,
				44, 77, 134, 27, 2, 0, 44, 77, 135, 27,
				3, 0, 0, 0, 8, 0, 7, 10, 45, 77,
				140, 27, 8, 0, 45, 109, 141, 27, 9, 0,
				45, 141, 142, 27, 10, 0, 10, 45, 77, 143,
				27, 11, 0, 45, 109, 144, 27, 12, 0, 45,
				141, 145, 27, 13, 0, 0, 7, 9, 0, 0,
				40, 141, 146, 27, 4, 0, 8, 0, 7, 44,
				77, 149, 27, 2, 0, 44, 77, 150, 27, 3,
				0, 0, 7, 40, 77, 151, 27, 4, 0, 8,
				0, 7, 10, 45, 77, 156, 27, 8, 0, 45,
				109, 157, 27, 9, 0, 45, 141, 158, 27, 10,
				0, 10, 45, 77, 159, 27, 11, 0, 45, 109,
				160, 27, 12, 0, 45, 141, 161, 27, 13, 0,
				0, 0, 8, 0, 7, 44, 77, 164, 27, 2,
				0, 44, 77, 165, 27, 3, 0, 0, 0, 8,
				0, 7, 10, 45, 77, 170, 27, 8, 0, 45,
				109, 171, 27, 9, 0, 45, 141, 172, 27, 10,
				0, 10, 45, 77, 173, 27, 11, 0, 45, 109,
				174, 27, 12, 0, 45, 141, 175, 27, 13, 0,
				0, 0, 8, 0, 7, 44, 77, 178, 27, 2,
				0, 44, 77, 179, 27, 3, 0, 0, 0, 2,
				4, 0, 8, 0, 7, 0, 9, 42, 77, 180,
				27, 11, 42, 109, 181, 27, 12, 42, 141, 182,
				27, 13, 0, 0, 8, 0, 7, 0, 9, 42,
				77, 183, 27, 11, 42, 109, 184, 27, 12, 42,
				141, 185, 27, 13, 0, 0, 8, 0, 7, 10,
				45, 77, 190, 27, 8, 0, 45, 109, 191, 27,
				9, 0, 45, 141, 192, 27, 10, 0, 10, 45,
				77, 193, 27, 11, 0, 45, 109, 194, 27, 12,
				0, 45, 141, 195, 27, 13, 0, 0, 0, 8,
				0, 7, 10, 45, 77, 200, 27, 8, 0, 45,
				109, 201, 27, 9, 0, 45, 141, 202, 27, 10,
				0, 10, 45, 77, 203, 27, 11, 0, 45, 109,
				204, 27, 12, 0, 45, 141, 205, 27, 13, 0,
				0, 0, 8, 0, 7, 10, 45, 77, 210, 27,
				8, 0, 45, 109, 211, 27, 9, 0, 45, 141,
				212, 27, 10, 0, 10, 45, 77, 213, 27, 11,
				0, 45, 109, 214, 27, 12, 0, 45, 141, 215,
				27, 13, 0, 0, 0, 8, 0, 7, 44, 77,
				218, 27, 2, 0, 44, 77, 219, 27, 3, 0,
				0, 0, 8, 0, 7, 10, 45, 77, 224, 27,
				8, 0, 45, 109, 225, 27, 9, 0, 45, 141,
				226, 27, 10, 0, 10, 45, 77, 227, 27, 11,
				0, 45, 109, 228, 27, 12, 0, 45, 141, 229,
				27, 13, 0, 0, 0, 8, 0, 7, 44, 77,
				232, 27, 2, 0, 44, 77, 233, 27, 3, 0,
				0, 0, 8, 0, 7, 10, 45, 77, 238, 27,
				8, 0, 45, 109, 239, 27, 9, 0, 45, 141,
				240, 27, 10, 0, 10, 45, 77, 241, 27, 11,
				0, 45, 109, 242, 27, 12, 0, 45, 141, 243,
				27, 13, 0, 0, 0, 8, 0, 7, 44, 77,
				246, 27, 2, 0, 44, 77, 247, 27, 3, 0,
				0, 0, 8, 0, 7, 10, 45, 77, 252, 27,
				8, 0, 45, 109, 253, 27, 9, 0, 45, 141,
				254, 27, 10, 0, 10, 45, 77, 255, 27, 11,
				0, 45, 109, 128, 28, 12, 0, 45, 141, 129,
				28, 13, 0, 0, 0, 8, 0, 7, 44, 77,
				132, 28, 2, 0, 44, 77, 133, 28, 3, 0,
				0, 0, 2, 4, 0, 8, 0, 7, 9, 53,
				77, 134, 28, 8, 53, 109, 135, 28, 9, 53,
				141, 136, 28, 10, 9, 53, 77, 137, 28, 11,
				53, 109, 138, 28, 12, 53, 141, 139, 28, 13,
				0, 0, 0, 6, 4, 3, 6, 4, 4, 8,
				0, 7, 10, 0, 0, 56, 141, 157, 28, 10,
				1, 10, 0, 0, 56, 141, 158, 28, 13, 1,
				0, 0, 0, 8, 0, 7, 10, 0, 0, 56,
				141, 161, 28, 10, 1, 10, 0, 0, 56, 141,
				162, 28, 13, 1, 0, 0, 8, 0, 7, 44,
				77, 164, 28, 2, 1, 44, 77, 165, 28, 3,
				1, 0, 0, 8, 0, 7, 10, 0, 0, 56,
				141, 167, 28, 10, 1, 10, 0, 0, 56, 141,
				168, 28, 13, 1, 0, 0, 8, 0, 7, 44,
				77, 170, 28, 2, 1, 44, 77, 171, 28, 3,
				1, 0, 0, 0, 8, 0, 7, 9, 41, 77,
				175, 28, 4, 41, 109, 176, 28, 5, 41, 141,
				177, 28, 6, 0, 0, 0, 2, 12, 0, 8,
				0, 9, 33, 77, 183, 28, 4, 33, 109, 184,
				28, 5, 33, 141, 185, 28, 6, 0, 0, 8,
				0, 9, 33, 77, 189, 28, 4, 33, 109, 190,
				28, 5, 33, 141, 191, 28, 6, 0, 0, 8,
				0, 9, 33, 77, 195, 28, 4, 33, 109, 196,
				28, 5, 33, 141, 197, 28, 6, 0, 0, 8,
				0, 9, 33, 77, 201, 28, 4, 33, 109, 202,
				28, 5, 33, 141, 203, 28, 6, 0, 0, 2,
				32, 0, 1, 128, 2, 8, 0, 7, 0, 9,
				0, 60, 109, 131, 29, 12, 60, 141, 132, 29,
				13, 0, 0, 8, 0, 7, 0, 9, 0, 60,
				109, 134, 29, 12, 60, 141, 135, 29, 13, 0,
				0, 0, 8, 0, 7, 9, 47, 77, 138, 29,
				8, 47, 109, 139, 29, 9, 47, 141, 140, 29,
				10, 9, 47, 77, 141, 29, 11, 47, 109, 142,
				29, 12, 47, 141, 143, 29, 13, 0, 0, 8,
				0, 7, 9, 60, 77, 146, 29, 8, 60, 109,
				147, 29, 9, 60, 141, 148, 29, 10, 0, 0,
				0, 8, 0, 7, 0, 9, 60, 77, 151, 29,
				11, 60, 109, 152, 29, 12, 60, 141, 153, 29,
				13, 0, 0, 1, 8, 7, 10, 61, 77, 188,
				35, 16, 61, 109, 189, 35, 17, 61, 141, 190,
				35, 18, 0, 7, 10, 61, 77, 158, 29, 8,
				61, 109, 159, 29, 9, 61, 141, 160, 29, 10,
				0, 0, 0, 8, 0, 7, 0, 10, 61, 77,
				164, 29, 11, 61, 109, 165, 29, 12, 61, 141,
				166, 29, 13, 0, 0, 8, 7, 49, 77, 191,
				35, 1, 0, 7, 49, 77, 169, 29, 2, 0,
				0, 0, 8, 0, 7, 0, 49, 77, 172, 29,
				3, 0, 0, 2, 3, 0, 8, 0, 9, 46,
				77, 186, 29, 4, 46, 109, 187, 29, 5, 46,
				141, 188, 29, 6, 0, 0, 2, 4, 0, 8,
				0, 9, 15, 77, 193, 29, 0, 0, 0, 0,
				0, 0, 8, 0, 9, 15, 77, 199, 29, 1,
				1, 0, 0, 0, 0, 8, 0, 9, 15, 77,
				205, 29, 2, 3, 0, 0, 0, 0, 8, 0,
				9, 11, 77, 211, 29, 2, 2, 0, 0, 0,
				0, 8, 0, 7, 9, 0, 48, 109, 109, 77,
				214, 29, 4, 48, 141, 141, 77, 215, 29, 4,
				9, 0, 48, 109, 109, 77, 216, 29, 4, 48,
				141, 141, 77, 217, 29, 4, 0, 0, 8, 0,
				7, 9, 0, 72, 77, 109, 219, 29, 4, 72,
				77, 141, 220, 29, 4, 9, 0, 72, 77, 109,
				221, 29, 4, 72, 77, 141, 222, 29, 4, 0,
				0, 8, 0, 7, 9, 0, 0, 48, 141, 141,
				109, 223, 29, 5, 9, 0, 0, 48, 141, 141,
				109, 224, 29, 5, 0, 0, 8, 0, 7, 9,
				0, 0, 72, 109, 141, 225, 29, 5, 9, 0,
				0, 72, 109, 141, 226, 29, 5, 0, 0, 0,
				8, 0, 7, 10, 73, 77, 77, 229, 29, 3,
				73, 77, 109, 230, 29, 4, 73, 109, 141, 231,
				29, 5, 0, 0, 0, 8, 0, 7, 9, 24,
				77, 232, 29, 8, 24, 109, 233, 29, 9, 24,
				141, 234, 29, 10, 9, 24, 77, 235, 29, 11,
				24, 109, 236, 29, 12, 24, 141, 237, 29, 13,
				0, 0, 8, 0, 7, 9, 24, 77, 238, 29,
				8, 24, 109, 239, 29, 9, 24, 141, 240, 29,
				10, 9, 24, 77, 241, 29, 11, 24, 109, 242,
				29, 12, 24, 141, 243, 29, 13, 0, 0, 8,
				0, 9, 31, 77, 248, 29, 0, 0, 0, 0,
				0, 0, 8, 0, 7, 9, 35, 77, 252, 29,
				2, 0, 0, 0, 0, 0, 8, 0, 9, 31,
				77, 129, 30, 2, 3, 0, 0, 0, 0, 8,
				0, 7, 9, 0, 47, 109, 131, 30, 9, 47,
				141, 132, 30, 10, 9, 0, 47, 109, 133, 30,
				12, 47, 141, 134, 30, 13, 0, 0, 0, 8,
				0, 7, 9, 47, 77, 135, 30, 8, 47, 109,
				136, 30, 9, 47, 141, 137, 30, 10, 9, 47,
				77, 138, 30, 11, 47, 109, 139, 30, 12, 47,
				141, 140, 30, 13, 0, 0, 8, 7, 10, 61,
				77, 156, 35, 16, 61, 109, 157, 35, 17, 61,
				141, 158, 35, 18, 0, 7, 10, 61, 77, 141,
				30, 8, 61, 109, 142, 30, 9, 61, 141, 143,
				30, 10, 10, 61, 77, 144, 30, 11, 61, 109,
				145, 30, 12, 61, 141, 146, 30, 13, 0, 0,
				8, 7, 49, 77, 159, 35, 1, 0, 7, 49,
				77, 147, 30, 2, 49, 77, 148, 30, 3, 0,
				0, 2, 16, 0, 8, 0, 7, 9, 0, 48,
				109, 109, 77, 158, 30, 4, 48, 141, 141, 77,
				159, 30, 4, 9, 0, 48, 109, 109, 77, 160,
				30, 4, 48, 141, 141, 77, 161, 30, 4, 0,
				0, 8, 0, 7, 9, 0, 72, 77, 109, 163,
				30, 4, 72, 77, 141, 164, 30, 4, 9, 0,
				72, 77, 109, 165, 30, 4, 72, 77, 141, 166,
				30, 4, 0, 0, 8, 0, 7, 9, 0, 0,
				48, 141, 141, 109, 167, 30, 5, 9, 0, 0,
				48, 141, 141, 109, 168, 30, 5, 0, 0, 8,
				0, 7, 9, 0, 0, 72, 109, 141, 169, 30,
				5, 9, 0, 0, 72, 109, 141, 170, 30, 5,
				0, 0, 1, 8, 0, 7, 9, 23, 77, 171,
				30, 4, 23, 109, 172, 30, 5, 23, 141, 173,
				30, 6, 9, 23, 77, 174, 30, 4, 23, 109,
				175, 30, 5, 23, 141, 176, 30, 6, 0, 0,
				8, 0, 7, 9, 23, 77, 177, 30, 4, 23,
				109, 178, 30, 5, 23, 141, 179, 30, 6, 9,
				23, 77, 180, 30, 4, 23, 109, 181, 30, 5,
				23, 141, 182, 30, 6, 0, 0, 1, 8, 0,
				7, 9, 46, 77, 191, 30, 4, 46, 109, 192,
				30, 5, 46, 141, 193, 30, 6, 0, 0, 0,
				8, 0, 7, 9, 0, 47, 109, 194, 30, 9,
				47, 141, 195, 30, 10, 9, 0, 47, 109, 196,
				30, 12, 47, 141, 197, 30, 13, 0, 0, 8,
				0, 9, 35, 77, 201, 30, 4, 35, 109, 202,
				30, 5, 35, 141, 203, 30, 6, 0, 0, 2,
				11, 0, 8, 0, 7, 10, 50, 77, 219, 30,
				8, 50, 109, 220, 30, 9, 50, 141, 221, 30,
				10, 10, 50, 77, 222, 30, 11, 50, 109, 223,
				30, 12, 50, 141, 224, 30, 13, 0, 0, 8,
				0, 7, 49, 77, 225, 30, 2, 49, 77, 226,
				30, 3, 0, 0, 1, 8, 0, 7, 10, 50,
				77, 227, 30, 8, 50, 109, 228, 30, 9, 50,
				141, 229, 30, 10, 10, 50, 77, 230, 30, 11,
				50, 109, 231, 30, 12, 50, 141, 232, 30, 13,
				0, 0, 8, 0, 7, 49, 77, 233, 30, 2,
				49, 77, 234, 30, 3, 0, 0, 8, 7, 10,
				61, 77, 184, 35, 16, 61, 109, 185, 35, 17,
				61, 141, 186, 35, 18, 0, 7, 10, 61, 77,
				235, 30, 8, 61, 109, 236, 30, 9, 61, 141,
				237, 30, 10, 10, 61, 77, 238, 30, 11, 61,
				109, 239, 30, 12, 61, 141, 240, 30, 13, 0,
				0, 8, 7, 49, 77, 187, 35, 1, 0, 7,
				49, 77, 241, 30, 2, 49, 77, 242, 30, 3,
				0, 0, 2, 14, 0, 8, 7, 9, 26, 77,
				148, 35, 16, 26, 109, 149, 35, 17, 26, 141,
				150, 35, 18, 0, 7, 9, 26, 77, 143, 31,
				8, 26, 109, 144, 31, 9, 26, 141, 145, 31,
				10, 9, 26, 77, 146, 31, 11, 26, 109, 147,
				31, 12, 26, 141, 148, 31, 13, 0, 0, 8,
				7, 25, 77, 151, 35, 1, 0, 7, 25, 77,
				149, 31, 2, 25, 77, 150, 31, 3, 0, 0,
				2, 8, 0, 8, 0, 7, 0, 9, 46, 77,
				175, 31, 4, 46, 109, 176, 31, 5, 46, 141,
				177, 31, 6, 0, 0, 8, 0, 7, 9, 47,
				77, 178, 31, 8, 47, 109, 179, 31, 9, 47,
				141, 180, 31, 10, 9, 47, 77, 181, 31, 11,
				47, 109, 182, 31, 12, 47, 141, 183, 31, 13,
				0, 0, 8, 0, 7, 0, 9, 46, 77, 184,
				31, 4, 46, 109, 185, 31, 5, 46, 141, 186,
				31, 6, 0, 0, 8, 0, 7, 9, 47, 77,
				187, 31, 8, 47, 109, 188, 31, 9, 47, 141,
				189, 31, 10, 9, 47, 77, 190, 31, 11, 47,
				109, 191, 31, 12, 47, 141, 192, 31, 13, 0,
				0, 2, 78, 0, 8, 7, 10, 22, 77, 231,
				33, 16, 22, 109, 232, 33, 17, 22, 141, 233,
				33, 18, 0, 0, 7, 21, 77, 234, 33, 1,
				0, 0, 2, 11, 0, 8, 0, 7, 0, 9,
				47, 77, 221, 31, 11, 47, 109, 222, 31, 12,
				47, 141, 223, 31, 13, 0, 0, 8, 0, 7,
				0, 9, 47, 77, 227, 31, 11, 47, 109, 228,
				31, 12, 47, 141, 229, 31, 13, 0, 0, 2,
				48, 0, 1, 128, 2, 2, 16, 0, 8, 0,
				0, 7, 5, 41, 77, 170, 35, 0, 52, 77,
				168, 35, 1, 0, 0, 8, 0, 0, 7, 5,
				68, 77, 171, 35, 71, 77, 169, 35, 1, 0,
				0, 0, 2, 11, 0, 8, 7, 44, 77, 153,
				34, 2, 0, 0, 7, 10, 57, 77, 77, 138,
				34, 8, 0, 57, 77, 109, 139, 34, 9, 0,
				57, 109, 141, 140, 34, 10, 0, 0, 0, 0,
				2, 12, 0, 8, 0, 0, 30, 77, 151, 34,
				2, 3, 0, 0, 8, 0, 0, 14, 77, 172,
				34, 1, 1, 0, 8, 0, 0, 14, 77, 146,
				34, 1, 0, 0, 8, 7, 66, 77, 208, 35,
				1, 0, 0, 0, 0, 8, 7, 66, 77, 235,
				33, 1, 0, 0, 0, 0, 2, 33, 0, 8,
				7, 10, 56, 77, 200, 35, 16, 0, 56, 109,
				201, 35, 17, 0, 56, 141, 202, 35, 18, 0,
				0, 0, 7, 44, 77, 203, 35, 1, 0, 0,
				0, 2, 6, 0, 8, 7, 10, 45, 77, 227,
				33, 16, 0, 45, 109, 228, 33, 17, 0, 45,
				141, 229, 33, 18, 0, 0, 0, 7, 44, 77,
				230, 33, 1, 0, 0, 0, 8, 7, 10, 45,
				77, 176, 35, 16, 0, 45, 109, 177, 35, 17,
				0, 45, 141, 178, 35, 18, 0, 0, 0, 7,
				44, 77, 179, 35, 1, 0, 0, 0, 8, 7,
				10, 57, 77, 77, 245, 33, 14, 1, 57, 109,
				77, 246, 33, 15, 1, 57, 141, 77, 247, 33,
				16, 1, 0, 7, 0, 10, 57, 77, 77, 239,
				33, 11, 0, 57, 77, 109, 240, 33, 12, 0,
				57, 77, 141, 241, 33, 13, 0, 7, 44, 77,
				145, 34, 1, 1, 0, 7, 0, 44, 77, 144,
				34, 3, 0, 8, 7, 10, 57, 77, 77, 236,
				33, 8, 0, 57, 77, 109, 237, 33, 9, 0,
				57, 109, 141, 238, 33, 10, 0, 10, 57, 77,
				77, 141, 34, 11, 0, 57, 77, 109, 142, 34,
				12, 0, 57, 77, 141, 143, 34, 13, 0, 7,
				10, 57, 77, 77, 242, 33, 15, 0, 57, 109,
				77, 243, 33, 16, 0, 57, 141, 109, 244, 33,
				17, 0, 0, 7, 10, 57, 77, 77, 154, 34,
				15, 1, 57, 109, 77, 155, 34, 16, 1, 57,
				141, 109, 156, 34, 17, 1, 0, 0, 8, 7,
				10, 45, 77, 204, 35, 16, 0, 45, 109, 205,
				35, 17, 0, 45, 141, 206, 35, 18, 0, 0,
				0, 7, 44, 77, 207, 35, 1, 0, 0, 0,
				8, 7, 10, 45, 77, 164, 35, 16, 1, 45,
				109, 165, 35, 17, 1, 45, 141, 166, 35, 18,
				1, 0, 0, 7, 44, 77, 167, 35, 1, 1,
				0, 0, 8, 7, 10, 45, 77, 190, 34, 16,
				0, 45, 109, 191, 34, 17, 0, 45, 141, 192,
				34, 18, 0, 0, 0, 7, 44, 77, 193, 34,
				1, 0, 0, 0, 8, 7, 10, 45, 77, 160,
				35, 16, 1, 45, 109, 161, 35, 17, 1, 45,
				141, 162, 35, 18, 1, 0, 0, 7, 44, 77,
				163, 35, 1, 1, 0, 0, 2, 14, 0, 8,
				0, 9, 67, 172, 35, 1, 1, 0, 0, 0,
				0, 2, 9, 0, 8, 7, 10, 57, 77, 77,
				160, 34, 15, 1, 57, 109, 77, 161, 34, 16,
				1, 57, 141, 109, 162, 34, 17, 1, 0, 7,
				10, 57, 77, 77, 163, 34, 14, 1, 57, 109,
				77, 164, 34, 15, 1, 57, 141, 77, 165, 34,
				16, 1, 0, 14, 77, 174, 34, 1, 1, 0,
				8, 7, 10, 57, 77, 77, 254, 33, 15, 0,
				57, 109, 77, 255, 33, 16, 0, 57, 141, 109,
				128, 34, 17, 0, 0, 7, 10, 57, 77, 77,
				129, 34, 14, 0, 57, 109, 77, 130, 34, 15,
				0, 57, 141, 77, 131, 34, 16, 0, 0, 14,
				77, 149, 34, 1, 0, 0, 8, 0, 7, 10,
				57, 77, 77, 157, 34, 14, 1, 57, 109, 77,
				158, 34, 15, 1, 57, 141, 77, 159, 34, 16,
				1, 0, 0, 7, 10, 57, 77, 77, 176, 34,
				8, 0, 57, 77, 109, 177, 34, 9, 0, 57,
				109, 141, 178, 34, 10, 0, 10, 57, 77, 77,
				179, 34, 11, 0, 57, 77, 109, 180, 34, 12,
				0, 57, 77, 141, 181, 34, 13, 0, 8, 0,
				7, 10, 57, 77, 77, 251, 33, 14, 0, 57,
				109, 77, 252, 33, 15, 0, 57, 141, 77, 253,
				33, 16, 0, 0, 30, 77, 182, 34, 2, 3,
				0, 8, 7, 10, 56, 77, 166, 34, 16, 1,
				56, 109, 167, 34, 17, 1, 56, 141, 168, 34,
				18, 1, 0, 7, 10, 56, 77, 169, 34, 16,
				1, 56, 109, 170, 34, 17, 1, 56, 141, 171,
				34, 18, 1, 0, 0, 0, 8, 7, 10, 56,
				77, 132, 34, 16, 0, 56, 109, 133, 34, 17,
				0, 56, 141, 134, 34, 18, 0, 0, 7, 10,
				56, 77, 135, 34, 16, 0, 56, 109, 136, 34,
				17, 0, 56, 141, 137, 34, 18, 0, 0, 7,
				10, 56, 77, 187, 34, 16, 0, 56, 109, 188,
				34, 17, 0, 56, 141, 189, 34, 18, 0, 0,
				7, 10, 56, 77, 184, 34, 16, 0, 56, 109,
				185, 34, 17, 0, 56, 141, 186, 34, 18, 0,
				0, 8, 0, 9, 12, 174, 35, 1, 1, 0,
				0, 0, 0, 2, 129, 1, 0, 1, 128, 2,
				2, 19, 0, 8, 7, 44, 77, 148, 34, 1,
				1, 0, 7, 10, 57, 77, 77, 248, 33, 15,
				1, 57, 109, 77, 249, 33, 16, 1, 57, 141,
				109, 250, 33, 17, 1, 0, 0, 0, 2, 24,
				0, 8, 0, 7, 10, 45, 77, 196, 35, 16,
				0, 45, 109, 197, 35, 17, 0, 45, 141, 198,
				35, 18, 0, 0, 0, 0, 8, 0, 7, 44,
				77, 199, 35, 1, 0, 0, 0, 0, 2, 20,
				0, 8, 0, 7, 10, 56, 77, 152, 35, 16,
				1, 56, 109, 153, 35, 17, 1, 56, 141, 154,
				35, 18, 1, 0, 0, 0, 8, 0, 7, 44,
				77, 155, 35, 1, 1, 0, 0, 0, 2, 8,
				0, 8, 0, 7, 9, 53, 77, 180, 35, 16,
				53, 109, 181, 35, 17, 53, 141, 182, 35, 18,
				0, 0, 0, 8, 0, 7, 41, 77, 183, 35,
				1, 0, 0, 0, 8, 0, 7, 9, 53, 77,
				192, 35, 16, 53, 109, 193, 35, 17, 53, 141,
				194, 35, 18, 0, 0, 0, 8, 0, 7, 41,
				77, 195, 35, 1, 0, 0, 0, 2, 6, 0,
				8, 0, 0, 7, 10, 76, 77, 197, 34, 8,
				76, 109, 198, 34, 9, 76, 141, 199, 34, 10,
				0, 7, 10, 76, 77, 194, 34, 8, 76, 109,
				195, 34, 9, 76, 141, 196, 34, 10, 0, 8,
				0, 0, 7, 75, 77, 201, 34, 2, 0, 7,
				75, 77, 200, 34, 2, 0, 2, 62, 0, 8,
				0, 7, 10, 45, 77, 210, 34, 16, 0, 45,
				109, 211, 34, 17, 0, 45, 141, 212, 34, 18,
				0, 0, 0, 0, 8, 0, 7, 10, 45, 77,
				219, 34, 16, 0, 45, 109, 220, 34, 17, 0,
				45, 141, 221, 34, 18, 0, 0, 0, 0, 8,
				0, 7, 10, 45, 77, 228, 34, 16, 0, 45,
				109, 229, 34, 17, 0, 45, 141, 230, 34, 18,
				0, 0, 0, 0, 8, 0, 7, 44, 77, 246,
				34, 1, 0, 0, 0, 0, 8, 0, 7, 10,
				45, 77, 252, 34, 16, 0, 45, 109, 253, 34,
				17, 0, 45, 141, 254, 34, 18, 0, 0, 0,
				0, 8, 0, 7, 44, 77, 142, 35, 1, 0,
				0, 0, 0, 8, 0, 7, 10, 45, 77, 237,
				34, 16, 0, 45, 109, 238, 34, 17, 0, 45,
				141, 239, 34, 18, 0, 0, 0, 0, 8, 0,
				7, 44, 77, 249, 34, 1, 0, 0, 0, 0,
				8, 0, 7, 10, 45, 77, 133, 35, 16, 0,
				45, 109, 134, 35, 17, 0, 45, 141, 135, 35,
				18, 0, 0, 0, 0, 8, 0, 7, 44, 77,
				145, 35, 1, 0, 0, 0, 0, 2, 6, 0,
				8, 0, 7, 10, 45, 77, 213, 34, 16, 0,
				45, 109, 214, 34, 17, 0, 45, 141, 215, 34,
				18, 0, 0, 0, 0, 8, 0, 7, 10, 45,
				77, 222, 34, 16, 0, 45, 109, 223, 34, 17,
				0, 45, 141, 224, 34, 18, 0, 0, 0, 0,
				8, 0, 7, 10, 45, 77, 231, 34, 16, 0,
				45, 109, 232, 34, 17, 0, 45, 141, 233, 34,
				18, 0, 0, 0, 0, 8, 0, 7, 44, 77,
				247, 34, 1, 0, 0, 0, 0, 8, 0, 7,
				10, 45, 77, 255, 34, 16, 0, 45, 109, 128,
				35, 17, 0, 45, 141, 129, 35, 18, 0, 0,
				0, 0, 8, 0, 7, 44, 77, 143, 35, 1,
				0, 0, 0, 0, 8, 0, 7, 10, 45, 77,
				240, 34, 16, 0, 45, 109, 241, 34, 17, 0,
				45, 141, 242, 34, 18, 0, 0, 0, 0, 8,
				0, 7, 44, 77, 250, 34, 1, 0, 0, 0,
				0, 8, 0, 7, 10, 45, 77, 136, 35, 16,
				0, 45, 109, 137, 35, 17, 0, 45, 141, 138,
				35, 18, 0, 0, 0, 0, 8, 0, 7, 44,
				77, 146, 35, 1, 0, 0, 0, 0, 2, 6,
				0, 8, 0, 7, 10, 45, 77, 216, 34, 16,
				0, 45, 109, 217, 34, 17, 0, 45, 141, 218,
				34, 18, 0, 0, 0, 0, 8, 0, 7, 10,
				45, 77, 225, 34, 16, 0, 45, 109, 226, 34,
				17, 0, 45, 141, 227, 34, 18, 0, 0, 0,
				0, 8, 0, 7, 10, 45, 77, 234, 34, 16,
				0, 45, 109, 235, 34, 17, 0, 45, 141, 236,
				34, 18, 0, 0, 0, 0, 8, 0, 7, 44,
				77, 248, 34, 1, 0, 0, 0, 0, 8, 0,
				7, 10, 45, 77, 130, 35, 16, 0, 45, 109,
				131, 35, 17, 0, 45, 141, 132, 35, 18, 0,
				0, 0, 0, 8, 0, 7, 44, 77, 144, 35,
				1, 0, 0, 0, 0, 8, 0, 7, 10, 45,
				77, 243, 34, 16, 0, 45, 109, 244, 34, 17,
				0, 45, 141, 245, 34, 18, 0, 0, 0, 0,
				8, 0, 7, 44, 77, 251, 34, 1, 0, 0,
				0, 0, 8, 0, 7, 10, 45, 77, 139, 35,
				16, 0, 45, 109, 140, 35, 17, 0, 45, 141,
				141, 35, 18, 0, 0, 0, 0, 8, 0, 7,
				44, 77, 147, 35, 1, 0, 0, 0, 0, 2,
				22, 0, 8, 0, 0, 7, 10, 76, 77, 205,
				34, 8, 76, 109, 206, 34, 9, 76, 141, 207,
				34, 10, 0, 7, 10, 76, 77, 202, 34, 8,
				76, 109, 203, 34, 9, 76, 141, 204, 34, 10,
				0, 8, 0, 0, 7, 75, 77, 209, 34, 2,
				0, 7, 75, 77, 208, 34, 2, 0, 2, 40,
				0, 1, 128, 2, 2, 16, 0, 8, 7, 9,
				52, 77, 128, 7, 4, 52, 109, 129, 7, 5,
				52, 141, 130, 7, 6, 0, 7, 0, 9, 52,
				77, 134, 7, 4, 52, 109, 135, 7, 5, 52,
				141, 136, 7, 6, 7, 5, 41, 77, 140, 7,
				0, 52, 77, 141, 7, 2, 0, 7, 0, 5,
				41, 77, 145, 7, 0, 52, 77, 146, 7, 3,
				8, 7, 9, 69, 77, 150, 7, 4, 69, 109,
				151, 7, 5, 69, 141, 152, 7, 6, 0, 7,
				0, 9, 69, 77, 156, 7, 4, 69, 109, 157,
				7, 5, 69, 141, 158, 7, 6, 7, 5, 68,
				77, 162, 7, 71, 77, 163, 7, 2, 0, 0,
				7, 0, 5, 68, 77, 167, 7, 71, 77, 168,
				7, 3, 0, 8, 7, 9, 34, 77, 173, 7,
				174, 7, 3, 0, 0, 0, 7, 0, 9, 32,
				77, 177, 7, 3, 0, 0, 7, 9, 52, 77,
				181, 7, 4, 52, 109, 182, 7, 5, 52, 141,
				183, 7, 6, 0, 7, 0, 9, 52, 77, 187,
				7, 3, 52, 109, 188, 7, 5, 52, 141, 189,
				7, 6, 8, 7, 9, 29, 77, 192, 7, 3,
				0, 0, 0, 7, 0, 9, 29, 77, 195, 7,
				3, 0, 0, 0, 0, 8, 7, 9, 42, 77,
				199, 7, 8, 42, 109, 200, 7, 9, 42, 141,
				201, 7, 10, 0, 7, 0, 9, 42, 77, 205,
				7, 11, 42, 109, 206, 7, 12, 42, 141, 207,
				7, 13, 0, 0, 8, 7, 9, 42, 77, 211,
				7, 8, 42, 109, 212, 7, 9, 42, 141, 213,
				7, 10, 0, 7, 0, 9, 42, 77, 217, 7,
				11, 42, 109, 218, 7, 12, 42, 141, 219, 7,
				13, 0, 0, 8, 7, 9, 34, 77, 222, 7,
				225, 7, 3, 0, 0, 0, 7, 0, 9, 32,
				77, 228, 7, 3, 0, 0, 7, 9, 52, 77,
				232, 7, 4, 52, 109, 233, 7, 5, 52, 141,
				234, 7, 6, 0, 0, 8, 7, 9, 29, 77,
				237, 7, 3, 0, 0, 0, 7, 0, 9, 29,
				77, 240, 7, 3, 0, 0, 0, 0, 2, 16,
				0, 8, 7, 9, 52, 77, 176, 8, 4, 52,
				109, 177, 8, 5, 52, 141, 178, 8, 6, 0,
				7, 0, 9, 52, 77, 182, 8, 4, 52, 109,
				183, 8, 5, 52, 141, 184, 8, 6, 0, 0,
				8, 7, 9, 69, 77, 188, 8, 4, 69, 109,
				189, 8, 5, 69, 141, 190, 8, 6, 0, 7,
				0, 9, 69, 77, 194, 8, 4, 69, 109, 195,
				8, 5, 69, 141, 196, 8, 6, 0, 0, 8,
				0, 0, 30, 77, 203, 8, 2, 3, 30, 77,
				209, 8, 2, 3, 8, 7, 9, 29, 77, 214,
				8, 4, 29, 109, 215, 8, 5, 29, 141, 216,
				8, 6, 0, 7, 0, 9, 29, 77, 220, 8,
				4, 29, 109, 221, 8, 5, 29, 141, 222, 8,
				6, 0, 0, 8, 0, 0, 14, 77, 231, 8,
				2, 1, 14, 77, 237, 8, 3, 1, 8, 0,
				0, 14, 77, 245, 8, 2, 0, 14, 77, 251,
				8, 3, 0, 8, 7, 66, 77, 255, 8, 2,
				0, 7, 0, 66, 77, 130, 9, 3, 0, 0,
				8, 7, 66, 77, 135, 9, 2, 0, 7, 0,
				66, 77, 136, 9, 3, 0, 0, 2, 33, 0,
				8, 7, 10, 56, 77, 239, 9, 8, 0, 56,
				109, 240, 9, 9, 0, 56, 141, 241, 9, 10,
				0, 0, 7, 0, 10, 56, 77, 245, 9, 11,
				0, 56, 109, 246, 9, 12, 0, 56, 141, 247,
				9, 13, 0, 7, 44, 77, 250, 9, 2, 0,
				0, 7, 0, 44, 77, 253, 9, 3, 0, 1,
				8, 7, 9, 42, 77, 139, 10, 8, 42, 109,
				140, 10, 9, 42, 141, 141, 10, 10, 0, 7,
				0, 9, 42, 77, 145, 10, 11, 42, 109, 146,
				10, 12, 42, 141, 147, 10, 13, 0, 0, 8,
				7, 9, 42, 77, 151, 10, 8, 42, 109, 152,
				10, 9, 42, 141, 153, 10, 10, 0, 7, 0,
				9, 42, 77, 157, 10, 11, 42, 109, 158, 10,
				12, 42, 141, 159, 10, 13, 0, 0, 8, 7,
				9, 42, 77, 163, 10, 8, 42, 109, 164, 10,
				9, 42, 141, 165, 10, 10, 0, 7, 0, 9,
				42, 77, 169, 10, 11, 42, 109, 170, 10, 12,
				42, 141, 171, 10, 13, 0, 0, 8, 7, 9,
				42, 77, 175, 10, 8, 42, 109, 176, 10, 9,
				42, 141, 177, 10, 10, 0, 7, 0, 9, 42,
				77, 181, 10, 11, 42, 109, 182, 10, 12, 42,
				141, 183, 10, 13, 0, 0, 8, 7, 10, 45,
				77, 187, 10, 8, 0, 45, 109, 188, 10, 9,
				0, 45, 141, 189, 10, 10, 0, 0, 7, 0,
				10, 45, 77, 193, 10, 11, 0, 45, 109, 194,
				10, 12, 0, 45, 141, 195, 10, 13, 0, 7,
				44, 77, 198, 10, 2, 0, 0, 7, 0, 44,
				77, 201, 10, 3, 0, 8, 7, 10, 45, 77,
				205, 10, 8, 0, 45, 109, 206, 10, 9, 0,
				45, 141, 207, 10, 10, 0, 0, 7, 0, 10,
				45, 77, 211, 10, 11, 0, 45, 109, 212, 10,
				12, 0, 45, 141, 213, 10, 13, 0, 7, 44,
				77, 216, 10, 2, 0, 0, 7, 0, 44, 77,
				219, 10, 3, 0, 8, 7, 10, 57, 77, 77,
				223, 10, 7, 1, 57, 109, 77, 224, 10, 8,
				1, 57, 141, 109, 225, 10, 9, 1, 0, 7,
				0, 10, 57, 77, 77, 229, 10, 11, 0, 57,
				77, 109, 230, 10, 12, 0, 57, 109, 141, 231,
				10, 13, 0, 7, 44, 77, 234, 10, 2, 1,
				0, 7, 0, 44, 77, 237, 10, 3, 0, 8,
				7, 10, 56, 77, 241, 10, 8, 0, 56, 109,
				242, 10, 9, 0, 56, 141, 243, 10, 10, 0,
				10, 57, 77, 77, 244, 10, 11, 0, 57, 77,
				109, 245, 10, 12, 0, 57, 109, 141, 246, 10,
				13, 0, 7, 10, 56, 77, 250, 10, 8, 0,
				56, 109, 251, 10, 9, 0, 56, 141, 252, 10,
				10, 0, 0, 7, 10, 56, 77, 128, 11, 8,
				1, 56, 109, 129, 11, 9, 1, 56, 141, 130,
				11, 10, 1, 0, 0, 8, 7, 10, 45, 77,
				134, 11, 8, 0, 45, 109, 135, 11, 9, 0,
				45, 141, 136, 11, 10, 0, 0, 7, 0, 10,
				45, 77, 140, 11, 11, 0, 45, 109, 141, 11,
				12, 0, 45, 141, 142, 11, 13, 0, 7, 44,
				77, 145, 11, 2, 0, 0, 7, 0, 44, 77,
				148, 11, 3, 0, 8, 7, 10, 45, 77, 152,
				11, 8, 1, 45, 109, 153, 11, 9, 1, 45,
				141, 154, 11, 10, 1, 0, 7, 0, 10, 45,
				77, 158, 11, 11, 1, 45, 109, 159, 11, 12,
				1, 45, 141, 160, 11, 13, 1, 7, 44, 77,
				163, 11, 2, 1, 0, 7, 0, 44, 77, 166,
				11, 3, 1, 8, 7, 10, 45, 77, 170, 11,
				8, 0, 45, 109, 171, 11, 9, 0, 45, 141,
				172, 11, 10, 0, 0, 7, 0, 10, 45, 77,
				176, 11, 11, 0, 45, 109, 177, 11, 12, 0,
				45, 141, 178, 11, 13, 0, 7, 44, 77, 181,
				11, 2, 0, 0, 7, 0, 44, 77, 184, 11,
				3, 0, 8, 7, 10, 45, 77, 188, 11, 8,
				1, 45, 109, 189, 11, 9, 1, 45, 141, 190,
				11, 10, 1, 0, 7, 0, 10, 45, 77, 194,
				11, 11, 1, 45, 109, 195, 11, 12, 1, 45,
				141, 196, 11, 13, 1, 7, 44, 77, 199, 11,
				2, 1, 0, 7, 0, 44, 77, 202, 11, 3,
				1, 8, 0, 9, 41, 77, 207, 11, 4, 41,
				109, 208, 11, 5, 41, 141, 209, 11, 6, 0,
				0, 8, 0, 9, 41, 77, 214, 11, 4, 41,
				109, 215, 11, 5, 41, 141, 216, 11, 6, 0,
				0, 8, 0, 7, 9, 42, 77, 221, 11, 8,
				42, 109, 222, 11, 9, 42, 141, 223, 11, 10,
				0, 0, 0, 8, 0, 9, 41, 77, 228, 11,
				4, 41, 109, 229, 11, 5, 41, 141, 230, 11,
				6, 0, 0, 8, 0, 9, 19, 77, 235, 11,
				4, 19, 109, 236, 11, 5, 19, 141, 237, 11,
				6, 0, 0, 8, 0, 9, 19, 77, 242, 11,
				4, 19, 109, 243, 11, 5, 19, 141, 244, 11,
				6, 0, 0, 8, 0, 7, 9, 20, 77, 249,
				11, 8, 20, 109, 250, 11, 9, 20, 141, 251,
				11, 10, 0, 0, 0, 8, 0, 9, 41, 77,
				128, 12, 4, 41, 109, 129, 12, 5, 41, 141,
				130, 12, 6, 0, 0, 8, 0, 9, 41, 77,
				135, 12, 4, 41, 109, 136, 12, 5, 41, 141,
				137, 12, 6, 0, 0, 8, 0, 9, 41, 77,
				142, 12, 4, 41, 109, 143, 12, 5, 41, 141,
				144, 12, 6, 0, 0, 8, 0, 7, 9, 42,
				77, 149, 12, 8, 42, 109, 150, 12, 9, 42,
				141, 151, 12, 10, 0, 0, 0, 8, 0, 7,
				9, 42, 77, 156, 12, 8, 42, 109, 157, 12,
				9, 42, 141, 158, 12, 10, 0, 0, 0, 8,
				0, 7, 0, 9, 42, 77, 162, 12, 11, 42,
				109, 163, 12, 12, 42, 141, 164, 12, 13, 0,
				0, 8, 0, 7, 0, 9, 42, 77, 168, 12,
				11, 42, 109, 169, 12, 12, 42, 141, 170, 12,
				13, 0, 0, 8, 0, 9, 67, 177, 12, 2,
				3, 0, 0, 0, 0, 8, 0, 7, 9, 52,
				77, 183, 12, 4, 52, 109, 184, 12, 5, 52,
				141, 185, 12, 6, 9, 52, 77, 186, 12, 4,
				52, 109, 187, 12, 5, 52, 141, 188, 12, 6,
				7, 9, 52, 77, 192, 12, 4, 52, 109, 193,
				12, 5, 52, 141, 194, 12, 6, 9, 52, 77,
				195, 12, 4, 52, 109, 196, 12, 5, 52, 141,
				197, 12, 6, 7, 9, 52, 77, 198, 12, 4,
				52, 109, 199, 12, 5, 52, 141, 200, 12, 6,
				9, 52, 77, 201, 12, 4, 52, 109, 202, 12,
				5, 52, 141, 203, 12, 6, 8, 0, 7, 9,
				60, 77, 208, 12, 8, 60, 109, 209, 12, 9,
				60, 141, 210, 12, 10, 0, 9, 59, 77, 214,
				12, 4, 59, 109, 215, 12, 5, 59, 141, 216,
				12, 6, 9, 59, 77, 220, 12, 4, 59, 109,
				221, 12, 5, 59, 141, 222, 12, 6, 6, 4,
				0, 6, 4, 1, 6, 4, 2, 8, 0, 9,
				19, 77, 182, 13, 4, 19, 109, 183, 13, 5,
				19, 141, 184, 13, 6, 0, 0, 8, 0, 9,
				19, 77, 189, 13, 4, 19, 109, 190, 13, 5,
				19, 141, 191, 13, 6, 0, 0, 8, 0, 7,
				9, 20, 77, 196, 13, 8, 20, 109, 197, 13,
				9, 20, 141, 198, 13, 10, 0, 0, 0, 0,
				8, 7, 10, 57, 77, 77, 204, 13, 8, 1,
				57, 109, 109, 205, 13, 9, 1, 57, 141, 141,
				206, 13, 10, 1, 10, 57, 77, 77, 207, 13,
				11, 1, 57, 77, 109, 208, 13, 12, 1, 57,
				109, 141, 209, 13, 13, 1, 7, 10, 57, 77,
				77, 211, 13, 7, 1, 57, 109, 77, 212, 13,
				8, 1, 57, 141, 109, 213, 13, 9, 1, 10,
				57, 77, 77, 214, 13, 11, 1, 57, 109, 109,
				215, 13, 12, 1, 57, 141, 141, 216, 13, 13,
				1, 14, 77, 217, 13, 2, 1, 14, 77, 220,
				13, 3, 1, 8, 7, 10, 57, 77, 77, 224,
				13, 8, 0, 57, 109, 109, 225, 13, 9, 0,
				57, 141, 141, 226, 13, 10, 0, 10, 57, 77,
				77, 227, 13, 11, 0, 57, 77, 109, 228, 13,
				12, 0, 57, 109, 141, 229, 13, 13, 0, 7,
				10, 57, 77, 77, 231, 13, 7, 0, 57, 109,
				77, 232, 13, 8, 0, 57, 141, 109, 233, 13,
				9, 0, 10, 57, 77, 77, 234, 13, 11, 0,
				57, 109, 109, 235, 13, 12, 0, 57, 141, 141,
				236, 13, 13, 0, 14, 77, 237, 13, 2, 0,
				14, 77, 240, 13, 3, 0, 8, 0, 7, 10,
				57, 77, 77, 242, 13, 7, 1, 57, 109, 77,
				243, 13, 8, 1, 57, 141, 109, 244, 13, 9,
				1, 10, 57, 77, 77, 245, 13, 11, 1, 57,
				109, 109, 246, 13, 12, 1, 57, 141, 141, 247,
				13, 13, 1, 7, 10, 57, 77, 77, 248, 13,
				7, 0, 57, 109, 77, 249, 13, 8, 0, 57,
				141, 109, 250, 13, 9, 0, 10, 57, 77, 77,
				251, 13, 11, 0, 57, 109, 109, 252, 13, 12,
				0, 57, 141, 141, 253, 13, 13, 0, 7, 10,
				57, 77, 77, 254, 13, 8, 0, 57, 109, 109,
				255, 13, 9, 0, 57, 141, 141, 128, 14, 10,
				0, 10, 57, 77, 77, 129, 14, 11, 0, 57,
				77, 109, 130, 14, 12, 0, 57, 109, 141, 131,
				14, 13, 0, 8, 0, 7, 10, 57, 77, 77,
				132, 14, 7, 0, 57, 109, 77, 133, 14, 8,
				0, 57, 141, 109, 134, 14, 9, 0, 10, 57,
				77, 77, 135, 14, 11, 0, 57, 109, 109, 136,
				14, 12, 0, 57, 141, 141, 137, 14, 13, 0,
				30, 77, 138, 14, 2, 3, 30, 77, 140, 14,
				2, 3, 1, 8, 0, 9, 12, 160, 14, 2,
				3, 0, 0, 7, 0, 9, 65, 77, 164, 14,
				3, 0, 0, 0, 8, 0, 7, 9, 69, 77,
				169, 14, 4, 69, 109, 170, 14, 5, 69, 141,
				171, 14, 6, 9, 69, 77, 172, 14, 4, 69,
				109, 173, 14, 5, 69, 141, 174, 14, 6, 7,
				9, 69, 77, 178, 14, 4, 69, 109, 179, 14,
				5, 69, 141, 180, 14, 6, 9, 69, 77, 181,
				14, 4, 69, 109, 182, 14, 5, 69, 141, 183,
				14, 6, 7, 9, 69, 77, 184, 14, 4, 69,
				109, 185, 14, 5, 69, 141, 186, 14, 6, 9,
				69, 77, 187, 14, 4, 69, 109, 188, 14, 5,
				69, 141, 189, 14, 6, 2, 66, 0, 8, 7,
				10, 22, 77, 223, 16, 8, 22, 109, 224, 16,
				9, 22, 141, 225, 16, 10, 0, 7, 0, 10,
				22, 77, 229, 16, 11, 22, 109, 230, 16, 12,
				22, 141, 231, 16, 13, 7, 21, 77, 234, 16,
				2, 0, 7, 0, 21, 77, 237, 16, 3, 0,
				8, 0, 7, 9, 31, 77, 246, 16, 1, 1,
				0, 0, 9, 31, 77, 246, 16, 1, 1, 0,
				0, 0, 0, 8, 0, 7, 9, 5, 13, 77,
				254, 16, 0, 0, 0, 9, 5, 13, 77, 254,
				16, 0, 0, 0, 0, 0, 8, 7, 9, 47,
				77, 131, 17, 8, 47, 109, 132, 17, 9, 47,
				141, 133, 17, 10, 0, 7, 0, 9, 47, 77,
				137, 17, 11, 47, 109, 138, 17, 12, 47, 141,
				139, 17, 13, 0, 0, 2, 10, 0, 8, 0,
				9, 43, 77, 77, 77, 173, 17, 4, 43, 109,
				109, 77, 174, 17, 4, 43, 141, 141, 77, 175,
				17, 4, 0, 0, 8, 0, 7, 9, 43, 77,
				77, 77, 180, 17, 4, 43, 109, 109, 77, 181,
				17, 4, 43, 141, 141, 77, 182, 17, 4, 0,
				0, 0, 8, 0, 7, 0, 9, 43, 77, 77,
				77, 187, 17, 4, 43, 109, 109, 77, 188, 17,
				4, 43, 141, 141, 77, 189, 17, 4, 0, 0,
				8, 0, 7, 0, 9, 42, 77, 194, 17, 11,
				42, 109, 195, 17, 12, 42, 141, 196, 17, 13,
				0, 0, 8, 0, 9, 41, 77, 201, 17, 4,
				41, 109, 202, 17, 5, 41, 141, 203, 17, 6,
				0, 0, 8, 0, 7, 0, 9, 74, 77, 206,
				17, 3, 0, 0, 0, 0, 0, 8, 0, 9,
				41, 77, 221, 17, 4, 41, 109, 222, 17, 5,
				41, 141, 223, 17, 6, 0, 0, 8, 0, 9,
				41, 77, 228, 17, 4, 41, 109, 229, 17, 5,
				41, 141, 230, 17, 6, 0, 0, 8, 0, 9,
				41, 77, 235, 17, 4, 41, 109, 236, 17, 5,
				41, 141, 237, 17, 6, 0, 0, 8, 0, 7,
				9, 42, 77, 242, 17, 8, 42, 109, 243, 17,
				9, 42, 141, 244, 17, 10, 9, 42, 77, 245,
				17, 11, 42, 109, 246, 17, 12, 42, 141, 247,
				17, 13, 0, 0, 8, 0, 9, 41, 77, 252,
				17, 4, 41, 109, 253, 17, 5, 41, 141, 254,
				17, 6, 0, 0, 8, 0, 9, 41, 77, 131,
				18, 4, 41, 109, 132, 18, 5, 41, 141, 133,
				18, 6, 0, 0, 8, 0, 9, 41, 77, 138,
				18, 4, 41, 109, 139, 18, 5, 41, 141, 140,
				18, 6, 0, 0, 8, 0, 7, 9, 42, 77,
				145, 18, 8, 42, 109, 146, 18, 9, 42, 141,
				147, 18, 10, 9, 42, 77, 148, 18, 11, 42,
				109, 149, 18, 12, 42, 141, 150, 18, 13, 0,
				0, 8, 0, 9, 41, 77, 155, 18, 4, 41,
				109, 156, 18, 5, 41, 141, 157, 18, 6, 0,
				0, 8, 0, 9, 43, 77, 77, 77, 162, 18,
				4, 43, 109, 109, 77, 163, 18, 4, 43, 141,
				141, 77, 164, 18, 4, 0, 0, 8, 0, 7,
				9, 43, 77, 77, 77, 169, 18, 4, 43, 109,
				109, 77, 170, 18, 4, 43, 141, 141, 77, 171,
				18, 4, 9, 43, 77, 77, 77, 172, 18, 4,
				43, 109, 109, 77, 173, 18, 4, 43, 141, 141,
				77, 174, 18, 4, 0, 0, 8, 0, 9, 41,
				77, 179, 18, 4, 41, 109, 180, 18, 5, 41,
				141, 181, 18, 6, 0, 0, 8, 0, 9, 41,
				77, 186, 18, 4, 41, 109, 187, 18, 5, 41,
				141, 188, 18, 6, 0, 0, 8, 0, 9, 41,
				77, 193, 18, 4, 41, 109, 194, 18, 5, 41,
				141, 195, 18, 6, 0, 0, 8, 0, 7, 0,
				10, 57, 77, 77, 199, 18, 11, 1, 57, 77,
				109, 200, 18, 12, 1, 57, 109, 141, 201, 18,
				13, 1, 7, 10, 57, 77, 77, 205, 18, 7,
				0, 57, 109, 77, 206, 18, 8, 0, 57, 141,
				109, 207, 18, 9, 0, 10, 57, 77, 77, 208,
				18, 11, 0, 57, 109, 109, 209, 18, 12, 0,
				57, 141, 141, 210, 18, 13, 0, 7, 0, 10,
				57, 77, 77, 214, 18, 11, 0, 57, 77, 109,
				215, 18, 12, 0, 57, 109, 141, 216, 18, 13,
				0, 8, 0, 7, 9, 29, 77, 221, 18, 4,
				29, 109, 222, 18, 5, 29, 141, 223, 18, 6,
				0, 0, 0, 8, 0, 9, 41, 77, 228, 18,
				4, 41, 109, 229, 18, 5, 41, 141, 230, 18,
				6, 0, 0, 8, 0, 9, 41, 77, 235, 18,
				4, 41, 109, 236, 18, 5, 41, 141, 237, 18,
				6, 0, 0, 8, 0, 9, 41, 77, 242, 18,
				4, 41, 109, 243, 18, 5, 41, 141, 244, 18,
				6, 0, 0, 8, 0, 7, 9, 42, 77, 249,
				18, 8, 42, 109, 250, 18, 9, 42, 141, 251,
				18, 10, 9, 42, 77, 252, 18, 11, 42, 109,
				253, 18, 12, 42, 141, 254, 18, 13, 0, 0,
				8, 0, 9, 41, 77, 131, 19, 4, 41, 109,
				132, 19, 5, 41, 141, 133, 19, 6, 0, 0,
				8, 0, 9, 41, 77, 138, 19, 4, 41, 109,
				139, 19, 5, 41, 141, 140, 19, 6, 0, 0,
				8, 0, 9, 41, 77, 145, 19, 4, 41, 109,
				146, 19, 5, 41, 141, 147, 19, 6, 0, 0,
				8, 0, 7, 9, 42, 77, 152, 19, 8, 42,
				109, 153, 19, 9, 42, 141, 154, 19, 10, 9,
				42, 77, 155, 19, 11, 42, 109, 156, 19, 12,
				42, 141, 157, 19, 13, 0, 0, 0, 8, 0,
				9, 43, 77, 77, 77, 165, 19, 4, 43, 109,
				109, 77, 166, 19, 4, 43, 141, 141, 77, 167,
				19, 4, 0, 0, 8, 0, 7, 9, 43, 77,
				77, 77, 172, 19, 4, 43, 109, 109, 77, 173,
				19, 4, 43, 141, 141, 77, 174, 19, 4, 0,
				0, 0, 8, 0, 7, 0, 9, 43, 77, 77,
				77, 179, 19, 4, 43, 109, 109, 77, 180, 19,
				4, 43, 141, 141, 77, 181, 19, 4, 0, 0,
				8, 0, 7, 0, 9, 42, 77, 186, 19, 11,
				42, 109, 187, 19, 12, 42, 141, 188, 19, 13,
				0, 0, 8, 0, 9, 41, 77, 193, 19, 4,
				41, 109, 194, 19, 5, 41, 141, 195, 19, 6,
				0, 0, 8, 0, 9, 33, 77, 200, 19, 4,
				33, 109, 201, 19, 5, 33, 141, 202, 19, 6,
				0, 0, 0, 8, 0, 9, 41, 77, 210, 19,
				4, 41, 109, 211, 19, 5, 41, 141, 212, 19,
				6, 0, 0, 8, 0, 9, 41, 77, 217, 19,
				4, 41, 109, 218, 19, 5, 41, 141, 219, 19,
				6, 0, 0, 8, 0, 7, 9, 42, 77, 224,
				19, 8, 42, 109, 225, 19, 9, 42, 141, 226,
				19, 10, 0, 0, 0, 8, 0, 7, 0, 9,
				42, 77, 231, 19, 11, 42, 109, 232, 19, 12,
				42, 141, 233, 19, 13, 0, 0, 8, 0, 9,
				41, 77, 238, 19, 4, 41, 109, 239, 19, 5,
				41, 141, 240, 19, 6, 0, 0, 8, 0, 9,
				41, 77, 245, 19, 4, 41, 109, 246, 19, 5,
				41, 141, 247, 19, 6, 0, 0, 8, 0, 7,
				9, 42, 77, 252, 19, 8, 42, 109, 253, 19,
				9, 42, 141, 254, 19, 10, 0, 0, 0, 0
			};
		}
	}
	internal static class OpCodeHandlersTables_Legacy
	{
		internal static readonly OpCodeHandler[] Handlers_MAP0;

		private const int MaxIdNames = 82;

		private const uint Handlers_MAP0Index = 81u;

		static OpCodeHandlersTables_Legacy()
		{
			LegacyOpCodeHandlerReader handlerReader = new LegacyOpCodeHandlerReader();
			TableDeserializer tableDeserializer = new TableDeserializer(handlerReader, 82, GetSerializedTables());
			tableDeserializer.Deserialize();
			Handlers_MAP0 = tableDeserializer.GetTable(81u);
		}

		private static ReadOnlySpan<byte> GetSerializedTables()
		{
			return new byte[6392]
			{
				1, 8, 115, 238, 3, 115, 239, 3, 115, 240,
				3, 115, 241, 3, 115, 242, 3, 115, 243, 3,
				115, 244, 3, 115, 245, 3, 1, 8, 174, 246,
				3, 174, 247, 3, 174, 248, 3, 174, 249, 3,
				174, 250, 3, 174, 251, 3, 174, 252, 3, 174,
				253, 3, 1, 8, 115, 254, 3, 2, 115, 255,
				3, 115, 128, 4, 116, 129, 4, 115, 131, 4,
				117, 132, 4, 134, 4, 115, 136, 4, 1, 64,
				5, 8, 175, 138, 4, 5, 8, 174, 139, 4,
				164, 140, 4, 5, 6, 2, 200, 2, 164, 171,
				33, 128, 128, 64, 5, 8, 175, 141, 4, 164,
				142, 4, 164, 143, 4, 200, 2, 164, 172, 33,
				128, 128, 64, 2, 164, 144, 4, 164, 145, 4,
				200, 2, 164, 173, 33, 128, 128, 64, 200, 2,
				164, 174, 33, 128, 128, 64, 164, 146, 4, 164,
				147, 4, 164, 148, 4, 164, 149, 4, 164, 150,
				4, 164, 151, 4, 164, 152, 4, 2, 164, 153,
				4, 164, 154, 4, 164, 155, 4, 164, 156, 4,
				164, 157, 4, 164, 158, 4, 164, 159, 4, 164,
				160, 4, 164, 161, 4, 164, 162, 4, 164, 163,
				4, 164, 164, 4, 164, 165, 4, 164, 166, 4,
				164, 167, 4, 164, 168, 4, 1, 8, 115, 169,
				4, 115, 170, 4, 115, 171, 4, 115, 172, 4,
				115, 173, 4, 115, 174, 4, 115, 175, 4, 115,
				176, 4, 1, 64, 5, 8, 174, 177, 4, 5,
				8, 174, 178, 4, 5, 8, 174, 179, 4, 5,
				8, 174, 180, 4, 5, 9, 2, 164, 181, 4,
				5, 22, 2, 1, 8, 115, 182, 4, 115, 183,
				4, 115, 184, 4, 115, 185, 4, 2, 115, 186,
				4, 2, 115, 187, 4, 1, 64, 5, 8, 174,
				188, 4, 5, 8, 174, 189, 4, 5, 8, 174,
				190, 4, 5, 8, 174, 191, 4, 164, 192, 4,
				164, 194, 4, 164, 196, 4, 164, 198, 4, 164,
				200, 4, 0, 10, 2, 164, 202, 4, 64, 2,
				4, 5, 8, 174, 203, 4, 5, 8, 174, 204,
				4, 5, 4, 2, 200, 2, 164, 175, 33, 128,
				128, 64, 5, 3, 2, 1, 8, 115, 205, 4,
				115, 206, 4, 115, 207, 4, 115, 208, 4, 115,
				209, 4, 115, 210, 4, 115, 211, 4, 115, 212,
				4, 1, 8, 176, 213, 4, 176, 214, 4, 174,
				215, 4, 174, 216, 4, 176, 217, 4, 176, 218,
				4, 176, 219, 4, 176, 220, 4, 1, 8, 115,
				221, 4, 115, 222, 4, 115, 223, 4, 115, 224,
				4, 116, 225, 4, 2, 117, 227, 4, 229, 4,
				115, 231, 4, 1, 64, 5, 8, 175, 233, 4,
				5, 8, 174, 234, 4, 5, 8, 175, 235, 4,
				5, 8, 175, 236, 4, 5, 8, 174, 237, 4,
				5, 8, 174, 238, 4, 5, 12, 2, 200, 2,
				164, 176, 33, 128, 128, 64, 5, 3, 2, 1,
				8, 115, 239, 4, 115, 240, 4, 115, 241, 4,
				115, 242, 4, 115, 243, 4, 115, 244, 4, 115,
				245, 4, 115, 246, 4, 1, 64, 5, 8, 176,
				247, 4, 5, 8, 176, 248, 4, 5, 8, 174,
				249, 4, 200, 2, 164, 177, 33, 128, 128, 64,
				164, 250, 4, 200, 2, 164, 178, 33, 128, 128,
				64, 2, 200, 2, 164, 179, 33, 128, 128, 64,
				200, 2, 164, 180, 33, 128, 128, 64, 200, 2,
				164, 181, 33, 128, 128, 64, 2, 5, 8, 176,
				251, 4, 5, 8, 176, 252, 4, 5, 8, 176,
				253, 4, 5, 8, 176, 254, 4, 1, 8, 115,
				255, 4, 115, 128, 5, 115, 129, 5, 115, 130,
				5, 115, 131, 5, 115, 132, 5, 115, 133, 5,
				115, 134, 5, 1, 64, 5, 8, 175, 135, 5,
				5, 8, 174, 136, 5, 5, 8, 175, 137, 5,
				5, 8, 175, 138, 5, 145, 139, 5, 21, 0,
				10, 2, 145, 140, 33, 21, 64, 2, 0, 10,
				2, 145, 141, 33, 21, 64, 2, 5, 5, 2,
				5, 8, 174, 143, 5, 5, 8, 174, 144, 5,
				5, 4, 2, 200, 2, 164, 182, 33, 128, 128,
				64, 5, 3, 2, 1, 8, 46, 207, 1, 11,
				46, 208, 1, 11, 46, 209, 1, 11, 46, 210,
				1, 11, 46, 211, 1, 11, 46, 212, 1, 11,
				46, 213, 1, 11, 45, 214, 1, 1, 8, 66,
				215, 1, 11, 66, 218, 1, 11, 66, 221, 1,
				11, 66, 224, 1, 11, 66, 227, 1, 11, 66,
				230, 1, 11, 66, 233, 1, 11, 65, 236, 1,
				1, 8, 46, 239, 1, 11, 46, 240, 1, 11,
				46, 241, 1, 11, 46, 242, 1, 11, 46, 243,
				1, 11, 46, 244, 1, 11, 46, 245, 1, 11,
				45, 246, 1, 1, 8, 62, 247, 1, 11, 62,
				250, 1, 11, 62, 253, 1, 11, 62, 128, 2,
				11, 62, 131, 2, 11, 62, 134, 2, 11, 62,
				137, 2, 11, 61, 140, 2, 1, 8, 133, 168,
				2, 5, 7, 2, 1, 8, 45, 231, 2, 45,
				232, 2, 45, 233, 2, 45, 234, 2, 45, 235,
				2, 45, 236, 2, 45, 237, 2, 45, 238, 2,
				1, 8, 63, 239, 2, 63, 242, 2, 63, 245,
				2, 63, 248, 2, 63, 251, 2, 63, 254, 2,
				63, 129, 3, 63, 132, 3, 1, 8, 47, 170,
				3, 47, 171, 3, 47, 172, 3, 47, 173, 3,
				47, 174, 3, 47, 175, 3, 47, 176, 3, 47,
				177, 3, 1, 8, 71, 178, 3, 71, 181, 3,
				71, 184, 3, 71, 187, 3, 71, 190, 3, 71,
				193, 3, 71, 196, 3, 71, 199, 3, 1, 8,
				42, 202, 3, 42, 203, 3, 42, 204, 3, 42,
				205, 3, 42, 206, 3, 42, 207, 3, 42, 208,
				3, 42, 209, 3, 1, 8, 53, 210, 3, 53,
				213, 3, 53, 216, 3, 53, 219, 3, 53, 222,
				3, 53, 225, 3, 53, 228, 3, 53, 231, 3,
				1, 8, 45, 199, 5, 45, 200, 5, 41, 201,
				5, 11, 41, 202, 5, 11, 40, 203, 5, 40,
				204, 5, 40, 205, 5, 40, 206, 5, 1, 8,
				65, 207, 5, 65, 210, 5, 52, 213, 5, 11,
				52, 216, 5, 11, 50, 219, 5, 50, 222, 5,
				50, 225, 5, 50, 228, 5, 1, 8, 41, 237,
				5, 11, 41, 238, 5, 11, 5, 6, 2, 1,
				8, 52, 239, 5, 11, 52, 242, 5, 11, 72,
				245, 5, 49, 248, 5, 72, 251, 5, 49, 254,
				5, 133, 129, 6, 2, 1, 8, 73, 132, 6,
				73, 135, 6, 74, 138, 6, 74, 141, 6, 74,
				144, 6, 74, 147, 6, 12, 17, 2, 2, 2,
				1, 2, 73, 222, 33, 1, 51, 150, 6, 17,
				2, 2, 2, 1, 2, 73, 222, 33, 128, 32,
				2, 1, 8, 9, 2, 120, 152, 6, 9, 2,
				120, 155, 6, 9, 2, 120, 158, 6, 9, 2,
				120, 161, 6, 73, 164, 6, 17, 2, 2, 110,
				167, 6, 2, 73, 168, 6, 110, 171, 6, 1,
				64, 20, 164, 172, 6, 3, 3, 3, 20, 164,
				173, 6, 3, 3, 3, 20, 164, 174, 6, 3,
				3, 3, 20, 164, 175, 6, 3, 3, 3, 20,
				164, 176, 6, 3, 3, 3, 20, 164, 177, 6,
				3, 3, 3, 20, 164, 226, 37, 3, 0, 3,
				164, 227, 37, 0, 3, 164, 228, 37, 20, 0,
				3, 164, 177, 38, 3, 3, 3, 20, 171, 178,
				6, 3, 3, 3, 20, 164, 181, 6, 3, 3,
				3, 20, 164, 182, 6, 3, 0, 3, 164, 225,
				33, 0, 3, 164, 226, 33, 20, 164, 183, 6,
				3, 3, 3, 20, 3, 164, 183, 33, 3, 3,
				20, 3, 0, 3, 164, 184, 33, 3, 3, 20,
				3, 0, 3, 164, 185, 33, 3, 3, 20, 164,
				184, 6, 0, 3, 164, 186, 33, 3, 3, 20,
				164, 185, 6, 3, 3, 3, 20, 164, 186, 6,
				3, 3, 3, 5, 2, 6, 20, 164, 187, 6,
				3, 3, 3, 20, 164, 188, 6, 3, 3, 3,
				20, 164, 189, 6, 3, 3, 3, 20, 164, 190,
				6, 3, 3, 3, 171, 191, 6, 20, 164, 194,
				6, 164, 194, 6, 164, 254, 32, 164, 201, 33,
				171, 195, 6, 171, 198, 6, 164, 201, 6, 164,
				202, 6, 164, 203, 6, 171, 204, 6, 5, 8,
				6, 17, 165, 241, 32, 2, 165, 207, 6, 165,
				242, 32, 17, 2, 2, 2, 165, 243, 32, 17,
				2, 2, 165, 208, 6, 2, 6, 20, 3, 3,
				0, 3, 164, 202, 33, 3, 20, 3, 3, 0,
				3, 164, 203, 33, 3, 20, 164, 209, 6, 3,
				0, 3, 164, 204, 33, 3, 20, 164, 210, 6,
				3, 0, 3, 164, 205, 33, 3, 5, 8, 6,
				0, 2, 164, 211, 6, 164, 212, 6, 20, 171,
				213, 6, 3, 164, 216, 6, 3, 20, 164, 217,
				6, 3, 3, 3, 171, 218, 6, 20, 164, 221,
				6, 3, 0, 3, 164, 229, 37, 3, 20, 171,
				244, 32, 3, 0, 3, 164, 235, 32, 0, 3,
				164, 236, 32, 20, 164, 247, 32, 3, 0, 3,
				164, 237, 32, 171, 238, 32, 1, 8, 19, 142,
				33, 3, 5, 7, 2, 1, 8, 19, 143, 33,
				3, 5, 7, 2, 1, 8, 9, 2, 19, 149,
				33, 2, 5, 7, 2, 1, 8, 9, 2, 19,
				150, 33, 2, 5, 7, 2, 1, 8, 9, 2,
				19, 151, 33, 2, 5, 7, 2, 1, 8, 9,
				2, 19, 152, 33, 2, 5, 7, 2, 1, 8,
				9, 18, 2, 2, 214, 166, 15, 2, 0, 2,
				9, 18, 2, 2, 171, 169, 15, 2, 0, 2,
				9, 18, 2, 2, 171, 172, 15, 2, 0, 2,
				9, 18, 2, 2, 171, 222, 37, 2, 0, 2,
				9, 18, 2, 2, 171, 216, 37, 2, 0, 2,
				9, 18, 2, 2, 171, 216, 33, 2, 0, 2,
				9, 18, 2, 2, 171, 210, 37, 2, 0, 2,
				9, 18, 2, 2, 171, 213, 37, 2, 0, 2,
				1, 8, 9, 171, 177, 15, 2, 9, 18, 2,
				2, 171, 180, 15, 2, 0, 2, 9, 18, 2,
				2, 171, 183, 15, 2, 0, 2, 9, 18, 2,
				2, 171, 186, 15, 2, 0, 2, 9, 18, 2,
				2, 171, 189, 15, 2, 0, 2, 9, 18, 2,
				2, 171, 192, 15, 2, 0, 2, 9, 18, 2,
				2, 171, 219, 33, 2, 0, 2, 9, 18, 2,
				2, 171, 219, 37, 2, 0, 2, 1, 8, 5,
				4, 2, 63, 183, 16, 64, 186, 16, 11, 64,
				189, 16, 11, 64, 192, 16, 11, 1, 8, 2,
				113, 140, 17, 11, 8, 2, 17, 112, 142, 17,
				2, 2, 2, 17, 112, 144, 17, 2, 2, 2,
				17, 9, 2, 68, 146, 17, 2, 2, 2, 2,
				21, 161, 151, 17, 110, 148, 17, 161, 151, 17,
				110, 149, 17, 1, 2, 204, 206, 33, 110, 150,
				17, 2, 2, 5, 21, 161, 155, 17, 110, 154,
				17, 161, 155, 17, 2, 162, 158, 17, 2, 2,
				2, 5, 1, 8, 46, 145, 3, 6, 5, 7,
				2, 1, 64, 5, 56, 6, 101, 146, 3, 5,
				7, 6, 1, 8, 66, 147, 3, 6, 5, 7,
				2, 1, 64, 5, 56, 6, 108, 150, 3, 151,
				3, 5, 7, 6, 1, 8, 4, 17, 124, 223,
				12, 159, 224, 12, 2, 2, 2, 17, 124, 230,
				12, 159, 231, 12, 2, 2, 2, 17, 124, 237,
				12, 159, 238, 12, 2, 2, 2, 1, 8, 4,
				17, 124, 128, 13, 159, 129, 13, 2, 2, 2,
				17, 124, 135, 13, 159, 136, 13, 2, 2, 2,
				17, 124, 145, 13, 159, 146, 13, 2, 2, 2,
				1, 8, 4, 17, 124, 152, 13, 159, 153, 13,
				2, 2, 17, 2, 159, 159, 13, 2, 2, 4,
				17, 124, 165, 13, 159, 166, 13, 2, 2, 17,
				2, 159, 172, 13, 2, 2, 1, 8, 17, 111,
				216, 15, 2, 1, 2, 9, 68, 218, 15, 1,
				2, 2, 17, 111, 220, 15, 2, 1, 2, 9,
				68, 222, 15, 1, 2, 2, 17, 110, 224, 15,
				2, 1, 2, 9, 68, 225, 15, 1, 2, 2,
				17, 110, 228, 15, 2, 1, 2, 9, 68, 229,
				15, 1, 2, 2, 17, 111, 232, 15, 2, 68,
				234, 15, 7, 2, 17, 111, 236, 15, 2, 2,
				2, 17, 111, 240, 15, 110, 242, 15, 110, 245,
				15, 2, 17, 110, 251, 15, 110, 252, 15, 2,
				2, 1, 64, 5, 40, 6, 17, 165, 253, 15,
				2, 68, 238, 15, 1, 2, 17, 165, 254, 15,
				2, 68, 238, 15, 1, 2, 17, 165, 255, 15,
				2, 68, 238, 15, 1, 2, 17, 165, 128, 16,
				2, 68, 238, 15, 1, 2, 17, 165, 129, 16,
				2, 68, 238, 15, 1, 2, 17, 165, 130, 16,
				2, 68, 238, 15, 1, 2, 17, 165, 131, 16,
				2, 68, 238, 15, 1, 2, 17, 165, 132, 16,
				2, 68, 238, 15, 1, 2, 17, 165, 133, 16,
				68, 243, 15, 1, 172, 246, 15, 68, 249, 15,
				1, 17, 165, 134, 16, 68, 243, 15, 1, 172,
				246, 15, 68, 249, 15, 1, 17, 165, 135, 16,
				68, 243, 15, 1, 172, 246, 15, 68, 249, 15,
				1, 17, 165, 136, 16, 68, 243, 15, 1, 172,
				246, 15, 68, 249, 15, 1, 17, 165, 137, 16,
				68, 243, 15, 1, 172, 246, 15, 68, 249, 15,
				1, 17, 165, 138, 16, 68, 243, 15, 1, 172,
				246, 15, 68, 249, 15, 1, 17, 165, 139, 16,
				68, 243, 15, 1, 172, 246, 15, 68, 249, 15,
				1, 17, 165, 140, 16, 68, 243, 15, 1, 172,
				246, 15, 68, 249, 15, 1, 17, 165, 141, 16,
				12, 2, 165, 149, 16, 128, 1, 2, 2, 17,
				165, 142, 16, 2, 2, 2, 17, 165, 143, 16,
				2, 2, 2, 17, 165, 144, 16, 2, 2, 2,
				17, 165, 145, 16, 2, 2, 2, 17, 165, 146,
				16, 2, 2, 2, 17, 165, 147, 16, 2, 2,
				2, 17, 165, 148, 16, 2, 2, 2, 0, 55,
				240, 6, 0, 55, 241, 7, 0, 55, 244, 7,
				0, 55, 247, 7, 0, 55, 250, 7, 0, 55,
				253, 7, 0, 55, 128, 8, 0, 55, 131, 8,
				0, 55, 134, 8, 1, 8, 110, 243, 6, 110,
				244, 6, 110, 245, 6, 110, 248, 32, 110, 249,
				32, 110, 250, 32, 110, 251, 32, 110, 252, 32,
				0, 9, 7, 53, 14, 8, 62, 1, 8, 110,
				137, 8, 110, 138, 8, 110, 139, 8, 110, 140,
				8, 5, 2, 7, 54, 110, 230, 37, 110, 231,
				37, 0, 158, 7, 54, 9, 7, 54, 14, 8,
				64, 1, 8, 18, 110, 155, 8, 7, 58, 7,
				58, 7, 58, 0, 5, 7, 7, 58, 0, 158,
				7, 58, 9, 7, 58, 14, 8, 66, 1, 8,
				5, 8, 7, 60, 0, 17, 7, 60, 7, 60,
				9, 68, 156, 8, 1, 7, 60, 7, 60, 1,
				64, 5, 8, 6, 5, 8, 7, 69, 5, 42,
				6, 17, 7, 60, 7, 60, 165, 158, 8, 7,
				60, 17, 7, 60, 7, 60, 165, 159, 8, 7,
				60, 5, 4, 6, 0, 158, 7, 60, 9, 15,
				8, 68, 8, 70, 7, 60, 1, 8, 50, 160,
				8, 5, 7, 7, 61, 0, 158, 7, 61, 14,
				8, 72, 1, 8, 160, 210, 13, 5, 7, 2,
				1, 8, 9, 2, 110, 187, 33, 9, 2, 110,
				188, 33, 9, 2, 110, 189, 33, 9, 2, 110,
				190, 33, 5, 4, 2, 1, 8, 5, 8, 2,
				1, 64, 20, 3, 3, 100, 207, 33, 3, 5,
				63, 6, 1, 128, 2, 17, 129, 130, 20, 183,
				131, 20, 2, 2, 17, 129, 137, 20, 183, 138,
				20, 2, 2, 17, 129, 141, 20, 183, 142, 20,
				2, 2, 17, 129, 145, 20, 183, 146, 20, 2,
				2, 17, 129, 149, 20, 183, 150, 20, 2, 2,
				17, 129, 156, 20, 183, 157, 20, 2, 2, 17,
				129, 160, 20, 183, 161, 20, 2, 2, 17, 129,
				164, 20, 183, 165, 20, 2, 2, 17, 129, 168,
				20, 183, 169, 20, 2, 2, 17, 129, 172, 20,
				183, 173, 20, 2, 2, 17, 129, 176, 20, 183,
				177, 20, 2, 2, 17, 129, 180, 20, 183, 181,
				20, 2, 2, 5, 4, 2, 17, 2, 183, 201,
				20, 2, 2, 5, 3, 2, 17, 2, 183, 228,
				20, 2, 2, 17, 2, 183, 238, 20, 2, 2,
				2, 17, 2, 183, 253, 20, 2, 2, 5, 4,
				2, 17, 129, 145, 21, 183, 146, 21, 2, 2,
				17, 129, 152, 21, 183, 153, 21, 2, 2, 17,
				129, 159, 21, 183, 160, 21, 2, 2, 2, 17,
				2, 183, 169, 21, 2, 2, 17, 2, 183, 178,
				21, 2, 2, 17, 2, 183, 187, 21, 2, 2,
				17, 2, 183, 196, 21, 2, 2, 17, 2, 183,
				205, 21, 2, 2, 17, 2, 183, 214, 21, 2,
				2, 4, 17, 2, 183, 247, 21, 2, 2, 17,
				2, 183, 131, 22, 2, 2, 17, 2, 179, 143,
				22, 2, 2, 17, 2, 183, 152, 22, 2, 2,
				5, 4, 2, 17, 2, 183, 174, 22, 2, 2,
				17, 2, 183, 183, 22, 2, 2, 17, 2, 183,
				192, 22, 2, 2, 17, 2, 183, 201, 22, 2,
				2, 17, 2, 183, 210, 22, 2, 2, 17, 2,
				183, 219, 22, 2, 2, 2, 17, 2, 183, 233,
				22, 2, 2, 17, 2, 183, 239, 22, 2, 2,
				17, 2, 183, 251, 22, 2, 2, 17, 2, 183,
				138, 23, 2, 2, 17, 2, 183, 147, 23, 2,
				2, 17, 2, 183, 156, 23, 2, 2, 17, 2,
				183, 162, 23, 2, 2, 17, 2, 183, 171, 23,
				2, 2, 17, 2, 183, 177, 23, 2, 2, 17,
				2, 183, 186, 23, 2, 2, 17, 2, 183, 195,
				23, 2, 2, 5, 62, 2, 17, 2, 9, 2,
				79, 166, 25, 0, 1, 2, 2, 17, 2, 9,
				2, 79, 168, 25, 0, 1, 2, 2, 17, 2,
				9, 2, 79, 170, 25, 0, 1, 2, 2, 5,
				69, 2, 17, 183, 156, 28, 2, 2, 2, 17,
				183, 159, 28, 2, 2, 2, 17, 183, 160, 28,
				2, 2, 2, 17, 183, 163, 28, 2, 2, 2,
				17, 183, 166, 28, 2, 2, 2, 17, 183, 169,
				28, 2, 2, 2, 2, 17, 2, 183, 172, 28,
				2, 2, 5, 8, 2, 17, 2, 2, 14, 8,
				75, 2, 4, 17, 2, 183, 178, 28, 2, 2,
				17, 2, 183, 180, 28, 184, 191, 33, 192, 33,
				2, 17, 2, 183, 186, 28, 9, 2, 183, 193,
				33, 2, 17, 2, 183, 192, 28, 9, 2, 183,
				194, 33, 2, 17, 2, 183, 198, 28, 9, 2,
				183, 195, 33, 2, 5, 16, 2, 18, 94, 204,
				28, 94, 204, 28, 2, 78, 207, 28, 28, 18,
				122, 209, 28, 122, 209, 28, 2, 76, 212, 28,
				28, 5, 3, 2, 17, 2, 9, 2, 60, 225,
				28, 2, 2, 17, 9, 2, 60, 231, 28, 85,
				233, 28, 85, 235, 28, 2, 2, 17, 2, 90,
				247, 28, 90, 250, 28, 90, 253, 28, 17, 9,
				2, 60, 128, 29, 2, 2, 2, 17, 2, 2,
				9, 205, 196, 33, 2, 2, 17, 2, 2, 9,
				205, 197, 33, 2, 2, 17, 9, 2, 60, 232,
				37, 9, 2, 60, 234, 37, 9, 2, 60, 236,
				37, 9, 2, 60, 238, 37, 5, 3, 2, 1,
				128, 2, 5, 8, 2, 17, 2, 185, 155, 29,
				2, 2, 17, 2, 185, 161, 29, 2, 2, 17,
				2, 185, 167, 29, 2, 2, 17, 2, 185, 170,
				29, 2, 2, 17, 2, 185, 173, 29, 2, 2,
				17, 2, 185, 176, 29, 2, 2, 17, 2, 185,
				179, 29, 2, 2, 17, 130, 182, 29, 185, 183,
				29, 2, 2, 5, 4, 2, 17, 2, 99, 189,
				29, 2, 2, 17, 2, 99, 195, 29, 2, 2,
				17, 2, 99, 201, 29, 2, 2, 17, 2, 48,
				207, 29, 2, 2, 5, 8, 2, 17, 2, 187,
				244, 29, 2, 2, 17, 2, 185, 250, 29, 2,
				2, 17, 2, 187, 253, 29, 2, 2, 5, 29,
				2, 17, 2, 185, 183, 30, 2, 2, 17, 2,
				185, 186, 30, 2, 2, 17, 2, 185, 188, 30,
				2, 2, 2, 17, 2, 185, 198, 30, 2, 2,
				5, 27, 2, 17, 2, 186, 131, 31, 2, 2,
				17, 2, 186, 135, 31, 2, 2, 17, 2, 185,
				139, 31, 2, 2, 17, 2, 185, 141, 31, 2,
				2, 5, 104, 2, 17, 185, 217, 31, 2, 2,
				2, 2, 17, 2, 185, 218, 31, 2, 2, 17,
				2, 185, 224, 31, 2, 2, 5, 15, 2, 17,
				2, 185, 230, 31, 2, 2, 5, 16, 2, 15,
				8, 76, 8, 77, 5, 15, 2, 1, 128, 2,
				14, 8, 31, 15, 8, 32, 8, 33, 87, 222,
				6, 87, 225, 6, 0, 10, 2, 164, 228, 6,
				128, 2, 2, 0, 10, 164, 230, 6, 164, 229,
				6, 128, 2, 164, 230, 6, 164, 231, 6, 0,
				10, 167, 233, 6, 233, 6, 234, 6, 164, 232,
				6, 128, 4, 167, 233, 6, 233, 6, 234, 6,
				164, 235, 6, 189, 0, 10, 2, 164, 238, 6,
				128, 8, 2, 164, 239, 6, 2, 158, 7, 53,
				7, 63, 10, 164, 246, 6, 164, 209, 35, 128,
				128, 2, 10, 22, 164, 210, 35, 128, 128, 2,
				0, 10, 17, 183, 253, 6, 183, 131, 7, 183,
				137, 7, 183, 142, 7, 43, 247, 6, 8, 17,
				183, 253, 6, 183, 131, 7, 183, 137, 7, 183,
				142, 7, 0, 10, 17, 190, 147, 7, 190, 153,
				7, 190, 159, 7, 190, 164, 7, 56, 248, 6,
				8, 17, 190, 147, 7, 190, 153, 7, 190, 159,
				7, 190, 164, 7, 0, 10, 17, 184, 169, 7,
				170, 7, 179, 175, 7, 183, 178, 7, 183, 184,
				7, 75, 250, 6, 8, 17, 184, 169, 7, 170,
				7, 179, 175, 7, 183, 178, 7, 183, 184, 7,
				0, 10, 17, 121, 190, 7, 121, 193, 7, 2,
				2, 81, 251, 6, 8, 17, 121, 190, 7, 121,
				193, 7, 2, 2, 17, 183, 196, 7, 183, 202,
				7, 2, 2, 17, 183, 208, 7, 183, 214, 7,
				2, 2, 17, 184, 220, 7, 223, 7, 179, 226,
				7, 183, 229, 7, 2, 17, 121, 235, 7, 121,
				238, 7, 2, 2, 7, 65, 7, 55, 158, 7,
				56, 12, 7, 56, 17, 9, 7, 56, 31, 141,
				8, 29, 142, 8, 30, 144, 8, 1, 30, 146,
				8, 1, 128, 128, 32, 158, 7, 57, 12, 7,
				57, 17, 9, 7, 57, 118, 148, 8, 32, 149,
				8, 9, 7, 57, 30, 151, 8, 0, 30, 153,
				8, 1, 128, 128, 32, 7, 67, 7, 59, 7,
				71, 7, 73, 141, 163, 8, 185, 141, 165, 8,
				201, 35, 167, 8, 185, 35, 169, 8, 201, 0,
				10, 2, 142, 171, 8, 233, 128, 16, 2, 2,
				0, 10, 2, 36, 172, 8, 233, 128, 16, 2,
				2, 17, 183, 173, 8, 183, 179, 8, 2, 2,
				17, 190, 185, 8, 190, 191, 8, 2, 2, 17,
				181, 197, 8, 181, 198, 8, 178, 199, 8, 178,
				205, 8, 17, 121, 211, 8, 121, 217, 8, 121,
				223, 8, 121, 224, 8, 17, 132, 225, 8, 132,
				226, 8, 98, 227, 8, 98, 233, 8, 17, 132,
				239, 8, 132, 240, 8, 98, 241, 8, 98, 247,
				8, 17, 183, 253, 8, 183, 128, 9, 2, 2,
				17, 183, 131, 9, 183, 132, 9, 2, 2, 164,
				137, 9, 164, 138, 9, 164, 139, 9, 164, 140,
				9, 164, 141, 9, 170, 142, 9, 200, 2, 14,
				8, 34, 128, 128, 64, 200, 20, 199, 144, 9,
				255, 32, 3, 3, 3, 14, 8, 35, 128, 128,
				64, 200, 13, 8, 78, 164, 144, 33, 128, 128,
				64, 200, 2, 164, 145, 33, 128, 128, 128, 2,
				201, 13, 8, 79, 164, 146, 33, 128, 128, 128,
				2, 164, 154, 33, 128, 128, 64, 200, 2, 164,
				155, 33, 128, 128, 64, 200, 2, 164, 156, 33,
				128, 128, 64, 200, 2, 164, 157, 33, 128, 128,
				64, 2, 200, 2, 164, 158, 33, 128, 128, 128,
				4, 80, 145, 9, 80, 148, 9, 80, 151, 9,
				80, 154, 9, 80, 157, 9, 80, 160, 9, 80,
				163, 9, 80, 166, 9, 80, 169, 9, 80, 172,
				9, 80, 175, 9, 80, 178, 9, 80, 181, 9,
				80, 184, 9, 80, 187, 9, 80, 190, 9, 200,
				17, 97, 224, 9, 97, 230, 9, 2, 2, 129,
				159, 33, 128, 128, 64, 200, 17, 183, 236, 9,
				183, 242, 9, 183, 248, 9, 183, 251, 9, 129,
				160, 33, 128, 128, 64, 200, 17, 183, 254, 9,
				2, 183, 129, 10, 2, 129, 161, 33, 128, 128,
				64, 17, 183, 131, 10, 2, 183, 134, 10, 2,
				200, 17, 183, 136, 10, 183, 142, 10, 2, 2,
				9, 2, 129, 162, 33, 128, 128, 64, 200, 17,
				183, 148, 10, 183, 154, 10, 2, 2, 129, 163,
				33, 128, 128, 64, 17, 183, 160, 10, 183, 166,
				10, 2, 2, 17, 183, 172, 10, 183, 178, 10,
				2, 2, 200, 17, 183, 184, 10, 183, 190, 10,
				183, 196, 10, 183, 199, 10, 9, 2, 129, 164,
				33, 128, 128, 64, 200, 17, 183, 202, 10, 183,
				208, 10, 183, 214, 10, 183, 217, 10, 129, 165,
				33, 128, 128, 64, 200, 17, 183, 220, 10, 183,
				226, 10, 183, 232, 10, 183, 235, 10, 9, 2,
				129, 166, 33, 128, 128, 64, 200, 17, 183, 238,
				10, 183, 247, 10, 183, 253, 10, 2, 9, 2,
				129, 167, 33, 128, 128, 64, 200, 17, 183, 131,
				11, 183, 137, 11, 183, 143, 11, 183, 146, 11,
				9, 2, 129, 168, 33, 128, 128, 64, 200, 17,
				183, 149, 11, 183, 155, 11, 183, 161, 11, 183,
				164, 11, 129, 169, 33, 128, 128, 64, 200, 17,
				183, 167, 11, 183, 173, 11, 183, 179, 11, 183,
				182, 11, 9, 2, 129, 170, 33, 128, 128, 64,
				17, 183, 185, 11, 183, 191, 11, 183, 197, 11,
				183, 200, 11, 17, 129, 203, 11, 183, 204, 11,
				2, 2, 17, 129, 210, 11, 183, 211, 11, 2,
				2, 17, 129, 217, 11, 183, 218, 11, 2, 2,
				17, 129, 224, 11, 183, 225, 11, 2, 2, 17,
				129, 231, 11, 183, 232, 11, 2, 2, 17, 129,
				238, 11, 183, 239, 11, 2, 2, 17, 129, 245,
				11, 183, 246, 11, 2, 2, 17, 129, 252, 11,
				183, 253, 11, 2, 2, 17, 129, 131, 12, 183,
				132, 12, 2, 2, 17, 129, 138, 12, 183, 139,
				12, 2, 2, 17, 129, 145, 12, 183, 146, 12,
				2, 2, 17, 129, 152, 12, 183, 153, 12, 2,
				2, 17, 2, 183, 159, 12, 2, 2, 17, 2,
				183, 165, 12, 2, 2, 17, 127, 171, 12, 188,
				173, 12, 2, 2, 17, 129, 179, 12, 183, 180,
				12, 183, 189, 12, 2, 17, 130, 204, 12, 185,
				205, 12, 185, 211, 12, 185, 217, 12, 14, 8,
				48, 14, 8, 49, 14, 8, 50, 17, 129, 178,
				13, 183, 179, 13, 2, 2, 17, 129, 185, 13,
				183, 186, 13, 2, 2, 17, 129, 192, 13, 183,
				193, 13, 2, 2, 20, 164, 199, 13, 3, 3,
				3, 200, 17, 54, 202, 13, 14, 8, 74, 2,
				182, 219, 13, 202, 147, 33, 128, 128, 64, 200,
				17, 79, 222, 13, 1, 1, 9, 184, 230, 13,
				0, 2, 2, 9, 184, 239, 13, 0, 2, 203,
				148, 33, 128, 128, 64, 200, 2, 14, 8, 36,
				128, 128, 64, 200, 2, 14, 8, 37, 128, 128,
				64, 200, 17, 2, 183, 142, 14, 2, 183, 145,
				14, 14, 8, 38, 128, 128, 64, 200, 17, 2,
				183, 148, 14, 2, 183, 151, 14, 14, 8, 39,
				128, 128, 64, 200, 17, 67, 154, 14, 70, 156,
				14, 183, 162, 14, 2, 164, 153, 33, 128, 128,
				128, 1, 17, 140, 165, 14, 190, 166, 14, 190,
				175, 14, 2, 109, 190, 14, 109, 193, 14, 109,
				196, 14, 109, 199, 14, 109, 202, 14, 109, 205,
				14, 109, 208, 14, 109, 211, 14, 109, 214, 14,
				109, 217, 14, 109, 220, 14, 109, 223, 14, 109,
				226, 14, 109, 229, 14, 109, 232, 14, 109, 235,
				14, 40, 238, 14, 40, 239, 14, 40, 240, 14,
				40, 241, 14, 40, 242, 14, 40, 243, 14, 40,
				244, 14, 40, 245, 14, 40, 246, 14, 40, 247,
				14, 40, 248, 14, 40, 249, 14, 40, 250, 14,
				40, 251, 14, 40, 252, 14, 40, 253, 14, 136,
				150, 15, 75, 136, 153, 15, 75, 164, 156, 15,
				55, 157, 15, 59, 160, 15, 58, 163, 15, 0,
				11, 14, 8, 40, 81, 175, 15, 16, 43, 197,
				15, 32, 14, 8, 40, 0, 11, 14, 8, 41,
				56, 195, 15, 16, 56, 198, 15, 32, 14, 8,
				41, 136, 200, 15, 76, 136, 203, 15, 76, 164,
				206, 15, 57, 207, 15, 11, 59, 210, 15, 58,
				213, 15, 15, 8, 51, 8, 52, 80, 150, 16,
				44, 153, 16, 11, 57, 154, 16, 11, 93, 157,
				16, 57, 160, 16, 11, 93, 163, 16, 93, 166,
				16, 77, 169, 16, 88, 172, 16, 10, 18, 2,
				2, 80, 177, 16, 2, 28, 0, 107, 175, 16,
				18, 2, 2, 80, 177, 16, 2, 28, 128, 32,
				80, 180, 16, 14, 8, 42, 57, 195, 16, 11,
				10, 18, 80, 198, 16, 80, 198, 16, 80, 201,
				16, 80, 198, 16, 20, 80, 198, 16, 128, 128,
				4, 10, 18, 80, 204, 16, 80, 204, 16, 80,
				207, 16, 80, 204, 16, 20, 80, 204, 16, 128,
				128, 8, 77, 210, 16, 88, 213, 16, 44, 216,
				16, 11, 57, 217, 16, 11, 17, 185, 220, 16,
				185, 226, 16, 185, 232, 16, 185, 235, 16, 17,
				123, 238, 16, 2, 2, 2, 17, 128, 240, 16,
				187, 242, 16, 2, 2, 17, 96, 248, 16, 9,
				83, 250, 16, 2, 2, 2, 17, 185, 128, 17,
				185, 134, 17, 2, 2, 14, 8, 43, 173, 160,
				17, 0, 173, 160, 17, 1, 173, 160, 17, 2,
				173, 160, 17, 3, 173, 160, 17, 4, 173, 160,
				17, 5, 173, 160, 17, 6, 173, 160, 17, 7,
				17, 2, 183, 163, 17, 2, 183, 166, 17, 17,
				129, 169, 17, 183, 170, 17, 2, 2, 17, 129,
				176, 17, 183, 177, 17, 2, 2, 17, 129, 183,
				17, 183, 184, 17, 2, 2, 17, 129, 190, 17,
				183, 191, 17, 2, 2, 17, 129, 197, 17, 183,
				198, 17, 2, 2, 17, 2, 190, 204, 17, 180,
				207, 17, 131, 208, 17, 17, 95, 209, 17, 97,
				211, 17, 2, 2, 17, 129, 217, 17, 183, 218,
				17, 2, 2, 17, 129, 224, 17, 183, 225, 17,
				2, 2, 17, 129, 231, 17, 183, 232, 17, 2,
				2, 17, 129, 238, 17, 183, 239, 17, 2, 2,
				17, 129, 248, 17, 183, 249, 17, 2, 2, 17,
				129, 255, 17, 183, 128, 18, 2, 2, 17, 129,
				134, 18, 183, 135, 18, 2, 2, 17, 129, 141,
				18, 183, 142, 18, 2, 2, 17, 129, 151, 18,
				183, 152, 18, 2, 2, 17, 129, 158, 18, 183,
				159, 18, 2, 2, 17, 129, 165, 18, 183, 166,
				18, 2, 2, 17, 129, 175, 18, 183, 176, 18,
				2, 2, 17, 129, 182, 18, 183, 183, 18, 2,
				2, 17, 129, 189, 18, 183, 190, 18, 2, 2,
				17, 2, 183, 196, 18, 183, 202, 18, 183, 211,
				18, 17, 119, 217, 18, 121, 218, 18, 2, 2,
				17, 129, 224, 18, 183, 225, 18, 2, 2, 17,
				129, 231, 18, 183, 232, 18, 2, 2, 17, 129,
				238, 18, 183, 239, 18, 2, 2, 17, 129, 245,
				18, 183, 246, 18, 2, 2, 17, 129, 255, 18,
				183, 128, 19, 2, 2, 17, 129, 134, 19, 183,
				135, 19, 2, 2, 17, 129, 141, 19, 183, 142,
				19, 2, 2, 17, 129, 148, 19, 183, 149, 19,
				2, 2, 17, 2, 2, 2, 179, 158, 19, 17,
				129, 161, 19, 183, 162, 19, 2, 2, 17, 129,
				168, 19, 183, 169, 19, 2, 2, 17, 129, 175,
				19, 183, 176, 19, 2, 2, 17, 129, 182, 19,
				183, 183, 19, 2, 2, 17, 129, 189, 19, 183,
				190, 19, 2, 2, 17, 129, 196, 19, 183, 197,
				19, 2, 2, 17, 143, 203, 19, 144, 204, 19,
				2, 2, 17, 129, 206, 19, 183, 207, 19, 2,
				2, 17, 129, 213, 19, 183, 214, 19, 2, 2,
				17, 129, 220, 19, 183, 221, 19, 2, 2, 17,
				129, 227, 19, 183, 228, 19, 2, 2, 17, 129,
				234, 19, 183, 235, 19, 2, 2, 17, 129, 241,
				19, 183, 242, 19, 2, 2, 17, 129, 248, 19,
				183, 249, 19, 2, 2, 10, 80, 255, 19, 164,
				253, 32, 2, 1, 128, 2, 44, 5, 11, 57,
				6, 11, 75, 9, 80, 10, 155, 13, 1, 147,
				14, 0, 137, 17, 71, 2, 0, 137, 19, 71,
				2, 44, 21, 11, 57, 22, 11, 75, 25, 80,
				26, 155, 29, 1, 147, 30, 0, 137, 33, 72,
				2, 13, 8, 80, 44, 36, 11, 57, 37, 11,
				75, 40, 80, 41, 155, 44, 1, 147, 45, 0,
				137, 48, 73, 2, 0, 137, 50, 73, 2, 44,
				52, 11, 57, 53, 11, 75, 56, 80, 57, 155,
				60, 1, 147, 61, 0, 137, 64, 74, 2, 0,
				137, 66, 74, 2, 44, 68, 11, 57, 69, 11,
				75, 72, 80, 73, 155, 76, 1, 147, 77, 206,
				71, 0, 164, 80, 2, 44, 81, 11, 57, 82,
				11, 75, 85, 80, 86, 155, 89, 1, 147, 90,
				206, 72, 0, 164, 93, 2, 44, 94, 11, 57,
				95, 11, 75, 98, 80, 99, 155, 102, 1, 147,
				103, 206, 73, 0, 164, 106, 2, 43, 107, 55,
				108, 75, 111, 80, 112, 155, 115, 1, 147, 116,
				206, 74, 0, 164, 119, 2, 213, 173, 120, 0,
				0, 213, 173, 120, 1, 1, 213, 173, 120, 2,
				2, 213, 173, 120, 3, 3, 213, 173, 120, 4,
				4, 213, 173, 120, 5, 5, 213, 173, 120, 6,
				6, 213, 173, 120, 7, 7, 213, 173, 122, 0,
				8, 213, 173, 122, 1, 9, 213, 173, 122, 2,
				10, 213, 173, 122, 3, 11, 213, 173, 122, 4,
				12, 213, 173, 122, 5, 13, 213, 173, 122, 6,
				14, 213, 173, 122, 7, 15, 139, 0, 124, 139,
				1, 124, 139, 2, 124, 139, 3, 124, 139, 4,
				124, 139, 5, 124, 139, 6, 124, 139, 7, 124,
				139, 0, 127, 139, 1, 127, 139, 2, 127, 139,
				3, 127, 139, 4, 127, 139, 5, 127, 139, 6,
				127, 139, 7, 127, 0, 167, 130, 1, 131, 1,
				131, 1, 2, 0, 167, 132, 1, 133, 1, 133,
				1, 2, 23, 91, 134, 1, 0, 163, 136, 1,
				86, 138, 1, 207, 75, 207, 76, 208, 209, 135,
				141, 1, 84, 144, 1, 134, 147, 1, 82, 150,
				1, 194, 153, 1, 23, 197, 154, 1, 150, 156,
				1, 23, 152, 157, 1, 105, 159, 1, 105, 162,
				1, 105, 165, 1, 105, 168, 1, 105, 171, 1,
				105, 174, 1, 105, 177, 1, 105, 180, 1, 105,
				183, 1, 105, 186, 1, 105, 189, 1, 105, 192,
				1, 105, 195, 1, 105, 198, 1, 105, 201, 1,
				105, 204, 1, 14, 8, 16, 14, 8, 17, 0,
				14, 8, 18, 2, 14, 8, 19, 43, 143, 2,
				55, 144, 2, 44, 147, 2, 15, 57, 148, 2,
				15, 44, 151, 2, 6, 57, 152, 2, 6, 75,
				155, 2, 80, 156, 2, 69, 159, 2, 89, 162,
				2, 177, 165, 2, 26, 14, 8, 20, 192, 0,
				192, 1, 192, 2, 192, 3, 192, 4, 192, 5,
				192, 6, 192, 7, 166, 178, 2, 166, 181, 2,
				0, 28, 184, 2, 2, 164, 186, 2, 138, 187,
				2, 138, 190, 2, 0, 164, 193, 2, 10, 164,
				193, 2, 2, 128, 128, 16, 0, 164, 194, 2,
				10, 164, 194, 2, 2, 128, 128, 16, 148, 195,
				2, 1, 149, 196, 2, 125, 199, 2, 1, 126,
				200, 2, 195, 203, 2, 198, 204, 2, 191, 207,
				2, 193, 208, 2, 155, 211, 2, 1, 147, 212,
				2, 194, 215, 2, 1, 196, 216, 2, 150, 219,
				2, 1, 151, 220, 2, 153, 223, 2, 1, 154,
				224, 2, 156, 0, 156, 1, 156, 2, 156, 3,
				156, 4, 156, 5, 156, 6, 156, 7, 157, 0,
				157, 1, 157, 2, 157, 3, 157, 4, 157, 5,
				157, 6, 157, 7, 14, 8, 21, 14, 8, 22,
				33, 135, 3, 34, 138, 3, 25, 92, 141, 3,
				24, 92, 143, 3, 15, 8, 44, 8, 45, 15,
				8, 46, 8, 47, 104, 152, 3, 169, 155, 3,
				168, 158, 3, 166, 161, 3, 164, 164, 3, 100,
				165, 3, 0, 164, 166, 3, 2, 166, 167, 3,
				14, 8, 23, 14, 8, 24, 14, 8, 25, 14,
				8, 26, 0, 100, 234, 3, 2, 0, 100, 235,
				3, 2, 0, 164, 236, 3, 2, 114, 237, 3,
				16, 8, 0, 8, 1, 15, 8, 2, 8, 3,
				15, 8, 4, 8, 5, 15, 8, 6, 8, 7,
				16, 8, 8, 8, 9, 15, 8, 10, 8, 11,
				15, 8, 12, 8, 13, 15, 8, 14, 8, 15,
				106, 145, 5, 147, 5, 150, 5, 146, 5, 148,
				5, 149, 5, 151, 5, 106, 152, 5, 154, 5,
				157, 5, 153, 5, 155, 5, 156, 5, 158, 5,
				106, 159, 5, 161, 5, 164, 5, 160, 5, 162,
				5, 163, 5, 165, 5, 106, 166, 5, 168, 5,
				171, 5, 167, 5, 169, 5, 170, 5, 172, 5,
				155, 173, 5, 1, 146, 174, 5, 102, 176, 5,
				1, 103, 177, 5, 109, 179, 5, 109, 182, 5,
				0, 28, 185, 5, 2, 105, 187, 5, 27, 190,
				5, 39, 191, 5, 37, 193, 5, 38, 194, 5,
				210, 164, 196, 5, 211, 212, 164, 197, 5, 164,
				198, 5, 14, 8, 27, 14, 8, 28, 164, 231,
				5, 164, 232, 5, 164, 233, 5, 164, 234, 5,
				164, 235, 5, 164, 236, 5, 14, 8, 29, 14,
				8, 30
			};
		}
	}
	internal static class OpCodeHandlersTables_VEX
	{
		internal static readonly OpCodeHandler[] Handlers_0F;

		internal static readonly OpCodeHandler[] Handlers_0F38;

		internal static readonly OpCodeHandler[] Handlers_0F3A;

		private const int MaxIdNames = 16;

		private const uint Handlers_MAP0Index = 14u;

		private const uint Handlers_0FIndex = 15u;

		private const uint Handlers_0F38Index = 12u;

		private const uint Handlers_0F3AIndex = 13u;

		static OpCodeHandlersTables_VEX()
		{
			VexOpCodeHandlerReader handlerReader = new VexOpCodeHandlerReader();
			TableDeserializer tableDeserializer = new TableDeserializer(handlerReader, 16, GetSerializedTables());
			tableDeserializer.Deserialize();
			Handlers_0F = tableDeserializer.GetTable(15u);
			Handlers_0F38 = tableDeserializer.GetTable(12u);
			Handlers_0F3A = tableDeserializer.GetTable(13u);
		}

		private static ReadOnlySpan<byte> GetSerializedTables()
		{
			return new byte[6767]
			{
				1, 8, 11, 14, 71, 0, 4, 0, 29, 213,
				35, 128, 128, 128, 8, 0, 0, 0, 0, 11,
				14, 71, 0, 4, 0, 29, 214, 35, 128, 128,
				128, 8, 0, 0, 0, 0, 11, 14, 71, 0,
				4, 0, 29, 215, 35, 128, 128, 128, 8, 0,
				0, 0, 0, 11, 14, 71, 0, 4, 0, 29,
				216, 35, 128, 128, 128, 8, 0, 0, 0, 0,
				11, 14, 71, 0, 4, 0, 29, 217, 35, 128,
				128, 128, 8, 0, 0, 0, 0, 11, 14, 71,
				0, 4, 0, 29, 218, 35, 128, 128, 128, 8,
				0, 0, 0, 0, 11, 14, 71, 0, 4, 0,
				29, 219, 35, 128, 128, 128, 8, 0, 0, 0,
				0, 11, 14, 71, 0, 4, 0, 29, 220, 35,
				128, 128, 128, 8, 0, 0, 0, 0, 1, 8,
				1, 11, 0, 14, 26, 77, 225, 12, 26, 109,
				226, 12, 0, 0, 0, 11, 0, 14, 26, 77,
				232, 12, 26, 109, 233, 12, 0, 0, 0, 11,
				0, 14, 26, 77, 239, 12, 26, 109, 240, 12,
				0, 0, 0, 1, 8, 1, 11, 0, 14, 26,
				77, 130, 13, 26, 109, 131, 13, 0, 0, 0,
				11, 0, 14, 26, 77, 137, 13, 26, 109, 138,
				13, 0, 0, 0, 11, 0, 14, 26, 77, 147,
				13, 26, 109, 148, 13, 0, 0, 0, 1, 8,
				1, 11, 0, 14, 26, 77, 154, 13, 26, 109,
				155, 13, 0, 0, 11, 0, 14, 26, 77, 160,
				13, 26, 109, 161, 13, 0, 0, 1, 11, 0,
				14, 26, 77, 167, 13, 26, 109, 168, 13, 0,
				0, 11, 0, 14, 26, 77, 173, 13, 26, 109,
				174, 13, 0, 0, 1, 8, 1, 11, 14, 29,
				227, 15, 0, 0, 0, 0, 11, 14, 29, 231,
				15, 0, 0, 0, 0, 1, 11, 0, 0, 14,
				71, 0, 4, 0, 7, 75, 238, 35, 0, 128,
				128, 128, 8, 0, 14, 71, 0, 4, 0, 7,
				75, 240, 35, 0, 128, 128, 128, 8, 0, 11,
				0, 0, 14, 71, 0, 4, 0, 29, 242, 35,
				128, 128, 128, 8, 0, 14, 71, 0, 4, 0,
				29, 243, 35, 128, 128, 128, 8, 0, 1, 8,
				0, 11, 14, 28, 217, 28, 0, 0, 0, 0,
				11, 14, 28, 219, 28, 0, 0, 0, 0, 11,
				14, 28, 221, 28, 0, 0, 0, 0, 2, 4,
				0, 1, 8, 7, 0, 29, 128, 33, 2, 7,
				0, 1, 64, 35, 129, 33, 2, 63, 70, 1,
				8, 7, 0, 29, 130, 33, 2, 7, 0, 1,
				64, 2, 64, 70, 1, 8, 2, 8, 0, 1,
				64, 66, 131, 33, 2, 7, 70, 66, 131, 33,
				2, 7, 70, 66, 131, 33, 2, 7, 70, 66,
				131, 33, 2, 7, 70, 66, 131, 33, 2, 7,
				70, 66, 131, 33, 2, 7, 70, 66, 131, 33,
				2, 7, 70, 66, 131, 33, 2, 7, 70, 1,
				128, 2, 11, 0, 14, 41, 77, 132, 20, 41,
				109, 133, 20, 0, 0, 11, 0, 14, 41, 77,
				139, 20, 41, 109, 140, 20, 0, 0, 11, 0,
				14, 41, 77, 143, 20, 41, 109, 144, 20, 0,
				0, 11, 0, 14, 41, 77, 147, 20, 41, 109,
				148, 20, 0, 0, 11, 0, 14, 41, 77, 151,
				20, 41, 109, 152, 20, 0, 0, 11, 0, 14,
				41, 77, 158, 20, 41, 109, 159, 20, 0, 0,
				11, 0, 14, 41, 77, 162, 20, 41, 109, 163,
				20, 0, 0, 11, 0, 14, 41, 77, 166, 20,
				41, 109, 167, 20, 0, 0, 11, 0, 14, 41,
				77, 170, 20, 41, 109, 171, 20, 0, 0, 11,
				0, 14, 41, 77, 174, 20, 41, 109, 175, 20,
				0, 0, 11, 0, 14, 41, 77, 178, 20, 41,
				109, 179, 20, 0, 0, 11, 0, 14, 41, 77,
				182, 20, 41, 109, 183, 20, 0, 0, 11, 0,
				9, 14, 41, 77, 187, 20, 41, 109, 188, 20,
				0, 0, 0, 11, 0, 9, 14, 41, 77, 192,
				20, 41, 109, 193, 20, 0, 0, 0, 11, 0,
				9, 14, 54, 77, 197, 20, 54, 109, 198, 20,
				0, 0, 0, 11, 0, 9, 14, 54, 77, 199,
				20, 54, 109, 200, 20, 0, 0, 0, 2, 3,
				0, 11, 0, 9, 14, 55, 77, 77, 220, 20,
				55, 109, 77, 221, 20, 0, 0, 0, 1, 11,
				0, 9, 14, 0, 41, 109, 248, 20, 0, 0,
				0, 11, 0, 14, 54, 77, 254, 20, 54, 109,
				255, 20, 0, 0, 11, 0, 9, 14, 7, 55,
				77, 77, 198, 33, 55, 77, 77, 128, 21, 7,
				55, 109, 77, 199, 33, 55, 109, 77, 129, 21,
				0, 0, 0, 11, 0, 9, 14, 0, 7, 55,
				109, 77, 200, 33, 55, 109, 77, 133, 21, 0,
				0, 0, 11, 0, 9, 14, 0, 53, 109, 138,
				21, 0, 0, 0, 0, 11, 0, 14, 54, 77,
				147, 21, 54, 109, 148, 21, 0, 0, 11, 0,
				14, 54, 77, 154, 21, 54, 109, 155, 21, 0,
				0, 11, 0, 14, 54, 77, 161, 21, 54, 109,
				162, 21, 0, 0, 0, 11, 0, 14, 55, 77,
				77, 170, 21, 55, 109, 77, 171, 21, 0, 0,
				11, 0, 14, 55, 77, 77, 179, 21, 55, 109,
				77, 180, 21, 0, 0, 11, 0, 14, 55, 77,
				77, 188, 21, 55, 109, 77, 189, 21, 0, 0,
				11, 0, 14, 55, 77, 77, 197, 21, 55, 109,
				77, 198, 21, 0, 0, 11, 0, 14, 55, 77,
				77, 206, 21, 55, 109, 77, 207, 21, 0, 0,
				11, 0, 14, 55, 77, 77, 215, 21, 55, 109,
				77, 216, 21, 0, 0, 1, 11, 0, 14, 41,
				77, 248, 21, 41, 109, 249, 21, 0, 0, 11,
				0, 14, 41, 77, 132, 22, 41, 109, 133, 22,
				0, 0, 11, 0, 14, 53, 77, 144, 22, 53,
				109, 145, 22, 0, 0, 11, 0, 14, 41, 77,
				153, 22, 41, 109, 154, 22, 0, 0, 11, 0,
				9, 14, 40, 77, 158, 22, 40, 109, 159, 22,
				0, 0, 0, 11, 0, 9, 14, 40, 77, 166,
				22, 40, 109, 167, 22, 0, 0, 0, 11, 0,
				9, 14, 30, 77, 170, 22, 30, 109, 171, 22,
				0, 0, 0, 11, 0, 9, 14, 30, 77, 172,
				22, 30, 109, 173, 22, 0, 0, 0, 11, 0,
				14, 55, 77, 77, 175, 22, 55, 109, 77, 176,
				22, 0, 0, 11, 0, 14, 55, 77, 77, 184,
				22, 55, 109, 77, 185, 22, 0, 0, 11, 0,
				14, 55, 77, 77, 193, 22, 55, 109, 77, 194,
				22, 0, 0, 11, 0, 14, 55, 77, 77, 202,
				22, 55, 109, 77, 203, 22, 0, 0, 11, 0,
				14, 55, 77, 77, 211, 22, 55, 109, 77, 212,
				22, 0, 0, 11, 0, 14, 55, 77, 77, 220,
				22, 55, 109, 77, 221, 22, 0, 0, 11, 0,
				9, 14, 0, 41, 109, 228, 22, 0, 0, 0,
				11, 0, 14, 41, 77, 234, 22, 41, 109, 235,
				22, 0, 0, 11, 0, 14, 41, 77, 240, 22,
				41, 109, 241, 22, 0, 0, 11, 0, 14, 41,
				77, 252, 22, 41, 109, 253, 22, 0, 0, 11,
				0, 14, 41, 77, 139, 23, 41, 109, 140, 23,
				0, 0, 11, 0, 14, 41, 77, 148, 23, 41,
				109, 149, 23, 0, 0, 11, 0, 14, 41, 77,
				157, 23, 41, 109, 158, 23, 0, 0, 11, 0,
				14, 41, 77, 163, 23, 41, 109, 164, 23, 0,
				0, 11, 0, 14, 41, 77, 172, 23, 41, 109,
				173, 23, 0, 0, 11, 0, 14, 41, 77, 178,
				23, 41, 109, 179, 23, 0, 0, 11, 0, 14,
				41, 77, 187, 23, 41, 109, 188, 23, 0, 0,
				11, 0, 14, 54, 77, 196, 23, 0, 0, 0,
				2, 3, 0, 11, 0, 9, 14, 41, 77, 211,
				23, 41, 109, 212, 23, 14, 41, 77, 213, 23,
				41, 109, 214, 23, 0, 0, 11, 0, 9, 14,
				41, 77, 221, 23, 41, 109, 222, 23, 0, 0,
				0, 11, 0, 9, 14, 41, 77, 229, 23, 41,
				109, 230, 23, 14, 41, 77, 231, 23, 41, 109,
				232, 23, 0, 0, 0, 69, 0, 11, 9, 14,
				68, 6, 6, 6, 7, 0, 0, 9, 14, 68,
				6, 8, 6, 9, 0, 0, 0, 9, 14, 68,
				6, 10, 6, 11, 0, 0, 0, 69, 0, 11,
				0, 9, 14, 7, 0, 64, 132, 33, 0, 0,
				9, 14, 7, 0, 65, 133, 33, 0, 0, 9,
				14, 7, 0, 64, 134, 33, 0, 0, 2, 4,
				0, 11, 9, 14, 41, 77, 240, 37, 41, 109,
				241, 37, 0, 9, 14, 41, 77, 208, 33, 41,
				109, 209, 33, 0, 9, 14, 41, 77, 242, 37,
				41, 109, 243, 37, 0, 9, 14, 41, 77, 244,
				37, 41, 109, 245, 37, 0, 11, 9, 14, 41,
				77, 246, 37, 41, 109, 247, 37, 0, 9, 14,
				41, 77, 210, 33, 41, 109, 211, 33, 0, 9,
				14, 41, 77, 248, 37, 41, 109, 249, 37, 0,
				9, 14, 41, 77, 250, 37, 41, 109, 251, 37,
				0, 11, 0, 9, 14, 41, 77, 212, 33, 41,
				109, 213, 33, 0, 0, 0, 11, 0, 9, 14,
				41, 77, 214, 33, 41, 109, 215, 33, 0, 0,
				0, 2, 4, 0, 11, 0, 9, 14, 55, 77,
				77, 156, 24, 55, 109, 77, 157, 24, 0, 0,
				0, 11, 0, 9, 14, 55, 77, 77, 161, 24,
				55, 109, 77, 162, 24, 0, 0, 0, 11, 0,
				9, 14, 0, 53, 109, 169, 24, 0, 0, 0,
				0, 69, 0, 11, 0, 0, 9, 14, 7, 67,
				135, 33, 0, 0, 0, 9, 14, 7, 67, 252,
				37, 0, 0, 0, 0, 69, 0, 11, 9, 14,
				7, 67, 136, 33, 0, 0, 0, 9, 14, 7,
				67, 137, 33, 0, 0, 0, 9, 14, 7, 67,
				138, 33, 0, 0, 0, 9, 14, 7, 67, 139,
				33, 0, 0, 0, 2, 13, 0, 69, 0, 11,
				9, 14, 7, 67, 175, 38, 0, 0, 0, 9,
				14, 7, 67, 176, 38, 0, 0, 0, 0, 0,
				2, 5, 0, 11, 0, 0, 9, 14, 55, 77,
				77, 253, 37, 55, 77, 109, 254, 37, 0, 0,
				2, 5, 0, 11, 0, 9, 14, 55, 77, 77,
				254, 24, 55, 109, 77, 255, 24, 0, 0, 0,
				11, 0, 9, 14, 55, 77, 77, 131, 25, 55,
				109, 77, 132, 25, 0, 0, 0, 2, 18, 0,
				11, 0, 9, 14, 40, 77, 199, 25, 40, 109,
				200, 25, 14, 40, 77, 201, 25, 40, 109, 202,
				25, 0, 0, 0, 11, 0, 9, 14, 30, 77,
				209, 25, 30, 109, 210, 25, 14, 30, 77, 211,
				25, 30, 109, 212, 25, 0, 0, 0, 11, 0,
				9, 14, 60, 77, 77, 77, 216, 25, 60, 109,
				109, 109, 217, 25, 14, 60, 77, 77, 77, 218,
				25, 60, 109, 77, 109, 219, 25, 0, 0, 11,
				0, 9, 14, 60, 77, 77, 77, 226, 25, 60,
				77, 109, 77, 227, 25, 14, 60, 77, 77, 77,
				228, 25, 60, 109, 109, 109, 229, 25, 0, 0,
				11, 0, 9, 14, 60, 77, 77, 77, 236, 25,
				60, 109, 109, 109, 237, 25, 14, 60, 77, 77,
				77, 238, 25, 60, 109, 77, 109, 239, 25, 0,
				0, 11, 0, 9, 14, 60, 77, 77, 77, 246,
				25, 60, 77, 109, 77, 247, 25, 14, 60, 77,
				77, 77, 248, 25, 60, 109, 109, 109, 249, 25,
				0, 0, 1, 11, 0, 9, 14, 41, 77, 128,
				26, 41, 109, 129, 26, 14, 41, 77, 130, 26,
				41, 109, 131, 26, 0, 0, 11, 0, 9, 14,
				41, 77, 138, 26, 41, 109, 139, 26, 14, 41,
				77, 140, 26, 41, 109, 141, 26, 0, 0, 11,
				0, 9, 14, 41, 77, 148, 26, 41, 109, 149,
				26, 14, 41, 77, 150, 26, 41, 109, 151, 26,
				0, 0, 11, 0, 9, 41, 77, 158, 26, 41,
				77, 159, 26, 0, 0, 11, 0, 9, 14, 41,
				77, 162, 26, 41, 109, 163, 26, 14, 41, 77,
				164, 26, 41, 109, 165, 26, 0, 0, 11, 0,
				9, 41, 77, 173, 26, 41, 77, 174, 26, 0,
				0, 11, 0, 9, 14, 41, 77, 178, 26, 41,
				109, 179, 26, 14, 41, 77, 180, 26, 41, 109,
				181, 26, 0, 0, 11, 0, 9, 41, 77, 188,
				26, 41, 77, 189, 26, 0, 0, 11, 0, 9,
				14, 41, 77, 192, 26, 41, 109, 193, 26, 14,
				41, 77, 194, 26, 41, 109, 195, 26, 0, 0,
				11, 0, 9, 41, 77, 202, 26, 41, 77, 203,
				26, 0, 0, 2, 6, 0, 11, 0, 9, 14,
				41, 77, 230, 26, 41, 109, 231, 26, 14, 41,
				77, 232, 26, 41, 109, 233, 26, 0, 0, 11,
				0, 9, 14, 41, 77, 240, 26, 41, 109, 241,
				26, 14, 41, 77, 242, 26, 41, 109, 243, 26,
				0, 0, 11, 0, 9, 14, 41, 77, 250, 26,
				41, 109, 251, 26, 14, 41, 77, 252, 26, 41,
				109, 253, 26, 0, 0, 11, 0, 9, 41, 77,
				132, 27, 41, 77, 133, 27, 0, 0, 11, 0,
				9, 14, 41, 77, 136, 27, 41, 109, 137, 27,
				14, 41, 77, 138, 27, 41, 109, 139, 27, 0,
				0, 11, 0, 9, 41, 77, 147, 27, 41, 77,
				148, 27, 0, 0, 11, 0, 9, 14, 41, 77,
				152, 27, 41, 109, 153, 27, 14, 41, 77, 154,
				27, 41, 109, 155, 27, 0, 0, 11, 0, 9,
				41, 77, 162, 27, 41, 77, 163, 27, 0, 0,
				11, 0, 9, 14, 41, 77, 166, 27, 41, 109,
				167, 27, 14, 41, 77, 168, 27, 41, 109, 169,
				27, 0, 0, 11, 0, 9, 41, 77, 176, 27,
				41, 77, 177, 27, 0, 0, 11, 9, 14, 53,
				77, 255, 37, 53, 109, 128, 38, 0, 9, 14,
				53, 77, 129, 38, 53, 109, 130, 38, 0, 9,
				14, 53, 77, 131, 38, 53, 109, 132, 38, 0,
				9, 14, 53, 77, 133, 38, 53, 109, 134, 38,
				0, 11, 0, 9, 14, 53, 77, 135, 38, 53,
				109, 136, 38, 0, 9, 14, 53, 77, 137, 38,
				53, 109, 138, 38, 0, 0, 1, 11, 0, 9,
				0, 14, 41, 77, 139, 38, 41, 109, 140, 38,
				0, 0, 11, 0, 9, 0, 14, 41, 77, 141,
				38, 41, 109, 142, 38, 0, 0, 11, 0, 9,
				14, 41, 77, 186, 27, 41, 109, 187, 27, 14,
				41, 77, 188, 27, 41, 109, 189, 27, 0, 0,
				11, 0, 9, 14, 41, 77, 196, 27, 41, 109,
				197, 27, 14, 41, 77, 198, 27, 41, 109, 199,
				27, 0, 0, 11, 0, 9, 14, 41, 77, 206,
				27, 41, 109, 207, 27, 14, 41, 77, 208, 27,
				41, 109, 209, 27, 0, 0, 11, 0, 9, 41,
				77, 216, 27, 41, 77, 217, 27, 0, 0, 11,
				0, 9, 14, 41, 77, 220, 27, 41, 109, 221,
				27, 14, 41, 77, 222, 27, 41, 109, 223, 27,
				0, 0, 11, 0, 9, 41, 77, 230, 27, 41,
				77, 231, 27, 0, 0, 11, 0, 9, 14, 41,
				77, 234, 27, 41, 109, 235, 27, 14, 41, 77,
				236, 27, 41, 109, 237, 27, 0, 0, 11, 0,
				9, 41, 77, 244, 27, 41, 77, 245, 27, 0,
				0, 11, 0, 9, 14, 41, 77, 248, 27, 41,
				109, 249, 27, 14, 41, 77, 250, 27, 41, 109,
				251, 27, 0, 0, 11, 0, 9, 41, 77, 130,
				28, 41, 77, 131, 28, 0, 0, 2, 11, 0,
				11, 0, 0, 0, 9, 14, 0, 7, 43, 109,
				109, 77, 178, 38, 0, 0, 11, 0, 0, 0,
				9, 14, 0, 7, 55, 109, 77, 179, 38, 0,
				0, 11, 0, 0, 0, 9, 14, 0, 7, 55,
				109, 109, 180, 38, 0, 0, 0, 11, 0, 9,
				14, 41, 77, 173, 28, 41, 109, 174, 28, 0,
				0, 0, 1, 11, 9, 14, 41, 77, 181, 38,
				41, 109, 182, 38, 0, 9, 14, 41, 77, 183,
				38, 41, 109, 184, 38, 0, 9, 14, 41, 77,
				185, 38, 41, 109, 186, 38, 0, 0, 11, 9,
				14, 41, 77, 187, 38, 41, 109, 188, 38, 0,
				9, 14, 41, 77, 189, 38, 41, 109, 190, 38,
				0, 9, 14, 41, 77, 191, 38, 41, 109, 192,
				38, 0, 0, 2, 6, 0, 11, 9, 14, 41,
				77, 193, 38, 0, 0, 9, 14, 41, 77, 194,
				38, 0, 0, 9, 14, 41, 77, 195, 38, 41,
				109, 196, 38, 0, 9, 14, 41, 77, 197, 38,
				41, 109, 198, 38, 0, 11, 0, 14, 54, 77,
				179, 28, 0, 0, 0, 11, 0, 14, 41, 77,
				181, 28, 41, 109, 182, 28, 0, 0, 11, 0,
				14, 41, 77, 187, 28, 41, 109, 188, 28, 0,
				0, 11, 0, 14, 41, 77, 193, 28, 41, 109,
				194, 28, 0, 0, 11, 0, 14, 41, 77, 199,
				28, 41, 109, 200, 28, 0, 0, 69, 0, 11,
				0, 14, 7, 0, 78, 143, 38, 0, 0, 0,
				69, 0, 11, 0, 14, 7, 0, 78, 145, 38,
				0, 0, 0, 69, 0, 11, 0, 14, 7, 0,
				78, 147, 38, 0, 0, 0, 69, 0, 11, 0,
				14, 7, 0, 78, 149, 38, 0, 0, 0, 69,
				0, 11, 0, 14, 7, 0, 78, 151, 38, 0,
				0, 0, 69, 0, 11, 0, 14, 7, 0, 78,
				153, 38, 0, 0, 0, 69, 0, 11, 0, 14,
				7, 0, 78, 155, 38, 0, 0, 0, 69, 0,
				11, 0, 14, 7, 0, 78, 157, 38, 0, 0,
				0, 69, 0, 11, 0, 14, 7, 0, 78, 159,
				38, 0, 0, 0, 69, 0, 11, 0, 14, 7,
				0, 78, 161, 38, 0, 0, 0, 69, 0, 11,
				0, 14, 7, 0, 78, 163, 38, 0, 0, 0,
				69, 0, 11, 0, 14, 7, 0, 78, 165, 38,
				0, 0, 0, 69, 0, 11, 0, 14, 7, 0,
				78, 167, 38, 0, 0, 0, 69, 0, 11, 0,
				14, 7, 0, 78, 169, 38, 0, 0, 0, 69,
				0, 11, 0, 14, 7, 0, 78, 171, 38, 0,
				0, 0, 69, 0, 11, 0, 14, 7, 0, 78,
				173, 38, 0, 0, 0, 11, 0, 0, 14, 71,
				0, 4, 0, 74, 252, 35, 128, 128, 128, 8,
				0, 14, 71, 0, 4, 0, 74, 254, 35, 128,
				128, 128, 8, 0, 11, 0, 0, 0, 14, 71,
				0, 4, 0, 74, 128, 36, 128, 128, 128, 8,
				0, 11, 14, 22, 215, 28, 0, 0, 0, 0,
				8, 6, 5, 0, 11, 14, 18, 223, 28, 0,
				0, 14, 22, 227, 28, 0, 14, 22, 229, 28,
				0, 11, 0, 0, 0, 14, 22, 237, 28, 0,
				11, 14, 18, 239, 28, 0, 14, 18, 241, 28,
				0, 14, 18, 243, 28, 0, 14, 18, 245, 28,
				0, 2, 8, 0, 1, 128, 2, 11, 0, 9,
				0, 14, 0, 57, 109, 130, 29, 0, 0, 11,
				0, 9, 0, 14, 0, 57, 109, 133, 29, 0,
				0, 11, 0, 9, 14, 44, 77, 136, 29, 44,
				109, 137, 29, 0, 0, 0, 0, 11, 0, 9,
				14, 57, 77, 144, 29, 57, 109, 145, 29, 0,
				0, 0, 11, 0, 9, 14, 57, 77, 149, 29,
				57, 109, 150, 29, 0, 0, 0, 11, 0, 9,
				14, 0, 44, 109, 154, 29, 0, 0, 0, 0,
				11, 0, 14, 57, 77, 156, 29, 57, 109, 157,
				29, 0, 0, 11, 0, 14, 57, 77, 162, 29,
				57, 109, 163, 29, 0, 0, 11, 0, 44, 77,
				168, 29, 0, 0, 11, 0, 44, 77, 171, 29,
				0, 0, 11, 0, 14, 44, 77, 174, 29, 44,
				109, 175, 29, 0, 0, 11, 0, 14, 44, 77,
				177, 29, 44, 109, 178, 29, 0, 0, 11, 0,
				14, 44, 77, 180, 29, 44, 109, 181, 29, 0,
				0, 11, 0, 14, 44, 77, 184, 29, 44, 109,
				185, 29, 0, 0, 2, 4, 0, 11, 0, 14,
				25, 77, 191, 29, 0, 0, 0, 11, 0, 14,
				25, 77, 197, 29, 0, 0, 0, 11, 0, 14,
				25, 77, 203, 29, 0, 0, 0, 11, 0, 14,
				15, 77, 209, 29, 0, 0, 0, 11, 0, 9,
				14, 0, 45, 109, 109, 77, 213, 29, 0, 0,
				0, 11, 0, 9, 14, 0, 63, 77, 109, 218,
				29, 0, 0, 0, 2, 3, 0, 11, 0, 9,
				14, 63, 77, 77, 227, 29, 63, 77, 109, 228,
				29, 0, 0, 0, 1, 11, 0, 14, 37, 77,
				246, 29, 0, 0, 0, 11, 0, 14, 44, 77,
				251, 29, 0, 0, 0, 11, 0, 14, 37, 77,
				255, 29, 0, 0, 0, 2, 13, 0, 11, 0,
				14, 9, 51, 149, 30, 51, 150, 30, 0, 0,
				0, 11, 0, 14, 9, 51, 151, 30, 51, 152,
				30, 0, 0, 0, 11, 0, 14, 9, 51, 153,
				30, 51, 154, 30, 0, 0, 0, 11, 0, 14,
				9, 51, 155, 30, 51, 156, 30, 0, 0, 0,
				2, 4, 0, 11, 0, 9, 14, 0, 45, 109,
				109, 77, 157, 30, 0, 0, 0, 11, 0, 9,
				14, 0, 63, 77, 109, 162, 30, 0, 0, 0,
				2, 4, 0, 11, 0, 14, 9, 71, 0, 4,
				0, 73, 130, 36, 53, 128, 128, 128, 8, 0,
				0, 0, 0, 0, 11, 0, 14, 44, 77, 184,
				30, 44, 109, 185, 30, 0, 0, 11, 0, 14,
				44, 77, 187, 30, 0, 0, 0, 11, 0, 14,
				44, 77, 189, 30, 44, 109, 190, 30, 0, 0,
				0, 11, 0, 14, 44, 77, 199, 30, 44, 109,
				200, 30, 0, 0, 0, 11, 0, 9, 14, 0,
				44, 109, 204, 30, 0, 0, 0, 0, 11, 0,
				9, 14, 47, 77, 205, 30, 47, 109, 206, 30,
				14, 39, 77, 207, 30, 39, 109, 208, 30, 0,
				0, 11, 0, 9, 14, 47, 77, 209, 30, 47,
				109, 210, 30, 14, 39, 77, 211, 30, 39, 109,
				212, 30, 0, 0, 11, 0, 9, 14, 46, 77,
				213, 30, 46, 109, 214, 30, 0, 0, 0, 11,
				0, 9, 14, 46, 77, 215, 30, 46, 109, 216,
				30, 0, 0, 0, 11, 0, 9, 14, 46, 77,
				217, 30, 46, 109, 218, 30, 0, 0, 0, 2,
				15, 0, 11, 0, 9, 14, 46, 77, 243, 30,
				46, 109, 244, 30, 14, 38, 77, 245, 30, 38,
				109, 246, 30, 0, 0, 11, 0, 9, 14, 46,
				77, 247, 30, 46, 109, 248, 30, 14, 38, 77,
				249, 30, 38, 109, 250, 30, 0, 0, 11, 0,
				9, 14, 46, 77, 251, 30, 46, 109, 252, 30,
				14, 38, 77, 253, 30, 38, 109, 254, 30, 0,
				0, 11, 0, 9, 14, 46, 77, 255, 30, 46,
				109, 128, 31, 14, 38, 77, 129, 31, 38, 109,
				130, 31, 0, 0, 11, 0, 14, 58, 77, 133,
				31, 0, 0, 0, 11, 0, 14, 58, 77, 137,
				31, 0, 0, 0, 11, 0, 14, 57, 77, 140,
				31, 0, 0, 0, 11, 0, 14, 57, 77, 142,
				31, 0, 0, 0, 2, 4, 0, 11, 0, 9,
				14, 46, 77, 151, 31, 46, 109, 152, 31, 14,
				38, 77, 153, 31, 38, 109, 154, 31, 0, 0,
				11, 0, 9, 14, 46, 77, 155, 31, 46, 109,
				156, 31, 14, 38, 77, 157, 31, 38, 109, 158,
				31, 0, 0, 11, 0, 9, 46, 77, 159, 31,
				38, 77, 160, 31, 0, 0, 11, 0, 9, 46,
				77, 161, 31, 38, 77, 162, 31, 0, 0, 11,
				0, 9, 14, 46, 77, 163, 31, 46, 109, 164,
				31, 14, 38, 77, 165, 31, 38, 109, 166, 31,
				0, 0, 11, 0, 9, 14, 46, 77, 167, 31,
				46, 109, 168, 31, 14, 38, 77, 169, 31, 38,
				109, 170, 31, 0, 0, 11, 0, 9, 46, 77,
				171, 31, 38, 77, 172, 31, 0, 0, 11, 0,
				9, 46, 77, 173, 31, 38, 77, 174, 31, 0,
				0, 2, 8, 0, 11, 0, 9, 14, 46, 77,
				193, 31, 46, 109, 194, 31, 14, 38, 77, 195,
				31, 38, 109, 196, 31, 0, 0, 11, 0, 9,
				14, 46, 77, 197, 31, 46, 109, 198, 31, 14,
				38, 77, 199, 31, 38, 109, 200, 31, 0, 0,
				11, 0, 9, 46, 77, 201, 31, 38, 77, 202,
				31, 0, 0, 11, 0, 9, 46, 77, 203, 31,
				38, 77, 204, 31, 0, 0, 11, 0, 9, 14,
				46, 77, 205, 31, 46, 109, 206, 31, 14, 38,
				77, 207, 31, 38, 109, 208, 31, 0, 0, 11,
				0, 9, 14, 46, 77, 209, 31, 46, 109, 210,
				31, 14, 38, 77, 211, 31, 38, 109, 212, 31,
				0, 0, 11, 0, 9, 46, 77, 213, 31, 38,
				77, 214, 31, 0, 0, 11, 0, 9, 46, 77,
				215, 31, 38, 77, 216, 31, 0, 0, 2, 78,
				0, 11, 0, 9, 0, 14, 44, 77, 219, 31,
				44, 109, 220, 31, 0, 0, 11, 0, 9, 0,
				14, 44, 77, 225, 31, 44, 109, 226, 31, 0,
				0, 2, 14, 0, 11, 0, 9, 14, 44, 77,
				199, 38, 0, 0, 0, 0, 11, 0, 14, 57,
				77, 231, 31, 0, 0, 0, 2, 16, 0, 11,
				0, 0, 0, 14, 19, 232, 31, 0, 2, 15,
				0, 1, 128, 2, 2, 116, 0, 11, 14, 9,
				71, 0, 4, 0, 76, 211, 35, 128, 128, 128,
				8, 0, 0, 0, 0, 0, 11, 14, 9, 71,
				0, 4, 0, 76, 212, 35, 128, 128, 128, 8,
				0, 0, 0, 0, 0, 2, 138, 1, 0, 1,
				128, 2, 2, 16, 0, 11, 14, 54, 77, 254,
				6, 54, 109, 255, 6, 14, 54, 77, 132, 7,
				54, 109, 133, 7, 7, 41, 77, 138, 7, 53,
				77, 139, 7, 7, 41, 77, 143, 7, 53, 77,
				144, 7, 11, 14, 62, 77, 148, 7, 62, 109,
				149, 7, 14, 62, 77, 154, 7, 62, 109, 155,
				7, 7, 61, 77, 160, 7, 32, 77, 161, 7,
				7, 61, 77, 165, 7, 32, 77, 166, 7, 11,
				14, 42, 77, 171, 7, 172, 7, 0, 14, 40,
				77, 176, 7, 0, 14, 54, 77, 179, 7, 54,
				109, 180, 7, 14, 54, 77, 185, 7, 54, 109,
				186, 7, 11, 14, 32, 77, 191, 7, 0, 14,
				32, 77, 194, 7, 0, 0, 0, 11, 14, 41,
				77, 197, 7, 41, 109, 198, 7, 14, 41, 77,
				203, 7, 41, 109, 204, 7, 0, 0, 11, 14,
				41, 77, 209, 7, 41, 109, 210, 7, 14, 41,
				77, 215, 7, 41, 109, 216, 7, 0, 0, 11,
				14, 42, 77, 221, 7, 224, 7, 0, 14, 40,
				77, 227, 7, 0, 14, 54, 77, 230, 7, 54,
				109, 231, 7, 0, 11, 14, 32, 77, 236, 7,
				0, 14, 32, 77, 239, 7, 0, 0, 0, 8,
				6, 0, 2, 15, 0, 11, 14, 54, 77, 174,
				8, 54, 109, 175, 8, 14, 54, 77, 180, 8,
				54, 109, 181, 8, 0, 0, 11, 14, 62, 77,
				186, 8, 62, 109, 187, 8, 14, 62, 77, 192,
				8, 62, 109, 193, 8, 0, 0, 11, 0, 0,
				36, 77, 201, 8, 36, 77, 207, 8, 11, 14,
				32, 77, 212, 8, 32, 109, 213, 8, 14, 32,
				77, 218, 8, 32, 109, 219, 8, 0, 0, 11,
				0, 0, 24, 77, 229, 8, 24, 77, 235, 8,
				11, 0, 0, 24, 77, 243, 8, 24, 77, 249,
				8, 11, 54, 77, 254, 8, 54, 77, 129, 9,
				0, 0, 11, 54, 77, 133, 9, 54, 77, 134,
				9, 0, 0, 2, 17, 0, 11, 14, 9, 71,
				0, 4, 0, 50, 221, 35, 128, 128, 128, 8,
				0, 9, 48, 193, 9, 48, 194, 9, 14, 0,
				9, 48, 195, 9, 48, 196, 9, 0, 0, 11,
				14, 9, 71, 0, 4, 0, 50, 222, 35, 128,
				128, 128, 8, 0, 9, 48, 197, 9, 48, 198,
				9, 14, 0, 9, 48, 199, 9, 48, 200, 9,
				0, 0, 11, 14, 9, 71, 0, 4, 0, 50,
				223, 35, 128, 128, 128, 8, 0, 0, 0, 0,
				0, 11, 14, 9, 71, 50, 201, 9, 4, 0,
				50, 224, 35, 128, 128, 128, 8, 50, 202, 9,
				0, 14, 9, 50, 203, 9, 50, 204, 9, 0,
				0, 0, 11, 14, 9, 71, 0, 4, 0, 50,
				225, 35, 128, 128, 128, 8, 0, 9, 48, 205,
				9, 48, 206, 9, 14, 0, 9, 48, 207, 9,
				48, 208, 9, 0, 0, 11, 14, 9, 71, 0,
				4, 0, 50, 226, 35, 128, 128, 128, 8, 0,
				9, 48, 209, 9, 48, 210, 9, 14, 0, 9,
				48, 211, 9, 48, 212, 9, 0, 0, 11, 14,
				9, 71, 0, 4, 0, 50, 227, 35, 128, 128,
				128, 8, 0, 9, 48, 213, 9, 48, 214, 9,
				14, 0, 9, 48, 215, 9, 48, 216, 9, 0,
				0, 11, 14, 9, 71, 0, 4, 0, 50, 228,
				35, 128, 128, 128, 8, 0, 0, 0, 0, 0,
				11, 14, 9, 71, 0, 4, 0, 50, 229, 35,
				128, 128, 128, 8, 0, 0, 0, 0, 0, 11,
				14, 0, 9, 48, 217, 9, 48, 218, 9, 14,
				0, 9, 48, 219, 9, 48, 220, 9, 0, 0,
				11, 14, 0, 9, 48, 221, 9, 48, 222, 9,
				14, 0, 9, 48, 223, 9, 0, 0, 0, 2,
				4, 0, 11, 14, 23, 77, 226, 9, 23, 109,
				228, 9, 14, 23, 77, 232, 9, 23, 109, 234,
				9, 0, 0, 11, 14, 54, 77, 237, 9, 54,
				109, 238, 9, 14, 54, 77, 243, 9, 54, 109,
				244, 9, 41, 77, 249, 9, 41, 77, 252, 9,
				11, 14, 54, 77, 255, 9, 54, 109, 128, 10,
				0, 41, 77, 130, 10, 0, 11, 14, 54, 77,
				132, 10, 54, 109, 133, 10, 0, 41, 77, 135,
				10, 0, 11, 14, 41, 77, 137, 10, 41, 109,
				138, 10, 14, 41, 77, 143, 10, 41, 109, 144,
				10, 0, 0, 11, 14, 41, 77, 149, 10, 41,
				109, 150, 10, 14, 41, 77, 155, 10, 41, 109,
				156, 10, 0, 0, 11, 14, 41, 77, 161, 10,
				41, 109, 162, 10, 14, 41, 77, 167, 10, 41,
				109, 168, 10, 0, 0, 11, 14, 41, 77, 173,
				10, 41, 109, 174, 10, 14, 41, 77, 179, 10,
				41, 109, 180, 10, 0, 0, 11, 14, 41, 77,
				185, 10, 41, 109, 186, 10, 14, 41, 77, 191,
				10, 41, 109, 192, 10, 41, 77, 197, 10, 41,
				77, 200, 10, 11, 14, 41, 77, 203, 10, 41,
				109, 204, 10, 14, 41, 77, 209, 10, 41, 109,
				210, 10, 41, 77, 215, 10, 41, 77, 218, 10,
				11, 14, 54, 77, 221, 10, 55, 109, 77, 222,
				10, 14, 54, 77, 227, 10, 55, 77, 109, 228,
				10, 41, 77, 233, 10, 41, 77, 236, 10, 11,
				14, 54, 77, 239, 10, 54, 109, 240, 10, 14,
				54, 77, 248, 10, 54, 109, 249, 10, 14, 54,
				77, 254, 10, 54, 109, 255, 10, 0, 11, 14,
				41, 77, 132, 11, 41, 109, 133, 11, 14, 41,
				77, 138, 11, 41, 109, 139, 11, 41, 77, 144,
				11, 41, 77, 147, 11, 11, 14, 41, 77, 150,
				11, 41, 109, 151, 11, 14, 41, 77, 156, 11,
				41, 109, 157, 11, 41, 77, 162, 11, 41, 77,
				165, 11, 11, 14, 41, 77, 168, 11, 41, 109,
				169, 11, 14, 41, 77, 174, 11, 41, 109, 175,
				11, 41, 77, 180, 11, 41, 77, 183, 11, 11,
				14, 41, 77, 186, 11, 41, 109, 187, 11, 14,
				41, 77, 192, 11, 41, 109, 193, 11, 41, 77,
				198, 11, 41, 77, 201, 11, 11, 0, 14, 41,
				77, 205, 11, 41, 109, 206, 11, 0, 0, 11,
				0, 14, 41, 77, 212, 11, 41, 109, 213, 11,
				0, 0, 11, 0, 14, 41, 77, 219, 11, 41,
				109, 220, 11, 0, 0, 11, 0, 14, 41, 77,
				226, 11, 41, 109, 227, 11, 0, 0, 11, 0,
				14, 41, 77, 233, 11, 41, 109, 234, 11, 0,
				0, 11, 0, 14, 41, 77, 240, 11, 41, 109,
				241, 11, 0, 0, 11, 0, 14, 41, 77, 247,
				11, 41, 109, 248, 11, 0, 0, 11, 0, 14,
				41, 77, 254, 11, 41, 109, 255, 11, 0, 0,
				11, 0, 14, 41, 77, 133, 12, 41, 109, 134,
				12, 0, 0, 11, 0, 14, 41, 77, 140, 12,
				41, 109, 141, 12, 0, 0, 11, 0, 14, 41,
				77, 147, 12, 41, 109, 148, 12, 0, 0, 11,
				0, 14, 41, 77, 154, 12, 41, 109, 155, 12,
				0, 0, 11, 0, 14, 41, 77, 160, 12, 41,
				109, 161, 12, 0, 0, 11, 0, 14, 41, 77,
				166, 12, 41, 109, 167, 12, 0, 0, 11, 0,
				14, 59, 175, 12, 0, 0, 0, 11, 0, 14,
				54, 77, 181, 12, 54, 109, 182, 12, 14, 54,
				77, 190, 12, 54, 109, 191, 12, 0, 11, 0,
				14, 57, 77, 206, 12, 57, 109, 207, 12, 14,
				57, 77, 212, 12, 57, 109, 213, 12, 14, 57,
				77, 218, 12, 57, 109, 219, 12, 8, 6, 1,
				8, 6, 2, 8, 6, 3, 11, 0, 14, 41,
				77, 180, 13, 41, 109, 181, 13, 0, 0, 11,
				0, 14, 41, 77, 187, 13, 41, 109, 188, 13,
				0, 0, 11, 0, 14, 41, 77, 194, 13, 41,
				109, 195, 13, 0, 0, 12, 13, 35, 200, 13,
				35, 201, 13, 3, 3, 3, 2, 4, 0, 11,
				0, 14, 41, 77, 143, 14, 41, 109, 144, 14,
				0, 14, 41, 77, 146, 14, 41, 109, 147, 14,
				11, 0, 14, 41, 77, 149, 14, 41, 109, 150,
				14, 0, 14, 41, 77, 152, 14, 41, 109, 153,
				14, 11, 0, 14, 16, 158, 14, 0, 14, 54,
				77, 163, 14, 0, 0, 11, 0, 14, 62, 77,
				167, 14, 62, 109, 168, 14, 14, 62, 77, 176,
				14, 62, 109, 177, 14, 0, 2, 4, 0, 11,
				14, 9, 71, 0, 4, 0, 77, 230, 35, 128,
				128, 128, 8, 0, 0, 0, 0, 0, 11, 14,
				9, 71, 0, 4, 0, 77, 231, 35, 128, 128,
				128, 8, 0, 0, 0, 0, 0, 2, 10, 0,
				11, 14, 9, 71, 52, 254, 14, 4, 0, 50,
				232, 35, 128, 128, 128, 8, 52, 255, 14, 0,
				14, 9, 52, 128, 15, 52, 129, 15, 0, 0,
				0, 11, 14, 9, 31, 130, 15, 31, 131, 15,
				0, 14, 9, 31, 132, 15, 31, 133, 15, 0,
				0, 0, 11, 14, 9, 71, 49, 134, 15, 37,
				4, 0, 49, 233, 35, 37, 128, 128, 128, 8,
				0, 0, 14, 9, 49, 135, 15, 37, 0, 0,
				0, 14, 9, 49, 136, 15, 37, 4, 49, 136,
				15, 37, 49, 137, 15, 53, 0, 11, 14, 9,
				71, 17, 138, 15, 37, 4, 0, 17, 234, 35,
				37, 128, 128, 128, 8, 0, 0, 14, 9, 17,
				139, 15, 37, 0, 0, 0, 14, 9, 17, 140,
				15, 37, 4, 17, 140, 15, 37, 17, 141, 15,
				53, 0, 0, 11, 14, 9, 71, 0, 4, 0,
				72, 235, 35, 128, 128, 128, 8, 0, 0, 0,
				0, 0, 0, 11, 14, 9, 71, 0, 4, 0,
				72, 236, 35, 128, 128, 128, 8, 0, 0, 0,
				0, 0, 11, 14, 9, 71, 50, 142, 15, 4,
				0, 50, 237, 35, 128, 128, 128, 8, 50, 143,
				15, 0, 14, 9, 50, 144, 15, 50, 145, 15,
				0, 0, 0, 11, 14, 9, 50, 146, 15, 50,
				147, 15, 0, 14, 9, 50, 148, 15, 50, 149,
				15, 0, 0, 0, 2, 20, 0, 8, 6, 4,
				2, 9, 0, 11, 0, 0, 14, 71, 0, 4,
				0, 7, 74, 244, 35, 0, 128, 128, 128, 8,
				0, 0, 2, 3, 0, 11, 0, 0, 14, 71,
				0, 4, 0, 7, 74, 246, 35, 0, 128, 128,
				128, 8, 0, 14, 71, 0, 4, 0, 7, 74,
				248, 35, 0, 128, 128, 128, 8, 0, 11, 0,
				0, 14, 71, 0, 4, 0, 7, 74, 250, 35,
				0, 128, 128, 128, 8, 0, 0, 2, 4, 0,
				11, 14, 44, 77, 221, 16, 44, 109, 222, 16,
				14, 44, 77, 227, 16, 44, 109, 228, 16, 44,
				77, 233, 16, 44, 77, 236, 16, 0, 11, 0,
				14, 37, 77, 244, 16, 0, 0, 0, 11, 0,
				14, 21, 77, 252, 16, 0, 0, 0, 11, 14,
				44, 77, 129, 17, 44, 109, 130, 17, 14, 44,
				77, 135, 17, 44, 109, 136, 17, 0, 0, 2,
				9, 0, 11, 0, 14, 41, 77, 164, 17, 41,
				109, 165, 17, 0, 14, 41, 77, 167, 17, 41,
				109, 168, 17, 11, 0, 14, 43, 77, 77, 77,
				171, 17, 43, 109, 109, 77, 172, 17, 0, 0,
				11, 0, 14, 43, 77, 77, 77, 178, 17, 43,
				109, 109, 77, 179, 17, 0, 0, 11, 0, 14,
				43, 77, 77, 77, 185, 17, 43, 109, 109, 77,
				186, 17, 0, 0, 11, 0, 14, 41, 77, 192,
				17, 41, 109, 193, 17, 0, 0, 11, 0, 14,
				41, 77, 199, 17, 41, 109, 200, 17, 0, 0,
				11, 0, 14, 62, 77, 205, 17, 0, 0, 0,
				11, 0, 14, 23, 77, 213, 17, 23, 109, 215,
				17, 0, 0, 11, 0, 14, 41, 77, 219, 17,
				41, 109, 220, 17, 0, 0, 11, 0, 14, 41,
				77, 226, 17, 41, 109, 227, 17, 0, 0, 11,
				0, 14, 41, 77, 233, 17, 41, 109, 234, 17,
				0, 0, 11, 0, 14, 41, 77, 240, 17, 41,
				109, 241, 17, 0, 0, 11, 0, 14, 41, 77,
				250, 17, 41, 109, 251, 17, 0, 0, 11, 0,
				14, 41, 77, 129, 18, 41, 109, 130, 18, 0,
				0, 11, 0, 14, 41, 77, 136, 18, 41, 109,
				137, 18, 0, 0, 11, 0, 14, 41, 77, 143,
				18, 41, 109, 144, 18, 0, 0, 11, 0, 14,
				41, 77, 153, 18, 41, 109, 154, 18, 0, 0,
				11, 0, 14, 43, 77, 77, 77, 160, 18, 43,
				109, 109, 77, 161, 18, 0, 0, 11, 0, 14,
				43, 77, 77, 77, 167, 18, 43, 109, 109, 77,
				168, 18, 0, 0, 11, 0, 14, 41, 77, 177,
				18, 41, 109, 178, 18, 0, 0, 11, 0, 14,
				41, 77, 184, 18, 41, 109, 185, 18, 0, 0,
				11, 0, 14, 41, 77, 191, 18, 41, 109, 192,
				18, 0, 0, 11, 0, 14, 54, 77, 197, 18,
				55, 77, 109, 198, 18, 14, 54, 77, 203, 18,
				55, 109, 77, 204, 18, 14, 54, 77, 212, 18,
				55, 77, 109, 213, 18, 11, 0, 14, 32, 77,
				219, 18, 32, 109, 220, 18, 0, 0, 11, 0,
				14, 41, 77, 226, 18, 41, 109, 227, 18, 0,
				0, 11, 0, 14, 41, 77, 233, 18, 41, 109,
				234, 18, 0, 0, 11, 0, 14, 41, 77, 240,
				18, 41, 109, 241, 18, 0, 0, 11, 0, 14,
				41, 77, 247, 18, 41, 109, 248, 18, 0, 0,
				11, 0, 14, 41, 77, 129, 19, 41, 109, 130,
				19, 0, 0, 11, 0, 14, 41, 77, 136, 19,
				41, 109, 137, 19, 0, 0, 11, 0, 14, 41,
				77, 143, 19, 41, 109, 144, 19, 0, 0, 11,
				0, 14, 41, 77, 150, 19, 41, 109, 151, 19,
				0, 0, 11, 0, 0, 0, 14, 53, 77, 159,
				19, 53, 109, 160, 19, 11, 0, 14, 43, 77,
				77, 77, 163, 19, 43, 109, 109, 77, 164, 19,
				0, 0, 11, 0, 14, 43, 77, 77, 77, 170,
				19, 43, 109, 109, 77, 171, 19, 0, 0, 11,
				0, 14, 43, 77, 77, 77, 177, 19, 43, 109,
				109, 77, 178, 19, 0, 0, 11, 0, 14, 41,
				77, 184, 19, 41, 109, 185, 19, 0, 0, 11,
				0, 14, 41, 77, 191, 19, 41, 109, 192, 19,
				0, 0, 11, 0, 14, 41, 77, 198, 19, 41,
				109, 199, 19, 0, 0, 11, 0, 14, 33, 77,
				205, 19, 0, 0, 0, 11, 0, 14, 41, 77,
				208, 19, 41, 109, 209, 19, 0, 0, 11, 0,
				14, 41, 77, 215, 19, 41, 109, 216, 19, 0,
				0, 11, 0, 14, 41, 77, 222, 19, 41, 109,
				223, 19, 0, 0, 11, 0, 14, 41, 77, 229,
				19, 41, 109, 230, 19, 0, 0, 11, 0, 14,
				41, 77, 236, 19, 41, 109, 237, 19, 0, 0,
				11, 0, 14, 41, 77, 243, 19, 41, 109, 244,
				19, 0, 0, 11, 0, 14, 41, 77, 250, 19,
				41, 109, 251, 19, 0, 0, 0
			};
		}
	}
	internal static class OpCodeHandlersTables_XOP
	{
		internal static readonly OpCodeHandler[] Handlers_MAP8;

		internal static readonly OpCodeHandler[] Handlers_MAP9;

		internal static readonly OpCodeHandler[] Handlers_MAP10;

		private const int MaxIdNames = 7;

		private const uint Handlers_MAP8Index = 4u;

		private const uint Handlers_MAP9Index = 5u;

		private const uint Handlers_MAP10Index = 6u;

		static OpCodeHandlersTables_XOP()
		{
			VexOpCodeHandlerReader handlerReader = new VexOpCodeHandlerReader();
			TableDeserializer tableDeserializer = new TableDeserializer(handlerReader, 7, GetSerializedTables());
			tableDeserializer.Deserialize();
			Handlers_MAP8 = tableDeserializer.GetTable(4u);
			Handlers_MAP9 = tableDeserializer.GetTable(5u);
			Handlers_MAP10 = tableDeserializer.GetTable(6u);
		}

		private static ReadOnlySpan<byte> GetSerializedTables()
		{
			return new byte[768]
			{
				1, 8, 0, 10, 14, 28, 136, 32, 0, 10,
				14, 28, 138, 32, 0, 10, 14, 28, 140, 32,
				0, 10, 14, 28, 142, 32, 0, 10, 14, 28,
				144, 32, 0, 10, 14, 28, 146, 32, 0, 10,
				14, 28, 148, 32, 0, 1, 8, 0, 10, 14,
				28, 150, 32, 0, 2, 4, 0, 10, 14, 28,
				152, 32, 0, 0, 1, 8, 10, 14, 34, 154,
				32, 0, 10, 14, 34, 156, 32, 0, 2, 6,
				0, 1, 8, 10, 14, 27, 205, 32, 0, 10,
				14, 27, 207, 32, 0, 2, 6, 0, 1, 128,
				2, 2, 133, 1, 0, 10, 14, 9, 46, 77,
				234, 31, 0, 0, 10, 14, 9, 46, 77, 235,
				31, 0, 0, 10, 14, 9, 46, 77, 236, 31,
				0, 0, 2, 6, 0, 10, 14, 9, 46, 77,
				237, 31, 0, 0, 10, 14, 9, 46, 77, 238,
				31, 0, 0, 2, 5, 0, 10, 14, 9, 46,
				77, 239, 31, 0, 0, 10, 14, 9, 46, 77,
				240, 31, 0, 0, 10, 14, 9, 46, 77, 241,
				31, 0, 0, 2, 6, 0, 10, 14, 9, 46,
				77, 242, 31, 0, 0, 10, 14, 9, 46, 77,
				243, 31, 0, 0, 1, 10, 9, 14, 46, 77,
				244, 31, 46, 109, 245, 31, 14, 38, 77, 246,
				31, 38, 109, 247, 31, 10, 9, 14, 46, 77,
				248, 31, 0, 14, 38, 77, 249, 31, 0, 1,
				10, 14, 9, 46, 77, 250, 31, 0, 0, 2,
				15, 0, 10, 14, 9, 46, 77, 251, 31, 0,
				0, 2, 9, 0, 10, 14, 9, 57, 77, 252,
				31, 0, 0, 10, 14, 9, 57, 77, 253, 31,
				0, 0, 10, 14, 9, 57, 77, 254, 31, 0,
				0, 10, 14, 9, 57, 77, 255, 31, 0, 0,
				2, 8, 0, 10, 14, 9, 44, 77, 128, 32,
				0, 0, 10, 14, 9, 44, 77, 129, 32, 0,
				0, 10, 14, 9, 44, 77, 130, 32, 0, 0,
				10, 14, 9, 44, 77, 131, 32, 0, 0, 2,
				28, 0, 10, 14, 9, 44, 77, 132, 32, 0,
				0, 10, 14, 9, 44, 77, 133, 32, 0, 0,
				10, 14, 9, 44, 77, 134, 32, 0, 0, 10,
				14, 9, 44, 77, 135, 32, 0, 0, 2, 16,
				0, 1, 128, 2, 0, 8, 6, 0, 8, 6,
				1, 2, 15, 0, 8, 6, 2, 2, 109, 0,
				10, 14, 9, 54, 77, 158, 32, 0, 9, 54,
				109, 159, 32, 0, 10, 14, 9, 54, 77, 160,
				32, 0, 9, 54, 109, 161, 32, 0, 10, 14,
				9, 54, 77, 162, 32, 0, 0, 10, 14, 9,
				54, 77, 163, 32, 0, 0, 2, 12, 0, 10,
				14, 9, 56, 77, 164, 32, 41, 77, 165, 32,
				0, 10, 14, 9, 56, 77, 166, 32, 41, 77,
				167, 32, 0, 10, 14, 9, 56, 77, 168, 32,
				41, 77, 169, 32, 0, 10, 14, 9, 56, 77,
				170, 32, 41, 77, 171, 32, 0, 10, 14, 9,
				56, 77, 172, 32, 41, 77, 173, 32, 0, 10,
				14, 9, 56, 77, 174, 32, 41, 77, 175, 32,
				0, 10, 14, 9, 56, 77, 176, 32, 41, 77,
				177, 32, 0, 10, 14, 9, 56, 77, 178, 32,
				41, 77, 179, 32, 0, 10, 14, 9, 56, 77,
				180, 32, 41, 77, 181, 32, 0, 10, 14, 9,
				56, 77, 182, 32, 41, 77, 183, 32, 0, 10,
				14, 9, 56, 77, 184, 32, 41, 77, 185, 32,
				0, 10, 14, 9, 56, 77, 186, 32, 41, 77,
				187, 32, 0, 2, 37, 0, 10, 14, 9, 54,
				77, 188, 32, 0, 0, 10, 14, 9, 54, 77,
				189, 32, 0, 0, 10, 14, 9, 54, 77, 190,
				32, 0, 0, 1, 10, 14, 9, 54, 77, 191,
				32, 0, 0, 10, 14, 9, 54, 77, 192, 32,
				0, 0, 2, 3, 0, 10, 14, 9, 54, 77,
				193, 32, 0, 0, 2, 5, 0, 10, 14, 9,
				54, 77, 194, 32, 0, 0, 10, 14, 9, 54,
				77, 195, 32, 0, 0, 10, 14, 9, 54, 77,
				196, 32, 0, 0, 1, 10, 14, 9, 54, 77,
				197, 32, 0, 0, 10, 14, 9, 54, 77, 198,
				32, 0, 0, 2, 3, 0, 10, 14, 9, 54,
				77, 199, 32, 0, 0, 2, 5, 0, 10, 14,
				9, 54, 77, 200, 32, 0, 0, 10, 14, 9,
				54, 77, 201, 32, 0, 0, 10, 14, 9, 54,
				77, 202, 32, 0, 0, 2, 28, 0, 1, 128,
				2, 2, 16, 0, 10, 14, 20, 203, 32, 0,
				0, 8, 6, 3, 2, 237, 1, 0
			};
		}
	}
	internal sealed class OpCodeHandler_D3NOW : OpCodeHandlerModRM
	{
		internal static readonly Code[] CodeValues = CreateCodeValues();

		private readonly Code[] codeValues = CodeValues;

		private static Code[] CreateCodeValues()
		{
			Code[] array = new Code[256];
			array[191] = Code.D3NOW_Pavgusb_mm_mmm64;
			array[187] = Code.D3NOW_Pswapd_mm_mmm64;
			array[183] = Code.D3NOW_Pmulhrw_mm_mmm64;
			array[182] = Code.D3NOW_Pfrcpit2_mm_mmm64;
			array[180] = Code.D3NOW_Pfmul_mm_mmm64;
			array[176] = Code.D3NOW_Pfcmpeq_mm_mmm64;
			array[174] = Code.D3NOW_Pfacc_mm_mmm64;
			array[170] = Code.D3NOW_Pfsubr_mm_mmm64;
			array[167] = Code.D3NOW_Pfrsqit1_mm_mmm64;
			array[166] = Code.D3NOW_Pfrcpit1_mm_mmm64;
			array[164] = Code.D3NOW_Pfmax_mm_mmm64;
			array[160] = Code.D3NOW_Pfcmpgt_mm_mmm64;
			array[158] = Code.D3NOW_Pfadd_mm_mmm64;
			array[154] = Code.D3NOW_Pfsub_mm_mmm64;
			array[151] = Code.D3NOW_Pfrsqrt_mm_mmm64;
			array[150] = Code.D3NOW_Pfrcp_mm_mmm64;
			array[148] = Code.D3NOW_Pfmin_mm_mmm64;
			array[144] = Code.D3NOW_Pfcmpge_mm_mmm64;
			array[142] = Code.D3NOW_Pfpnacc_mm_mmm64;
			array[138] = Code.D3NOW_Pfnacc_mm_mmm64;
			array[135] = Code.D3NOW_Pfrsqrtv_mm_mmm64;
			array[134] = Code.D3NOW_Pfrcpv_mm_mmm64;
			array[29] = Code.D3NOW_Pf2id_mm_mmm64;
			array[28] = Code.D3NOW_Pf2iw_mm_mmm64;
			array[13] = Code.D3NOW_Pi2fd_mm_mmm64;
			array[12] = Code.D3NOW_Pi2fw_mm_mmm64;
			return array;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op0Register = (Register)(decoder.state.reg + 225);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 225);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			Code code = codeValues[decoder.ReadByte()];
			if ((uint)(code - 4181) <= 1u && ((decoder.options & DecoderOptions.Cyrix) == 0 || decoder.Bitness == 64))
			{
				code = Code.INVALID;
			}
			instruction.InternalSetCodeNoCheck(code);
			if (code == Code.INVALID)
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VectorLength_EVEX : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler[] handlers;

		public OpCodeHandler_VectorLength_EVEX(OpCodeHandler handler128, OpCodeHandler handler256, OpCodeHandler handler512)
		{
			handlers = new OpCodeHandler[4]
			{
				handler128 ?? throw new ArgumentNullException("handler128"),
				handler256 ?? throw new ArgumentNullException("handler256"),
				handler512 ?? throw new ArgumentNullException("handler512"),
				OpCodeHandler_Invalid.Instance
			};
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			handlers[decoder.state.vectorLength].Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VectorLength_EVEX_er : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler[] handlers;

		public OpCodeHandler_VectorLength_EVEX_er(OpCodeHandler handler128, OpCodeHandler handler256, OpCodeHandler handler512)
		{
			handlers = new OpCodeHandler[4]
			{
				handler128 ?? throw new ArgumentNullException("handler128"),
				handler256 ?? throw new ArgumentNullException("handler256"),
				handler512 ?? throw new ArgumentNullException("handler512"),
				OpCodeHandler_Invalid.Instance
			};
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			int num = (int)decoder.state.vectorLength;
			if (decoder.state.mod == 3 && (decoder.state.zs.flags & StateFlags.b) != 0)
			{
				num = 2;
			}
			handlers[num].Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_EVEX_V_H_Ev_er : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code codeW0;

		private readonly Code codeW1;

		private readonly TupleType tupleTypeW0;

		private readonly TupleType tupleTypeW1;

		public OpCodeHandler_EVEX_V_H_Ev_er(Register baseReg, Code codeW0, Code codeW1, TupleType tupleTypeW0, TupleType tupleTypeW1)
		{
			this.baseReg = baseReg;
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
			this.tupleTypeW0 = tupleTypeW0;
			this.tupleTypeW1 = tupleTypeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & StateFlags.z) | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			TupleType tupleType;
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(codeW1);
				tupleType = tupleTypeW1;
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW0);
				tupleType = tupleTypeW0;
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					instruction.InternalRoundingControl = decoder.state.vectorLength + 1;
				}
				return;
			}
			if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op2Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_V_H_Ev_Ib : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code codeW0;

		private readonly Code codeW1;

		private readonly TupleType tupleTypeW0;

		private readonly TupleType tupleTypeW1;

		public OpCodeHandler_EVEX_V_H_Ev_Ib(Register baseReg, Code codeW0, Code codeW1, TupleType tupleTypeW0, TupleType tupleTypeW1)
		{
			this.baseReg = baseReg;
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
			this.tupleTypeW0 = tupleTypeW0;
			this.tupleTypeW1 = tupleTypeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(codeW1);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW0);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op2Kind = OpKind.Memory;
				if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
				{
					decoder.ReadOpMem(ref instruction, tupleTypeW1);
				}
				else
				{
					decoder.ReadOpMem(ref instruction, tupleTypeW0);
				}
			}
			instruction.Op3Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_Ed_V_Ib : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code32;

		private readonly Code code64;

		private readonly TupleType tupleType32;

		private readonly TupleType tupleType64;

		public OpCodeHandler_EVEX_Ed_V_Ib(Register baseReg, Code code32, Code code64, TupleType tupleType32, TupleType tupleType64)
		{
			this.baseReg = baseReg;
			this.code32 = code32;
			this.code64 = code64;
			this.tupleType32 = tupleType32;
			this.tupleType64 = tupleType64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
				{
					decoder.ReadOpMem(ref instruction, tupleType64);
				}
				else
				{
					decoder.ReadOpMem(ref instruction, tupleType32);
				}
			}
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkHW_er : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool onlySAE;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_VkHW_er(Register baseReg, Code code, TupleType tupleType, bool onlySAE, bool canBroadcast)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.onlySAE = onlySAE;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					if (onlySAE)
					{
						instruction.InternalSetSuppressAllExceptions();
					}
					else
					{
						instruction.InternalRoundingControl = decoder.state.vectorLength + 1;
					}
				}
				return;
			}
			instruction.Op2Kind = OpKind.Memory;
			if ((decoder.state.zs.flags & StateFlags.b) != 0)
			{
				if (canBroadcast)
				{
					instruction.InternalSetIsBroadcast();
				}
				else if (decoder.invalidCheckMask != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkHW_er_ur : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_VkHW_er_ur(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			int num = (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX);
			instruction.Op0Register = num + baseReg;
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				int num2 = (int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX);
				instruction.Op2Register = num2 + baseReg;
				if (decoder.invalidCheckMask != 0 && (num == (int)decoder.state.vvvv || num == num2))
				{
					decoder.SetInvalidInstruction();
				}
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					instruction.InternalRoundingControl = decoder.state.vectorLength + 1;
				}
				return;
			}
			if (decoder.invalidCheckMask != 0 && num == (int)decoder.state.vvvv)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op2Kind = OpKind.Memory;
			if ((decoder.state.zs.flags & StateFlags.b) != 0)
			{
				if (canBroadcast)
				{
					instruction.InternalSetIsBroadcast();
				}
				else if (decoder.invalidCheckMask != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkW_er : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool onlySAE;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_VkW_er(Register baseReg, Code code, TupleType tupleType, bool onlySAE)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.onlySAE = onlySAE;
			canBroadcast = true;
		}

		public OpCodeHandler_EVEX_VkW_er(Register baseReg1, Register baseReg2, Code code, TupleType tupleType, bool onlySAE)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.code = code;
			this.tupleType = tupleType;
			this.onlySAE = onlySAE;
			canBroadcast = true;
		}

		public OpCodeHandler_EVEX_VkW_er(Register baseReg1, Register baseReg2, Code code, TupleType tupleType, bool onlySAE, bool canBroadcast)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.code = code;
			this.tupleType = tupleType;
			this.onlySAE = onlySAE;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg2);
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					if (onlySAE)
					{
						instruction.InternalSetSuppressAllExceptions();
					}
					else
					{
						instruction.InternalRoundingControl = decoder.state.vectorLength + 1;
					}
				}
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			if ((decoder.state.zs.flags & StateFlags.b) != 0)
			{
				if (canBroadcast)
				{
					instruction.InternalSetIsBroadcast();
				}
				else if (decoder.invalidCheckMask != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkWIb_er : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VkWIb_er(Register baseReg, Code code, TupleType tupleType)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg2);
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					instruction.InternalSetSuppressAllExceptions();
				}
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					instruction.InternalSetIsBroadcast();
				}
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkW : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_VkW(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public OpCodeHandler_EVEX_VkW(Register baseReg1, Register baseReg2, Code code, TupleType tupleType, bool canBroadcast)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg2);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			if ((decoder.state.zs.flags & StateFlags.b) != 0)
			{
				if (canBroadcast)
				{
					instruction.InternalSetIsBroadcast();
				}
				else if (decoder.invalidCheckMask != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_WkV : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly uint disallowZeroingMasking;

		public OpCodeHandler_EVEX_WkV(Register baseReg, Code code, TupleType tupleType)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			disallowZeroingMasking = 0u;
		}

		public OpCodeHandler_EVEX_WkV(Register baseReg, Code code, TupleType tupleType, bool allowZeroingMasking)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			disallowZeroingMasking = ((!allowZeroingMasking) ? uint.MaxValue : 0u);
		}

		public OpCodeHandler_EVEX_WkV(Register baseReg1, Register baseReg2, Code code, TupleType tupleType)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.code = code;
			this.tupleType = tupleType;
			disallowZeroingMasking = 0u;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & StateFlags.b) | decoder.state.vvvv_invalidCheck) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg2);
			if (((uint)(decoder.state.zs.flags & StateFlags.z) & disallowZeroingMasking & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg1);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			if (((uint)(decoder.state.zs.flags & StateFlags.z) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkM : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VkM(Register baseReg, Code code, TupleType tupleType)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & StateFlags.b) | decoder.state.vvvv_invalidCheck) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkWIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_VkWIb(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg2);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					if (canBroadcast)
					{
						instruction.InternalSetIsBroadcast();
					}
					else if (decoder.invalidCheckMask != 0)
					{
						decoder.SetInvalidInstruction();
					}
				}
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_WkVIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_WkVIb(Register baseReg1, Register baseReg2, Code code, TupleType tupleType)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & StateFlags.b) | decoder.state.vvvv_invalidCheck) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg1);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				if (((uint)(decoder.state.zs.flags & StateFlags.z) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg2);
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_HkWIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_HkWIb(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)decoder.state.vvvv + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg2);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					if (canBroadcast)
					{
						instruction.InternalSetIsBroadcast();
					}
					else if (decoder.invalidCheckMask != 0)
					{
						decoder.SetInvalidInstruction();
					}
				}
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_HWIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_HWIb(Register baseReg, Code code, TupleType tupleType)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op0Register = (Register)((int)decoder.state.vvvv + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg2);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_WkVIb_er : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_WkVIb_er(Register baseReg1, Register baseReg2, Code code, TupleType tupleType)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg1);
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					instruction.InternalSetSuppressAllExceptions();
				}
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				if (((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg2);
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_VW_er : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VW_er(Register baseReg, Code code, TupleType tupleType)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			if ((((uint)(decoder.state.zs.flags & StateFlags.z) | decoder.state.vvvv_invalidCheck | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg2);
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					instruction.InternalSetSuppressAllExceptions();
				}
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VW : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VW(Register baseReg, Code code, TupleType tupleType)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg2);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction, tupleType);
			}
		}
	}
	internal sealed class OpCodeHandler_EVEX_WV : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_WV(Register baseReg, Code code, TupleType tupleType)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg2);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction, tupleType);
			}
		}
	}
	internal sealed class OpCodeHandler_EVEX_VM : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VM(Register baseReg, Code code, TupleType tupleType)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VK : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_EVEX_VK(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 173);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_EVEX_KR : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_EVEX_KR(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa | decoder.state.zs.extraRegisterBase | decoder.state.extraRegisterBaseEVEX) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_EVEX_KkHWIb_sae : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_KkHWIb_sae(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & StateFlags.z) | decoder.state.zs.extraRegisterBase | decoder.state.extraRegisterBaseEVEX) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					instruction.InternalSetSuppressAllExceptions();
				}
			}
			else
			{
				instruction.Op2Kind = OpKind.Memory;
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					if (canBroadcast)
					{
						instruction.InternalSetIsBroadcast();
					}
					else if (decoder.invalidCheckMask != 0)
					{
						decoder.SetInvalidInstruction();
					}
				}
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op3Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkHW : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Register baseReg3;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_VkHW(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			baseReg3 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public OpCodeHandler_EVEX_VkHW(Register baseReg1, Register baseReg2, Register baseReg3, Code code, TupleType tupleType, bool canBroadcast)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.baseReg3 = baseReg3;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg2);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg3);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				return;
			}
			instruction.Op2Kind = OpKind.Memory;
			if ((decoder.state.zs.flags & StateFlags.b) != 0)
			{
				if (canBroadcast)
				{
					instruction.InternalSetIsBroadcast();
				}
				else if (decoder.invalidCheckMask != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkHM : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VkHM(Register baseReg, Code code, TupleType tupleType)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg2);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op2Kind = OpKind.Memory;
			if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkHWIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Register baseReg3;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_VkHWIb(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			baseReg3 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public OpCodeHandler_EVEX_VkHWIb(Register baseReg1, Register baseReg2, Register baseReg3, Code code, TupleType tupleType, bool canBroadcast)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.baseReg3 = baseReg3;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg2);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg3);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				instruction.Op2Kind = OpKind.Memory;
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					if (canBroadcast)
					{
						instruction.InternalSetIsBroadcast();
					}
					else if (decoder.invalidCheckMask != 0)
					{
						decoder.SetInvalidInstruction();
					}
				}
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op3Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkHWIb_er : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Register baseReg3;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_VkHWIb_er(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			baseReg3 = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg2);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg3);
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					instruction.InternalSetSuppressAllExceptions();
				}
			}
			else
			{
				instruction.Op2Kind = OpKind.Memory;
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					if (canBroadcast)
					{
						instruction.InternalSetIsBroadcast();
					}
					else if (decoder.invalidCheckMask != 0)
					{
						decoder.SetInvalidInstruction();
					}
				}
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op3Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_KkHW : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_KkHW(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if ((((uint)(decoder.state.zs.flags & StateFlags.z) | decoder.state.zs.extraRegisterBase | decoder.state.extraRegisterBaseEVEX) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				return;
			}
			instruction.Op2Kind = OpKind.Memory;
			if ((decoder.state.zs.flags & StateFlags.b) != 0)
			{
				if (canBroadcast)
				{
					instruction.InternalSetIsBroadcast();
				}
				else if (decoder.invalidCheckMask != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_KP1HW : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_KP1HW(Register baseReg, Code code, TupleType tupleType)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if ((((uint)(decoder.state.zs.flags & StateFlags.z) | decoder.state.aaa | decoder.state.zs.extraRegisterBase | decoder.state.extraRegisterBaseEVEX) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				return;
			}
			instruction.Op2Kind = OpKind.Memory;
			if ((decoder.state.zs.flags & StateFlags.b) != 0)
			{
				instruction.InternalSetIsBroadcast();
			}
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_KkHWIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_KkHWIb(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if ((((uint)(decoder.state.zs.flags & StateFlags.z) | decoder.state.zs.extraRegisterBase | decoder.state.extraRegisterBaseEVEX) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				instruction.Op2Kind = OpKind.Memory;
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					if (canBroadcast)
					{
						instruction.InternalSetIsBroadcast();
					}
					else if (decoder.invalidCheckMask != 0)
					{
						decoder.SetInvalidInstruction();
					}
				}
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op3Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_WkHV : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_EVEX_WkHV(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
			if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			instruction.Op2Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VHWIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VHWIb(Register baseReg, Code code, TupleType tupleType)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
			}
			else
			{
				instruction.Op2Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op3Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_VHW : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Register baseReg3;

		private readonly Code codeR;

		private readonly Code codeM;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VHW(Register baseReg, Code codeR, Code codeM, TupleType tupleType)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			baseReg3 = baseReg;
			this.codeR = codeR;
			this.codeM = codeM;
			this.tupleType = tupleType;
		}

		public OpCodeHandler_EVEX_VHW(Register baseReg, Code code, TupleType tupleType)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			baseReg3 = baseReg;
			codeR = code;
			codeM = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg1);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg2);
			if (decoder.state.mod == 3)
			{
				instruction.InternalSetCodeNoCheck(codeR);
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg3);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeM);
				instruction.Op2Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction, tupleType);
			}
		}
	}
	internal sealed class OpCodeHandler_EVEX_VHM : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VHM(Register baseReg, Code code, TupleType tupleType)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op2Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_Gv_W_er : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code codeW0;

		private readonly Code codeW1;

		private readonly TupleType tupleType;

		private readonly bool onlySAE;

		public OpCodeHandler_EVEX_Gv_W_er(Register baseReg, Code codeW0, Code codeW1, TupleType tupleType, bool onlySAE)
		{
			this.baseReg = baseReg;
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
			this.tupleType = tupleType;
			this.onlySAE = onlySAE;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & StateFlags.z) | decoder.state.vvvv_invalidCheck | decoder.state.aaa | decoder.state.extraRegisterBaseEVEX) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(codeW1);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW0);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					if (onlySAE)
					{
						instruction.InternalSetSuppressAllExceptions();
					}
					else
					{
						instruction.InternalRoundingControl = decoder.state.vectorLength + 1;
					}
				}
			}
			else
			{
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction, tupleType);
			}
		}
	}
	internal sealed class OpCodeHandler_EVEX_VX_Ev : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		private readonly TupleType tupleTypeW0;

		private readonly TupleType tupleTypeW1;

		public OpCodeHandler_EVEX_VX_Ev(Code code32, Code code64, TupleType tupleTypeW0, TupleType tupleTypeW1)
		{
			this.code32 = code32;
			this.code64 = code64;
			this.tupleTypeW0 = tupleTypeW0;
			this.tupleTypeW1 = tupleTypeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			TupleType tupleType;
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				tupleType = tupleTypeW1;
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				tupleType = tupleTypeW0;
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX + 77);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_Ev_VX : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		private readonly TupleType tupleTypeW0;

		private readonly TupleType tupleTypeW1;

		public OpCodeHandler_EVEX_Ev_VX(Code code32, Code code64, TupleType tupleTypeW0, TupleType tupleTypeW1)
		{
			this.code32 = code32;
			this.code64 = code64;
			this.tupleTypeW0 = tupleTypeW0;
			this.tupleTypeW1 = tupleTypeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX + 77);
			TupleType tupleType;
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				tupleType = tupleTypeW1;
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				tupleType = tupleTypeW0;
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_Ev_VX_Ib : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_EVEX_Ev_VX_Ib(Register baseReg, Code code32, Code code64)
		{
			this.baseReg = baseReg;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa | decoder.state.extraRegisterBaseEVEX) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_MV : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_MV(Register baseReg, Code code, TupleType tupleType)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VkEv_REXW : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_EVEX_VkEv_REXW(Register baseReg, Code code32)
		{
			this.baseReg = baseReg;
			this.code32 = code32;
			code64 = Code.INVALID;
		}

		public OpCodeHandler_EVEX_VkEv_REXW(Register baseReg, Code code32, Code code64)
		{
			this.baseReg = baseReg;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & StateFlags.b) | decoder.state.vvvv_invalidCheck) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_EVEX_Vk_VSIB : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Register vsibBase;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_Vk_VSIB(Register baseReg, Register vsibBase, Code code, TupleType tupleType)
		{
			this.baseReg = baseReg;
			this.vsibBase = vsibBase;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.invalidCheckMask != 0 && (((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | (decoder.state.vvvv_invalidCheck & 0xF)) != 0 || decoder.state.aaa == 0))
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			int num = (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX);
			instruction.Op0Register = num + baseReg;
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem_VSIB(ref instruction, vsibBase, tupleType);
			if (decoder.invalidCheckMask != 0 && num == (int)((uint)(instruction.MemoryIndex - 77) % 32u))
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_EVEX_VSIB_k1_VX : OpCodeHandlerModRM
	{
		private readonly Register vsibIndex;

		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VSIB_k1_VX(Register vsibIndex, Register baseReg, Code code, TupleType tupleType)
		{
			this.vsibIndex = vsibIndex;
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.invalidCheckMask != 0 && (((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | (decoder.state.vvvv_invalidCheck & 0xF)) != 0 || decoder.state.aaa == 0))
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem_VSIB(ref instruction, vsibIndex, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_VSIB_k1 : OpCodeHandlerModRM
	{
		private readonly Register vsibIndex;

		private readonly Code code;

		private readonly TupleType tupleType;

		public OpCodeHandler_EVEX_VSIB_k1(Register vsibIndex, Code code, TupleType tupleType)
		{
			this.vsibIndex = vsibIndex;
			this.code = code;
			this.tupleType = tupleType;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.invalidCheckMask != 0 && (((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | (decoder.state.vvvv_invalidCheck & 0xF)) != 0 || decoder.state.aaa == 0))
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem_VSIB(ref instruction, vsibIndex, tupleType);
		}
	}
	internal sealed class OpCodeHandler_EVEX_GvM_VX_Ib : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code32;

		private readonly Code code64;

		private readonly TupleType tupleType32;

		private readonly TupleType tupleType64;

		public OpCodeHandler_EVEX_GvM_VX_Ib(Register baseReg, Code code32, Code code64, TupleType tupleType32, TupleType tupleType64)
		{
			this.baseReg = baseReg;
			this.code32 = code32;
			this.code64 = code64;
			this.tupleType32 = tupleType32;
			this.tupleType64 = tupleType64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & (StateFlags.b | StateFlags.z)) | decoder.state.vvvv_invalidCheck | decoder.state.aaa) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
				{
					decoder.ReadOpMem(ref instruction, tupleType64);
				}
				else
				{
					decoder.ReadOpMem(ref instruction, tupleType32);
				}
			}
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase + decoder.state.extraRegisterBaseEVEX) + (int)baseReg);
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_EVEX_KkWIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		private readonly TupleType tupleType;

		private readonly bool canBroadcast;

		public OpCodeHandler_EVEX_KkWIb(Register baseReg, Code code, TupleType tupleType, bool canBroadcast)
		{
			this.baseReg = baseReg;
			this.code = code;
			this.tupleType = tupleType;
			this.canBroadcast = canBroadcast;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((((uint)(decoder.state.zs.flags & StateFlags.z) | decoder.state.vvvv_invalidCheck | decoder.state.zs.extraRegisterBase | decoder.state.extraRegisterBaseEVEX) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.extraBaseRegisterBaseEVEX) + (int)baseReg);
				if (((uint)(decoder.state.zs.flags & StateFlags.b) & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				if ((decoder.state.zs.flags & StateFlags.b) != 0)
				{
					if (canBroadcast)
					{
						instruction.InternalSetIsBroadcast();
					}
					else if (decoder.invalidCheckMask != 0)
					{
						decoder.SetInvalidInstruction();
					}
				}
				decoder.ReadOpMem(ref instruction, tupleType);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_ST_STi : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_ST_STi(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = Register.ST0;
			instruction.Op1Register = (Register)(217 + decoder.state.rm);
		}
	}
	internal sealed class OpCodeHandler_STi_ST : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_STi_ST(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(217 + decoder.state.rm);
			instruction.Op1Register = Register.ST0;
		}
	}
	internal sealed class OpCodeHandler_STi : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_STi(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(217 + decoder.state.rm);
		}
	}
	internal sealed class OpCodeHandler_Mf : OpCodeHandlerModRM
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_Mf(Code code)
		{
			code16 = code;
			code32 = code;
		}

		public OpCodeHandler_Mf(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal struct Code3
	{
		public unsafe fixed ushort codes[3];

		public unsafe Code3(Code code16, Code code32, Code code64)
		{
			codes[0] = (ushort)code16;
			codes[1] = (ushort)code32;
			codes[2] = (ushort)code64;
		}
	}
	internal sealed class OpCodeHandler_VEX2 : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler handlerMem;

		public OpCodeHandler_VEX2(OpCodeHandler handlerMem)
		{
			this.handlerMem = handlerMem ?? throw new ArgumentNullException("handlerMem");
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				decoder.VEX2(ref instruction);
			}
			else if (decoder.state.mod == 3)
			{
				decoder.VEX2(ref instruction);
			}
			else
			{
				handlerMem.Decode(decoder, ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_VEX3 : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler handlerMem;

		public OpCodeHandler_VEX3(OpCodeHandler handlerMem)
		{
			this.handlerMem = handlerMem ?? throw new ArgumentNullException("handlerMem");
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				decoder.VEX3(ref instruction);
			}
			else if (decoder.state.mod == 3)
			{
				decoder.VEX3(ref instruction);
			}
			else
			{
				handlerMem.Decode(decoder, ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_XOP : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler handler_reg0;

		public OpCodeHandler_XOP(OpCodeHandler handler_reg0)
		{
			this.handler_reg0 = handler_reg0 ?? throw new ArgumentNullException("handler_reg0");
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.modrm & 0x1F) < 8)
			{
				handler_reg0.Decode(decoder, ref instruction);
			}
			else
			{
				decoder.XOP(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_EVEX : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler handlerMem;

		public OpCodeHandler_EVEX(OpCodeHandler handlerMem)
		{
			this.handlerMem = handlerMem ?? throw new ArgumentNullException("handlerMem");
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				decoder.EVEX_MVEX(ref instruction);
			}
			else if (decoder.state.mod == 3)
			{
				decoder.EVEX_MVEX(ref instruction);
			}
			else
			{
				handlerMem.Decode(decoder, ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_PrefixEsCsSsDs : OpCodeHandler
	{
		private readonly Register seg;

		public OpCodeHandler_PrefixEsCsSsDs(Register seg)
		{
			this.seg = seg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (!decoder.is64bMode || decoder.state.zs.segmentPrio <= 0)
			{
				instruction.SegmentPrefix = seg;
			}
			decoder.ResetRexPrefixState();
			decoder.CallOpCodeHandlerXXTable(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_PrefixFsGs : OpCodeHandler
	{
		private readonly Register seg;

		public OpCodeHandler_PrefixFsGs(Register seg)
		{
			this.seg = seg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.SegmentPrefix = seg;
			decoder.state.zs.segmentPrio = 1;
			decoder.ResetRexPrefixState();
			decoder.CallOpCodeHandlerXXTable(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Prefix66 : OpCodeHandler
	{
		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.state.zs.flags |= StateFlags.Has66;
			decoder.state.operandSize = decoder.defaultInvertedOperandSize;
			if (decoder.state.zs.mandatoryPrefix == MandatoryPrefixByte.None)
			{
				decoder.state.zs.mandatoryPrefix = MandatoryPrefixByte.P66;
			}
			decoder.ResetRexPrefixState();
			decoder.CallOpCodeHandlerXXTable(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Prefix67 : OpCodeHandler
	{
		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.state.addressSize = decoder.defaultInvertedAddressSize;
			decoder.ResetRexPrefixState();
			decoder.CallOpCodeHandlerXXTable(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_PrefixF0 : OpCodeHandler
	{
		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetHasLockPrefix();
			decoder.state.zs.flags |= StateFlags.Lock;
			decoder.ResetRexPrefixState();
			decoder.CallOpCodeHandlerXXTable(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_PrefixF2 : OpCodeHandler
	{
		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetHasRepnePrefix();
			decoder.state.zs.mandatoryPrefix = MandatoryPrefixByte.PF2;
			decoder.ResetRexPrefixState();
			decoder.CallOpCodeHandlerXXTable(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_PrefixF3 : OpCodeHandler
	{
		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetHasRepePrefix();
			decoder.state.zs.mandatoryPrefix = MandatoryPrefixByte.PF3;
			decoder.ResetRexPrefixState();
			decoder.CallOpCodeHandlerXXTable(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_PrefixREX : OpCodeHandler
	{
		private readonly OpCodeHandler handler;

		private readonly uint rex;

		public OpCodeHandler_PrefixREX(OpCodeHandler handler, uint rex)
		{
			this.handler = handler ?? throw new InvalidOperationException();
			this.rex = rex;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if ((rex & 8) != 0)
				{
					decoder.state.operandSize = OpSize.Size64;
					decoder.state.zs.flags |= StateFlags.HasRex | StateFlags.W;
				}
				else
				{
					decoder.state.zs.flags |= StateFlags.HasRex;
					decoder.state.zs.flags &= ~StateFlags.W;
					if ((decoder.state.zs.flags & StateFlags.Has66) == 0)
					{
						decoder.state.operandSize = OpSize.Size32;
					}
					else
					{
						decoder.state.operandSize = OpSize.Size16;
					}
				}
				decoder.state.zs.extraRegisterBase = (rex << 1) & 8;
				decoder.state.zs.extraIndexRegisterBase = (rex << 2) & 8;
				decoder.state.zs.extraBaseRegisterBase = (rex << 3) & 8;
				decoder.CallOpCodeHandlerXXTable(ref instruction);
			}
			else
			{
				handler.Decode(decoder, ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_Reg : OpCodeHandler
	{
		private readonly Code code;

		private readonly Register reg;

		public OpCodeHandler_Reg(Code code, Register reg)
		{
			this.code = code;
			this.reg = reg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = reg;
		}
	}
	internal sealed class OpCodeHandler_RegIb : OpCodeHandler
	{
		private readonly Code code;

		private readonly Register reg;

		public OpCodeHandler_RegIb(Code code, Register reg)
		{
			this.code = code;
			this.reg = reg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = reg;
			instruction.Op1Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_IbReg : OpCodeHandler
	{
		private readonly Code code;

		private readonly Register reg;

		public OpCodeHandler_IbReg(Code code, Register reg)
		{
			this.code = code;
			this.reg = reg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = reg;
			instruction.Op0Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_AL_DX : OpCodeHandler
	{
		private readonly Code code;

		public OpCodeHandler_AL_DX(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = Register.AL;
			instruction.Op1Register = Register.DX;
		}
	}
	internal sealed class OpCodeHandler_DX_AL : OpCodeHandler
	{
		private readonly Code code;

		public OpCodeHandler_DX_AL(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = Register.DX;
			instruction.Op1Register = Register.AL;
		}
	}
	internal sealed class OpCodeHandler_Ib : OpCodeHandler
	{
		private readonly Code code;

		public OpCodeHandler_Ib(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Ib3 : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_Ib3(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_MandatoryPrefix : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler[] handlers;

		public OpCodeHandler_MandatoryPrefix(OpCodeHandler handler, OpCodeHandler handler66, OpCodeHandler handlerF3, OpCodeHandler handlerF2)
		{
			handlers = new OpCodeHandler[4]
			{
				handler ?? throw new ArgumentNullException("handler"),
				handler66 ?? throw new ArgumentNullException("handler66"),
				handlerF3 ?? throw new ArgumentNullException("handlerF3"),
				handlerF2 ?? throw new ArgumentNullException("handlerF2")
			};
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.ClearMandatoryPrefix(ref instruction);
			handlers[(uint)decoder.state.zs.mandatoryPrefix].Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_MandatoryPrefix3 : OpCodeHandlerModRM
	{
		private readonly struct Info
		{
			public readonly OpCodeHandler handler;

			public readonly bool mandatoryPrefix;

			public Info(OpCodeHandler handler, bool mandatoryPrefix)
			{
				this.handler = handler;
				this.mandatoryPrefix = mandatoryPrefix;
			}
		}

		private readonly Info[] handlers_reg;

		private readonly Info[] handlers_mem;

		public OpCodeHandler_MandatoryPrefix3(OpCodeHandler handler_reg, OpCodeHandler handler_mem, OpCodeHandler handler66_reg, OpCodeHandler handler66_mem, OpCodeHandler handlerF3_reg, OpCodeHandler handlerF3_mem, OpCodeHandler handlerF2_reg, OpCodeHandler handlerF2_mem, LegacyHandlerFlags flags)
		{
			handlers_reg = new Info[4]
			{
				new Info(handler_reg ?? throw new ArgumentNullException("handler_reg"), (flags & LegacyHandlerFlags.HandlerReg) == 0),
				new Info(handler66_reg ?? throw new ArgumentNullException("handler66_reg"), (flags & LegacyHandlerFlags.Handler66Reg) == 0),
				new Info(handlerF3_reg ?? throw new ArgumentNullException("handlerF3_reg"), (flags & LegacyHandlerFlags.HandlerF3Reg) == 0),
				new Info(handlerF2_reg ?? throw new ArgumentNullException("handlerF2_reg"), (flags & LegacyHandlerFlags.HandlerF2Reg) == 0)
			};
			handlers_mem = new Info[4]
			{
				new Info(handler_mem ?? throw new ArgumentNullException("handler_mem"), (flags & LegacyHandlerFlags.HandlerMem) == 0),
				new Info(handler66_mem ?? throw new ArgumentNullException("handler66_mem"), (flags & LegacyHandlerFlags.Handler66Mem) == 0),
				new Info(handlerF3_mem ?? throw new ArgumentNullException("handlerF3_mem"), (flags & LegacyHandlerFlags.HandlerF3Mem) == 0),
				new Info(handlerF2_mem ?? throw new ArgumentNullException("handlerF2_mem"), (flags & LegacyHandlerFlags.HandlerF2Mem) == 0)
			};
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Info info = ((decoder.state.mod == 3) ? handlers_reg : handlers_mem)[(uint)decoder.state.zs.mandatoryPrefix];
			if (info.mandatoryPrefix)
			{
				decoder.ClearMandatoryPrefix(ref instruction);
			}
			info.handler.Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_MandatoryPrefix4 : OpCodeHandler
	{
		private readonly OpCodeHandler handlerNP;

		private readonly OpCodeHandler handler66;

		private readonly OpCodeHandler handlerF3;

		private readonly OpCodeHandler handlerF2;

		private readonly uint flags;

		public OpCodeHandler_MandatoryPrefix4(OpCodeHandler handlerNP, OpCodeHandler handler66, OpCodeHandler handlerF3, OpCodeHandler handlerF2, uint flags)
		{
			this.handlerNP = handlerNP ?? throw new ArgumentNullException("handlerNP");
			this.handler66 = handler66 ?? throw new ArgumentNullException("handler66");
			this.handlerF3 = handlerF3 ?? throw new ArgumentNullException("handlerF3");
			this.handlerF2 = handlerF2 ?? throw new ArgumentNullException("handlerF2");
			this.flags = flags;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			OpCodeHandler opCodeHandler;
			switch (decoder.state.zs.mandatoryPrefix)
			{
			case MandatoryPrefixByte.None:
				opCodeHandler = handlerNP;
				break;
			case MandatoryPrefixByte.P66:
				opCodeHandler = handler66;
				break;
			case MandatoryPrefixByte.PF3:
				if ((flags & 4) != 0)
				{
					decoder.ClearMandatoryPrefixF3(ref instruction);
				}
				opCodeHandler = handlerF3;
				break;
			case MandatoryPrefixByte.PF2:
				if ((flags & 8) != 0)
				{
					decoder.ClearMandatoryPrefixF2(ref instruction);
				}
				opCodeHandler = handlerF2;
				break;
			default:
				throw new InvalidOperationException();
			}
			if (opCodeHandler.HasModRM && (flags & 0x10) != 0)
			{
				decoder.ReadModRM();
			}
			opCodeHandler.Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_MandatoryPrefix_NoModRM : OpCodeHandler
	{
		private readonly OpCodeHandler[] handlers;

		public OpCodeHandler_MandatoryPrefix_NoModRM(OpCodeHandler handler, OpCodeHandler handler66, OpCodeHandler handlerF3, OpCodeHandler handlerF2)
		{
			handlers = new OpCodeHandler[4]
			{
				handler ?? throw new ArgumentNullException("handler"),
				handler66 ?? throw new ArgumentNullException("handler66"),
				handlerF3 ?? throw new ArgumentNullException("handlerF3"),
				handlerF2 ?? throw new ArgumentNullException("handlerF2")
			};
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.ClearMandatoryPrefix(ref instruction);
			handlers[(uint)decoder.state.zs.mandatoryPrefix].Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_NIb : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_NIb(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(decoder.state.rm + 225);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op1Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Reservednop : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler reservedNopHandler;

		private readonly OpCodeHandler otherHandler;

		public OpCodeHandler_Reservednop(OpCodeHandler reservedNopHandler, OpCodeHandler otherHandler)
		{
			this.reservedNopHandler = reservedNopHandler ?? throw new ArgumentNullException("reservedNopHandler");
			this.otherHandler = otherHandler ?? throw new ArgumentNullException("otherHandler");
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			(((decoder.options & DecoderOptions.ForceReservedNop) != DecoderOptions.None) ? reservedNopHandler : otherHandler).Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Ev_Iz : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		private readonly HandlerFlags flags;

		public OpCodeHandler_Ev_Iz(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public OpCodeHandler_Ev_Iz(Code code16, Code code32, Code code64, HandlerFlags flags)
		{
			codes = new Code3(code16, code32, code64);
			this.flags = flags;
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			if (decoder.state.mod < 3)
			{
				decoder.state.zs.flags |= (StateFlags)((uint)(flags & HandlerFlags.Lock) << 10);
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			else
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
			}
			if ((int)num == 1)
			{
				instruction.Op1Kind = OpKind.Immediate32;
				instruction.Immediate32 = decoder.ReadUInt32();
			}
			else if ((int)num == 2)
			{
				instruction.Op1Kind = OpKind.Immediate32to64;
				instruction.Immediate32 = decoder.ReadUInt32();
			}
			else
			{
				instruction.Op1Kind = OpKind.Immediate16;
				instruction.InternalImmediate16 = decoder.ReadUInt16();
			}
		}
	}
	internal sealed class OpCodeHandler_Ev_Ib : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		private readonly HandlerFlags flags;

		public OpCodeHandler_Ev_Ib(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public OpCodeHandler_Ev_Ib(Code code16, Code code32, Code code64, HandlerFlags flags)
		{
			codes = new Code3(code16, code32, code64);
			this.flags = flags;
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
			}
			else
			{
				decoder.state.zs.flags |= (StateFlags)((uint)(flags & HandlerFlags.Lock) << 10);
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			if ((int)num == 1)
			{
				instruction.Op1Kind = OpKind.Immediate8to32;
			}
			else if ((int)num == 2)
			{
				instruction.Op1Kind = OpKind.Immediate8to64;
			}
			else
			{
				instruction.Op1Kind = OpKind.Immediate8to16;
			}
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Ev_Ib2 : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		private readonly HandlerFlags flags;

		public OpCodeHandler_Ev_Ib2(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public OpCodeHandler_Ev_Ib2(Code code16, Code code32, Code code64, HandlerFlags flags)
		{
			codes = new Code3(code16, code32, code64);
			this.flags = flags;
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
			}
			else
			{
				decoder.state.zs.flags |= (StateFlags)((uint)(flags & HandlerFlags.Lock) << 10);
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op1Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Ev_1 : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Ev_1(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op1Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = 1u;
			decoder.state.zs.flags |= StateFlags.NoImm;
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Ev_CL : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Ev_CL(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op1Register = Register.CL;
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Ev : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		private readonly HandlerFlags flags;

		public OpCodeHandler_Ev(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public OpCodeHandler_Ev(Code code16, Code code32, Code code64, HandlerFlags flags)
		{
			codes = new Code3(code16, code32, code64);
			this.flags = flags;
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			decoder.state.zs.flags |= (StateFlags)((uint)(flags & HandlerFlags.Lock) << 10);
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Rv : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Rv(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
		}
	}
	internal sealed class OpCodeHandler_Rv_32_64 : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Rv_32_64(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (decoder.is64bMode)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
		}
	}
	internal sealed class OpCodeHandler_Rq : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_Rq(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 53);
		}
	}
	internal sealed class OpCodeHandler_Ev_REXW : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		private readonly uint flags;

		private readonly uint disallowReg;

		private readonly uint disallowMem;

		public OpCodeHandler_Ev_REXW(Code code32, Code code64, uint flags)
		{
			this.code32 = code32;
			this.code64 = code64;
			this.flags = flags;
			disallowReg = (((flags & 1) == 0) ? uint.MaxValue : 0u);
			disallowMem = (((flags & 2) == 0) ? uint.MaxValue : 0u);
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			if ((((flags & 4) | (uint)(decoder.state.zs.flags & StateFlags.Has66)) & decoder.invalidCheckMask) == 32772)
			{
				decoder.SetInvalidInstruction();
			}
			if (decoder.state.mod == 3)
			{
				if ((decoder.state.zs.flags & StateFlags.W) != 0)
				{
					instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 53);
				}
				else
				{
					instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 37);
				}
				if ((disallowReg & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				if ((disallowMem & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_Evj : OpCodeHandlerModRM
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Evj(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if ((decoder.options & DecoderOptions.AMD) == 0 || decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
				}
				if (decoder.state.mod < 3)
				{
					instruction.Op0Kind = OpKind.Memory;
					decoder.ReadOpMem(ref instruction);
				}
				else if ((decoder.options & DecoderOptions.AMD) == 0 || decoder.state.operandSize != OpSize.Size16)
				{
					instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 53);
				}
				else
				{
					instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 21);
				}
			}
			else
			{
				if (decoder.state.operandSize == OpSize.Size32)
				{
					instruction.InternalSetCodeNoCheck(code32);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
				}
				if (decoder.state.mod < 3)
				{
					instruction.Op0Kind = OpKind.Memory;
					decoder.ReadOpMem(ref instruction);
				}
				else if (decoder.state.operandSize == OpSize.Size32)
				{
					instruction.Op0Register = (Register)(decoder.state.rm + 37);
				}
				else
				{
					instruction.Op0Register = (Register)(decoder.state.rm + 21);
				}
			}
		}
	}
	internal sealed class OpCodeHandler_Ep : OpCodeHandlerModRM
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Ep(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.operandSize == OpSize.Size64 && (decoder.options & DecoderOptions.AMD) == 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
			}
			else if (decoder.state.operandSize == OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Evw : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Evw(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Ew : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Ew(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Ms : OpCodeHandlerModRM
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Ms(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				instruction.InternalSetCodeNoCheck(code64);
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_Ev : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gv_Ev(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod < 3)
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			else
			{
				instruction.Op1Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
			}
		}
	}
	internal sealed class OpCodeHandler_Gd_Rd : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_Gd_Rd(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 37);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_Gv_M_as : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gv_M_as(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.addressSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gdq_Ev : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gdq_Ev(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			if ((int)num != 2)
			{
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			else
			{
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_Ev3 : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gv_Ev3(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_Ev2 : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gv_Ev2(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				uint num2 = decoder.state.rm + decoder.state.zs.extraBaseRegisterBase;
				if (decoder.state.operandSize != OpSize.Size16)
				{
					instruction.Op1Register = (Register)(num2 + 37);
				}
				else
				{
					instruction.Op1Register = (Register)(num2 + 21);
				}
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_R_C : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		private readonly Register baseReg;

		public OpCodeHandler_R_C(Code code32, Code code64, Register baseReg)
		{
			this.code32 = code32;
			this.code64 = code64;
			this.baseReg = baseReg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 37);
			}
			uint num = decoder.state.zs.extraRegisterBase;
			if (baseReg == Register.CR0 && instruction.HasLockPrefix && (decoder.options & DecoderOptions.AMD) != DecoderOptions.None)
			{
				if ((num & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				num = 8u;
				instruction.InternalClearHasLockPrefix();
				decoder.state.zs.flags &= ~StateFlags.Lock;
			}
			int num2 = (int)(decoder.state.reg + num);
			if (decoder.invalidCheckMask != 0)
			{
				if (baseReg == Register.CR0)
				{
					if (num2 == 1 || (num2 != 8 && num2 >= 5))
					{
						decoder.SetInvalidInstruction();
					}
				}
				else if (baseReg == Register.DR0 && num2 > 7)
				{
					decoder.SetInvalidInstruction();
				}
			}
			instruction.Op1Register = num2 + baseReg;
		}
	}
	internal sealed class OpCodeHandler_C_R : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		private readonly Register baseReg;

		public OpCodeHandler_C_R(Code code32, Code code64, Register baseReg)
		{
			this.code32 = code32;
			this.code64 = code64;
			this.baseReg = baseReg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 37);
			}
			uint num = decoder.state.zs.extraRegisterBase;
			if (baseReg == Register.CR0 && instruction.HasLockPrefix && (decoder.options & DecoderOptions.AMD) != DecoderOptions.None)
			{
				if ((num & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				num = 8u;
				instruction.InternalClearHasLockPrefix();
				decoder.state.zs.flags &= ~StateFlags.Lock;
			}
			int num2 = (int)(decoder.state.reg + num);
			if (decoder.invalidCheckMask != 0)
			{
				if (baseReg == Register.CR0)
				{
					if (num2 == 1 || (num2 != 8 && num2 >= 5))
					{
						decoder.SetInvalidInstruction();
					}
				}
				else if (baseReg == Register.DR0 && num2 > 7)
				{
					decoder.SetInvalidInstruction();
				}
			}
			instruction.Op0Register = num2 + baseReg;
		}
	}
	internal sealed class OpCodeHandler_Jb : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Jb(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.state.zs.flags |= StateFlags.BranchImm8;
			if (decoder.is64bMode)
			{
				if ((decoder.options & DecoderOptions.AMD) == 0 || decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
					instruction.Op0Kind = OpKind.NearBranch64;
					instruction.NearBranch64 = (ulong)(sbyte)decoder.ReadByte() + decoder.GetCurrentInstructionPointer64();
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
					instruction.Op0Kind = OpKind.NearBranch16;
					instruction.InternalNearBranch16 = (ushort)((uint)(sbyte)decoder.ReadByte() + decoder.GetCurrentInstructionPointer32());
				}
			}
			else if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Kind = OpKind.NearBranch32;
				instruction.NearBranch32 = (uint)(sbyte)decoder.ReadByte() + decoder.GetCurrentInstructionPointer32();
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Kind = OpKind.NearBranch16;
				instruction.InternalNearBranch16 = (ushort)((uint)(sbyte)decoder.ReadByte() + decoder.GetCurrentInstructionPointer32());
			}
		}
	}
	internal sealed class OpCodeHandler_Jx : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Jx(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.state.zs.flags |= StateFlags.Xbegin;
			if (decoder.is64bMode)
			{
				if (decoder.state.operandSize == OpSize.Size32)
				{
					instruction.InternalSetCodeNoCheck(code32);
					instruction.Op0Kind = OpKind.NearBranch64;
					instruction.NearBranch64 = (ulong)(int)decoder.ReadUInt32() + decoder.GetCurrentInstructionPointer64();
				}
				else if (decoder.state.operandSize == OpSize.Size64)
				{
					instruction.InternalSetCodeNoCheck(code64);
					instruction.Op0Kind = OpKind.NearBranch64;
					instruction.NearBranch64 = (ulong)(int)decoder.ReadUInt32() + decoder.GetCurrentInstructionPointer64();
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
					instruction.Op0Kind = OpKind.NearBranch64;
					instruction.NearBranch64 = (ulong)(short)decoder.ReadUInt16() + decoder.GetCurrentInstructionPointer64();
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Kind = OpKind.NearBranch32;
				instruction.NearBranch32 = decoder.ReadUInt32() + decoder.GetCurrentInstructionPointer32();
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Kind = OpKind.NearBranch32;
				instruction.NearBranch32 = (uint)(short)decoder.ReadUInt16() + decoder.GetCurrentInstructionPointer32();
			}
		}
	}
	internal sealed class OpCodeHandler_Jz : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Jz(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if ((decoder.options & DecoderOptions.AMD) == 0 || decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
					instruction.Op0Kind = OpKind.NearBranch64;
					instruction.NearBranch64 = (ulong)(int)decoder.ReadUInt32() + decoder.GetCurrentInstructionPointer64();
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
					instruction.Op0Kind = OpKind.NearBranch16;
					instruction.InternalNearBranch16 = (ushort)(decoder.ReadUInt16() + decoder.GetCurrentInstructionPointer32());
				}
			}
			else if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Kind = OpKind.NearBranch32;
				instruction.NearBranch32 = decoder.ReadUInt32() + decoder.GetCurrentInstructionPointer32();
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Kind = OpKind.NearBranch16;
				instruction.InternalNearBranch16 = (ushort)(decoder.ReadUInt16() + decoder.GetCurrentInstructionPointer32());
			}
		}
	}
	internal sealed class OpCodeHandler_Jb2 : OpCodeHandler
	{
		private readonly Code code16_16;

		private readonly Code code16_32;

		private readonly Code code16_64;

		private readonly Code code32_16;

		private readonly Code code32_32;

		private readonly Code code64_32;

		private readonly Code code64_64;

		public OpCodeHandler_Jb2(Code code16_16, Code code16_32, Code code16_64, Code code32_16, Code code32_32, Code code64_32, Code code64_64)
		{
			this.code16_16 = code16_16;
			this.code16_32 = code16_32;
			this.code16_64 = code16_64;
			this.code32_16 = code32_16;
			this.code32_32 = code32_32;
			this.code64_32 = code64_32;
			this.code64_64 = code64_64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.state.zs.flags |= StateFlags.BranchImm8;
			if (decoder.is64bMode)
			{
				if ((decoder.options & DecoderOptions.AMD) == 0 || decoder.state.operandSize != OpSize.Size16)
				{
					if (decoder.state.addressSize == OpSize.Size64)
					{
						instruction.InternalSetCodeNoCheck(code64_64);
					}
					else
					{
						instruction.InternalSetCodeNoCheck(code64_32);
					}
					instruction.Op0Kind = OpKind.NearBranch64;
					instruction.NearBranch64 = (ulong)(sbyte)decoder.ReadByte() + decoder.GetCurrentInstructionPointer64();
				}
				else
				{
					if (decoder.state.addressSize == OpSize.Size64)
					{
						instruction.InternalSetCodeNoCheck(code16_64);
					}
					else
					{
						instruction.InternalSetCodeNoCheck(code16_32);
					}
					instruction.Op0Kind = OpKind.NearBranch16;
					instruction.InternalNearBranch16 = (ushort)((uint)(sbyte)decoder.ReadByte() + decoder.GetCurrentInstructionPointer32());
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				if (decoder.state.addressSize == OpSize.Size32)
				{
					instruction.InternalSetCodeNoCheck(code32_32);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code32_16);
				}
				instruction.Op0Kind = OpKind.NearBranch32;
				instruction.NearBranch32 = (uint)(sbyte)decoder.ReadByte() + decoder.GetCurrentInstructionPointer32();
			}
			else
			{
				if (decoder.state.addressSize == OpSize.Size32)
				{
					instruction.InternalSetCodeNoCheck(code16_32);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16_16);
				}
				instruction.Op0Kind = OpKind.NearBranch16;
				instruction.InternalNearBranch16 = (ushort)((uint)(sbyte)decoder.ReadByte() + decoder.GetCurrentInstructionPointer32());
			}
		}
	}
	internal sealed class OpCodeHandler_Jdisp : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_Jdisp(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Kind = OpKind.NearBranch32;
				instruction.NearBranch32 = decoder.ReadUInt32();
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Kind = OpKind.NearBranch16;
				instruction.InternalNearBranch16 = decoder.ReadUInt16();
			}
		}
	}
	internal sealed class OpCodeHandler_PushOpSizeReg : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		private readonly Register reg;

		public OpCodeHandler_PushOpSizeReg(Code code16, Code code32, Code code64, Register reg)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
			this.reg = reg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if (decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
			instruction.Op0Register = reg;
		}
	}
	internal sealed class OpCodeHandler_PushEv : OpCodeHandlerModRM
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_PushEv(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if (decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
			if (decoder.state.mod == 3)
			{
				uint num = decoder.state.rm + decoder.state.zs.extraBaseRegisterBase;
				if (decoder.is64bMode)
				{
					if (decoder.state.operandSize != OpSize.Size16)
					{
						instruction.Op0Register = (Register)(num + 53);
					}
					else
					{
						instruction.Op0Register = (Register)(num + 21);
					}
				}
				else if (decoder.state.operandSize == OpSize.Size32)
				{
					instruction.Op0Register = (Register)(num + 37);
				}
				else
				{
					instruction.Op0Register = (Register)(num + 21);
				}
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_Ev_Gv : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		private readonly HandlerFlags flags;

		public OpCodeHandler_Ev_Gv(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public OpCodeHandler_Ev_Gv(Code code16, Code code32, Code code64, HandlerFlags flags)
		{
			codes = new Code3(code16, code32, code64);
			this.flags = flags;
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op1Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			decoder.state.zs.flags |= (StateFlags)((uint)(flags & HandlerFlags.Lock) << 10);
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Ev_Gv_32_64 : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Ev_Gv_32_64(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (decoder.is64bMode)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Ev_Gv_Ib : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Ev_Gv_Ib(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op1Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Ev_Gv_CL : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Ev_Gv_CL(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op2Register = Register.CL;
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op1Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_Mp : OpCodeHandlerModRM
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Gv_Mp(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.operandSize == OpSize.Size64 && (decoder.options & DecoderOptions.AMD) == 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else if (decoder.state.operandSize == OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 21);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_Eb : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gv_Eb(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				uint num2 = decoder.state.rm + decoder.state.zs.extraBaseRegisterBase;
				if ((decoder.state.zs.flags & StateFlags.HasRex) != 0 && num2 >= 4)
				{
					num2 += 4;
				}
				instruction.Op1Register = (Register)(num2 + 1);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_Gv_Ew : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gv_Ew(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 21);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_PushSimple2 : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_PushSimple2(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if (decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
		}
	}
	internal sealed class OpCodeHandler_Simple2 : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Simple2(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
		}
	}
	internal sealed class OpCodeHandler_Simple2Iw : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Simple2Iw(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Kind = OpKind.Immediate16;
			instruction.InternalImmediate16 = decoder.ReadUInt16();
		}
	}
	internal sealed class OpCodeHandler_Simple3 : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Simple3(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if (decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
		}
	}
	internal sealed class OpCodeHandler_Simple5 : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Simple5(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.addressSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
		}
	}
	internal sealed class OpCodeHandler_Simple5_a32 : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Simple5_a32(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.addressSize != OpSize.Size32 && decoder.invalidCheckMask != 0)
			{
				decoder.SetInvalidInstruction();
			}
			nuint num = (nuint)decoder.state.addressSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
		}
	}
	internal sealed class OpCodeHandler_Simple5_ModRM_as : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Simple5_ModRM_as(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.addressSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
		}
	}
	internal sealed class OpCodeHandler_Simple4 : OpCodeHandler
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Simple4(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
		}
	}
	internal sealed class OpCodeHandler_PushSimpleReg : OpCodeHandler
	{
		private readonly int index;

		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_PushSimpleReg(int index, Code code16, Code code32, Code code64)
		{
			this.index = index;
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if (decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
					instruction.Op0Register = (Register)(index + (int)decoder.state.zs.extraBaseRegisterBase + 53);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
					instruction.Op0Register = (Register)(index + (int)decoder.state.zs.extraBaseRegisterBase + 21);
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = (Register)(index + (int)decoder.state.zs.extraBaseRegisterBase + 37);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Register = (Register)(index + (int)decoder.state.zs.extraBaseRegisterBase + 21);
			}
		}
	}
	internal sealed class OpCodeHandler_SimpleReg : OpCodeHandler
	{
		private readonly Code code;

		private readonly int index;

		public OpCodeHandler_SimpleReg(Code code, int index)
		{
			this.code = code;
			this.index = index;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			int operandSize = (int)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck(operandSize + code);
			instruction.Op0Register = (Register)(operandSize * 16 + index + (int)decoder.state.zs.extraBaseRegisterBase + 21);
		}
	}
	internal sealed class OpCodeHandler_Xchg_Reg_rAX : OpCodeHandler
	{
		private readonly int index;

		private readonly Code[] codes;

		private static readonly Code[] s_codes = new Code[48]
		{
			Code.Nopw,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Xchg_r16_AX,
			Code.Nopd,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Xchg_r32_EAX,
			Code.Nopq,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX,
			Code.Xchg_r64_RAX
		};

		public OpCodeHandler_Xchg_Reg_rAX(int index)
		{
			this.index = index;
			codes = s_codes;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (index == 0 && decoder.state.zs.mandatoryPrefix == MandatoryPrefixByte.PF3 && (decoder.options & DecoderOptions.NoPause) == 0)
			{
				decoder.ClearMandatoryPrefixF3(ref instruction);
				instruction.InternalSetCodeNoCheck(Code.Pause);
				return;
			}
			int operandSize = (int)decoder.state.operandSize;
			int num = index + (int)decoder.state.zs.extraBaseRegisterBase;
			instruction.InternalSetCodeNoCheck(codes[operandSize * 16 + num]);
			if (num != 0)
			{
				Register op0Register = (Register)(operandSize * 16 + num + 21);
				instruction.Op0Register = op0Register;
				instruction.Op1Register = (Register)(operandSize * 16 + 21);
			}
		}
	}
	internal sealed class OpCodeHandler_Reg_Iz : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Reg_Iz(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = Register.EAX;
				instruction.Op1Kind = OpKind.Immediate32;
				instruction.Immediate32 = decoder.ReadUInt32();
			}
			else if (decoder.state.operandSize == OpSize.Size64)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op0Register = Register.RAX;
				instruction.Op1Kind = OpKind.Immediate32to64;
				instruction.Immediate32 = decoder.ReadUInt32();
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Register = Register.AX;
				instruction.Op1Kind = OpKind.Immediate16;
				instruction.InternalImmediate16 = decoder.ReadUInt16();
			}
		}
	}
	internal sealed class OpCodeHandler_RegIb3 : OpCodeHandler
	{
		private readonly int index;

		private readonly Register[] withRexPrefix;

		private static readonly Register[] s_withRexPrefix = new Register[16]
		{
			Register.AL,
			Register.CL,
			Register.DL,
			Register.BL,
			Register.SPL,
			Register.BPL,
			Register.SIL,
			Register.DIL,
			Register.R8L,
			Register.R9L,
			Register.R10L,
			Register.R11L,
			Register.R12L,
			Register.R13L,
			Register.R14L,
			Register.R15L
		};

		public OpCodeHandler_RegIb3(int index)
		{
			this.index = index;
			withRexPrefix = s_withRexPrefix;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register op0Register = (((decoder.state.zs.flags & StateFlags.HasRex) == 0) ? ((Register)(index + 1)) : withRexPrefix[index + (int)decoder.state.zs.extraBaseRegisterBase]);
			instruction.InternalSetCodeNoCheck(Code.Mov_r8_imm8);
			instruction.Op0Register = op0Register;
			instruction.Op1Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_RegIz2 : OpCodeHandler
	{
		private readonly int index;

		public OpCodeHandler_RegIz2(int index)
		{
			this.index = index;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(Code.Mov_r32_imm32);
				instruction.Op0Register = (Register)(index + (int)decoder.state.zs.extraBaseRegisterBase + 37);
				instruction.Op1Kind = OpKind.Immediate32;
				instruction.Immediate32 = decoder.ReadUInt32();
			}
			else if (decoder.state.operandSize == OpSize.Size64)
			{
				instruction.InternalSetCodeNoCheck(Code.Mov_r64_imm64);
				instruction.Op0Register = (Register)(index + (int)decoder.state.zs.extraBaseRegisterBase + 53);
				instruction.Op1Kind = OpKind.Immediate64;
				instruction.InternalImmediate64_lo = decoder.ReadUInt32();
				instruction.InternalImmediate64_hi = decoder.ReadUInt32();
			}
			else
			{
				instruction.InternalSetCodeNoCheck(Code.Mov_r16_imm16);
				instruction.Op0Register = (Register)(index + (int)decoder.state.zs.extraBaseRegisterBase + 21);
				instruction.Op1Kind = OpKind.Immediate16;
				instruction.InternalImmediate16 = decoder.ReadUInt16();
			}
		}
	}
	internal sealed class OpCodeHandler_PushIb2 : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_PushIb2(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if (decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
					instruction.Op0Kind = OpKind.Immediate8to64;
					instruction.InternalImmediate8 = decoder.ReadByte();
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
					instruction.Op0Kind = OpKind.Immediate8to16;
					instruction.InternalImmediate8 = decoder.ReadByte();
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Kind = OpKind.Immediate8to32;
				instruction.InternalImmediate8 = decoder.ReadByte();
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Kind = OpKind.Immediate8to16;
				instruction.InternalImmediate8 = decoder.ReadByte();
			}
		}
	}
	internal sealed class OpCodeHandler_PushIz : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_PushIz(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if (decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
					instruction.Op0Kind = OpKind.Immediate32to64;
					instruction.Immediate32 = decoder.ReadUInt32();
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
					instruction.Op0Kind = OpKind.Immediate16;
					instruction.InternalImmediate16 = decoder.ReadUInt16();
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Kind = OpKind.Immediate32;
				instruction.Immediate32 = decoder.ReadUInt32();
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Kind = OpKind.Immediate16;
				instruction.InternalImmediate16 = decoder.ReadUInt16();
			}
		}
	}
	internal sealed class OpCodeHandler_Gv_Ma : OpCodeHandlerModRM
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_Gv_Ma(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 21);
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_RvMw_Gw : OpCodeHandlerModRM
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_RvMw_Gw(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
				register = Register.EAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 21);
				register = Register.AX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_Ev_Ib : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gv_Ev_Ib(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			if ((int)num == 1)
			{
				instruction.Op2Kind = OpKind.Immediate8to32;
				instruction.InternalImmediate8 = decoder.ReadByte();
			}
			else if ((int)num == 2)
			{
				instruction.Op2Kind = OpKind.Immediate8to64;
				instruction.InternalImmediate8 = decoder.ReadByte();
			}
			else
			{
				instruction.Op2Kind = OpKind.Immediate8to16;
				instruction.InternalImmediate8 = decoder.ReadByte();
			}
		}
	}
	internal sealed class OpCodeHandler_Gv_Ev_Ib_REX : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Gv_Ev_Ib_REX(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Gv_Ev_32_64 : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		private readonly uint disallowReg;

		private readonly uint disallowMem;

		public OpCodeHandler_Gv_Ev_32_64(Code code32, Code code64, bool allowReg, bool allowMem)
		{
			this.code32 = code32;
			this.code64 = code64;
			disallowMem = ((!allowMem) ? uint.MaxValue : 0u);
			disallowReg = ((!allowReg) ? uint.MaxValue : 0u);
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (decoder.is64bMode)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				if ((disallowReg & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
				return;
			}
			if ((disallowMem & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_Ev_Iz : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gv_Ev_Iz(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			if ((int)num == 1)
			{
				instruction.Op2Kind = OpKind.Immediate32;
				instruction.Immediate32 = decoder.ReadUInt32();
			}
			else if ((int)num == 2)
			{
				instruction.Op2Kind = OpKind.Immediate32to64;
				instruction.Immediate32 = decoder.ReadUInt32();
			}
			else
			{
				instruction.Op2Kind = OpKind.Immediate16;
				instruction.InternalImmediate16 = decoder.ReadUInt16();
			}
		}
	}
	internal sealed class OpCodeHandler_Yb_Reg : OpCodeHandler
	{
		private readonly Code code;

		private readonly Register reg;

		public OpCodeHandler_Yb_Reg(Code code, Register reg)
		{
			this.code = code;
			this.reg = reg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = reg;
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op0Kind = OpKind.MemoryESRDI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op0Kind = OpKind.MemoryESEDI;
			}
			else
			{
				instruction.Op0Kind = OpKind.MemoryESDI;
			}
		}
	}
	internal sealed class OpCodeHandler_Yv_Reg : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Yv_Reg(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op1Register = (Register)(((int)num << 4) + 21);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op0Kind = OpKind.MemoryESRDI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op0Kind = OpKind.MemoryESEDI;
			}
			else
			{
				instruction.Op0Kind = OpKind.MemoryESDI;
			}
		}
	}
	internal sealed class OpCodeHandler_Yv_Reg2 : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_Yv_Reg2(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op1Register = Register.DX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op1Register = Register.DX;
			}
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op0Kind = OpKind.MemoryESRDI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op0Kind = OpKind.MemoryESEDI;
			}
			else
			{
				instruction.Op0Kind = OpKind.MemoryESDI;
			}
		}
	}
	internal sealed class OpCodeHandler_Reg_Xb : OpCodeHandler
	{
		private readonly Code code;

		private readonly Register reg;

		public OpCodeHandler_Reg_Xb(Code code, Register reg)
		{
			this.code = code;
			this.reg = reg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = reg;
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op1Kind = OpKind.MemorySegRSI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op1Kind = OpKind.MemorySegESI;
			}
			else
			{
				instruction.Op1Kind = OpKind.MemorySegSI;
			}
		}
	}
	internal sealed class OpCodeHandler_Reg_Xv : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Reg_Xv(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + 21);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op1Kind = OpKind.MemorySegRSI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op1Kind = OpKind.MemorySegESI;
			}
			else
			{
				instruction.Op1Kind = OpKind.MemorySegSI;
			}
		}
	}
	internal sealed class OpCodeHandler_Reg_Xv2 : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_Reg_Xv2(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = Register.DX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Register = Register.DX;
			}
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op1Kind = OpKind.MemorySegRSI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op1Kind = OpKind.MemorySegESI;
			}
			else
			{
				instruction.Op1Kind = OpKind.MemorySegSI;
			}
		}
	}
	internal sealed class OpCodeHandler_Reg_Yb : OpCodeHandler
	{
		private readonly Code code;

		private readonly Register reg;

		public OpCodeHandler_Reg_Yb(Code code, Register reg)
		{
			this.code = code;
			this.reg = reg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = reg;
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op1Kind = OpKind.MemoryESRDI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op1Kind = OpKind.MemoryESEDI;
			}
			else
			{
				instruction.Op1Kind = OpKind.MemoryESDI;
			}
		}
	}
	internal sealed class OpCodeHandler_Reg_Yv : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Reg_Yv(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + 21);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op1Kind = OpKind.MemoryESRDI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op1Kind = OpKind.MemoryESEDI;
			}
			else
			{
				instruction.Op1Kind = OpKind.MemoryESDI;
			}
		}
	}
	internal sealed class OpCodeHandler_Yb_Xb : OpCodeHandler
	{
		private readonly Code code;

		public OpCodeHandler_Yb_Xb(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op0Kind = OpKind.MemoryESRDI;
				instruction.Op1Kind = OpKind.MemorySegRSI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op0Kind = OpKind.MemoryESEDI;
				instruction.Op1Kind = OpKind.MemorySegESI;
			}
			else
			{
				instruction.Op0Kind = OpKind.MemoryESDI;
				instruction.Op1Kind = OpKind.MemorySegSI;
			}
		}
	}
	internal sealed class OpCodeHandler_Yv_Xv : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Yv_Xv(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op0Kind = OpKind.MemoryESRDI;
				instruction.Op1Kind = OpKind.MemorySegRSI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op0Kind = OpKind.MemoryESEDI;
				instruction.Op1Kind = OpKind.MemorySegESI;
			}
			else
			{
				instruction.Op0Kind = OpKind.MemoryESDI;
				instruction.Op1Kind = OpKind.MemorySegSI;
			}
		}
	}
	internal sealed class OpCodeHandler_Xb_Yb : OpCodeHandler
	{
		private readonly Code code;

		public OpCodeHandler_Xb_Yb(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op0Kind = OpKind.MemorySegRSI;
				instruction.Op1Kind = OpKind.MemoryESRDI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op0Kind = OpKind.MemorySegESI;
				instruction.Op1Kind = OpKind.MemoryESEDI;
			}
			else
			{
				instruction.Op0Kind = OpKind.MemorySegSI;
				instruction.Op1Kind = OpKind.MemoryESDI;
			}
		}
	}
	internal sealed class OpCodeHandler_Xv_Yv : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Xv_Yv(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op0Kind = OpKind.MemorySegRSI;
				instruction.Op1Kind = OpKind.MemoryESRDI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op0Kind = OpKind.MemorySegESI;
				instruction.Op1Kind = OpKind.MemoryESEDI;
			}
			else
			{
				instruction.Op0Kind = OpKind.MemorySegSI;
				instruction.Op1Kind = OpKind.MemoryESDI;
			}
		}
	}
	internal sealed class OpCodeHandler_Ev_Sw : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Ev_Sw(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op1Register = decoder.ReadOpSegReg();
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_M_Sw : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_M_Sw(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = decoder.ReadOpSegReg();
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_M : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gv_M(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod < 3)
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_Sw_Ev : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Sw_Ev(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			Register register = decoder.ReadOpSegReg();
			if (decoder.invalidCheckMask != 0 && register == Register.CS)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op0Register = register;
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(((int)num << 4) + (int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + 21);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Sw_M : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_Sw_M(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = decoder.ReadOpSegReg();
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Ap : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_Ap(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.Op0Kind = OpKind.FarBranch32;
				instruction.FarBranch32 = decoder.ReadUInt32();
			}
			else
			{
				instruction.Op0Kind = OpKind.FarBranch16;
				instruction.InternalFarBranch16 = decoder.ReadUInt16();
			}
			instruction.InternalFarBranchSelector = decoder.ReadUInt16();
		}
	}
	internal sealed class OpCodeHandler_Reg_Ob : OpCodeHandler
	{
		private readonly Code code;

		private readonly Register reg;

		public OpCodeHandler_Reg_Ob(Code code, Register reg)
		{
			this.code = code;
			this.reg = reg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = reg;
			decoder.displIndex = decoder.state.zs.instructionLength;
			instruction.Op1Kind = OpKind.Memory;
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.InternalSetMemoryDisplSize(4u);
				decoder.state.zs.flags |= StateFlags.Addr64;
				instruction.MemoryDisplacement64 = decoder.ReadUInt64();
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.InternalSetMemoryDisplSize(3u);
				instruction.MemoryDisplacement64 = decoder.ReadUInt32();
			}
			else
			{
				instruction.InternalSetMemoryDisplSize(2u);
				instruction.MemoryDisplacement64 = decoder.ReadUInt16();
			}
		}
	}
	internal sealed class OpCodeHandler_Ob_Reg : OpCodeHandler
	{
		private readonly Code code;

		private readonly Register reg;

		public OpCodeHandler_Ob_Reg(Code code, Register reg)
		{
			this.code = code;
			this.reg = reg;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			decoder.displIndex = decoder.state.zs.instructionLength;
			instruction.Op0Kind = OpKind.Memory;
			instruction.Op1Register = reg;
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.InternalSetMemoryDisplSize(4u);
				decoder.state.zs.flags |= StateFlags.Addr64;
				instruction.MemoryDisplacement64 = decoder.ReadUInt64();
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.InternalSetMemoryDisplSize(3u);
				instruction.MemoryDisplacement64 = decoder.ReadUInt32();
			}
			else
			{
				instruction.InternalSetMemoryDisplSize(2u);
				instruction.MemoryDisplacement64 = decoder.ReadUInt16();
			}
		}
	}
	internal sealed class OpCodeHandler_Reg_Ov : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Reg_Ov(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.displIndex = decoder.state.zs.instructionLength;
			instruction.Op1Kind = OpKind.Memory;
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + 21);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.InternalSetMemoryDisplSize(4u);
				decoder.state.zs.flags |= StateFlags.Addr64;
				instruction.MemoryDisplacement64 = decoder.ReadUInt64();
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.InternalSetMemoryDisplSize(3u);
				instruction.MemoryDisplacement64 = decoder.ReadUInt32();
			}
			else
			{
				instruction.InternalSetMemoryDisplSize(2u);
				instruction.MemoryDisplacement64 = decoder.ReadUInt16();
			}
		}
	}
	internal sealed class OpCodeHandler_Ov_Reg : OpCodeHandler
	{
		private readonly Code3 codes;

		public OpCodeHandler_Ov_Reg(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.displIndex = decoder.state.zs.instructionLength;
			instruction.Op0Kind = OpKind.Memory;
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op1Register = (Register)(((int)num << 4) + 21);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.InternalSetMemoryDisplSize(4u);
				decoder.state.zs.flags |= StateFlags.Addr64;
				instruction.MemoryDisplacement64 = decoder.ReadUInt64();
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.InternalSetMemoryDisplSize(3u);
				instruction.MemoryDisplacement64 = decoder.ReadUInt32();
			}
			else
			{
				instruction.InternalSetMemoryDisplSize(2u);
				instruction.MemoryDisplacement64 = decoder.ReadUInt16();
			}
		}
	}
	internal sealed class OpCodeHandler_BranchIw : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_BranchIw(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if ((decoder.options & DecoderOptions.AMD) == 0 || decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
			instruction.Op0Kind = OpKind.Immediate16;
			instruction.InternalImmediate16 = decoder.ReadUInt16();
		}
	}
	internal sealed class OpCodeHandler_BranchSimple : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_BranchSimple(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.is64bMode)
			{
				if ((decoder.options & DecoderOptions.AMD) == 0 || decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
		}
	}
	internal sealed class OpCodeHandler_Iw_Ib : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Iw_Ib(Code code16, Code code32, Code code64)
		{
			this.code16 = code16;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op0Kind = OpKind.Immediate16;
			instruction.InternalImmediate16 = decoder.ReadUInt16();
			instruction.Op1Kind = OpKind.Immediate8_2nd;
			instruction.InternalImmediate8_2nd = decoder.ReadByte();
			if (decoder.is64bMode)
			{
				if (decoder.state.operandSize != OpSize.Size16)
				{
					instruction.InternalSetCodeNoCheck(code64);
				}
				else
				{
					instruction.InternalSetCodeNoCheck(code16);
				}
			}
			else if (decoder.state.operandSize == OpSize.Size32)
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
			}
		}
	}
	internal sealed class OpCodeHandler_Reg_Ib2 : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_Reg_Ib2(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op1Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = Register.EAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Register = Register.AX;
			}
		}
	}
	internal sealed class OpCodeHandler_IbReg2 : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_IbReg2(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op0Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op1Register = Register.EAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op1Register = Register.AX;
			}
		}
	}
	internal sealed class OpCodeHandler_eAX_DX : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_eAX_DX(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op1Register = Register.DX;
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = Register.EAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op0Register = Register.AX;
			}
		}
	}
	internal sealed class OpCodeHandler_DX_eAX : OpCodeHandler
	{
		private readonly Code code16;

		private readonly Code code32;

		public OpCodeHandler_DX_eAX(Code code16, Code code32)
		{
			this.code16 = code16;
			this.code32 = code32;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op0Register = Register.DX;
			if (decoder.state.operandSize != OpSize.Size16)
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op1Register = Register.EAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code16);
				instruction.Op1Register = Register.AX;
			}
		}
	}
	internal sealed class OpCodeHandler_Eb_Ib : OpCodeHandlerModRM
	{
		private readonly Code code;

		private readonly HandlerFlags flags;

		public OpCodeHandler_Eb_Ib(Code code)
		{
			this.code = code;
		}

		public OpCodeHandler_Eb_Ib(Code code, HandlerFlags flags)
		{
			this.code = code;
			this.flags = flags;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.mod < 3)
			{
				decoder.state.zs.flags |= (StateFlags)((uint)(flags & HandlerFlags.Lock) << 10);
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			else
			{
				uint num = decoder.state.rm + decoder.state.zs.extraBaseRegisterBase;
				if ((decoder.state.zs.flags & StateFlags.HasRex) != 0 && num >= 4)
				{
					num += 4;
				}
				instruction.Op0Register = (Register)(num + 1);
			}
			instruction.Op1Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Eb_1 : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_Eb_1(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = 1u;
			decoder.state.zs.flags |= StateFlags.NoImm;
			if (decoder.state.mod == 3)
			{
				uint num = decoder.state.rm + decoder.state.zs.extraBaseRegisterBase;
				if ((decoder.state.zs.flags & StateFlags.HasRex) != 0 && num >= 4)
				{
					num += 4;
				}
				instruction.Op0Register = (Register)(num + 1);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_Eb_CL : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_Eb_CL(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = Register.CL;
			if (decoder.state.mod == 3)
			{
				uint num = decoder.state.rm + decoder.state.zs.extraBaseRegisterBase;
				if ((decoder.state.zs.flags & StateFlags.HasRex) != 0 && num >= 4)
				{
					num += 4;
				}
				instruction.Op0Register = (Register)(num + 1);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_Eb : OpCodeHandlerModRM
	{
		private readonly Code code;

		private readonly HandlerFlags flags;

		public OpCodeHandler_Eb(Code code)
		{
			this.code = code;
		}

		public OpCodeHandler_Eb(Code code, HandlerFlags flags)
		{
			this.code = code;
			this.flags = flags;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.mod == 3)
			{
				uint num = decoder.state.rm + decoder.state.zs.extraBaseRegisterBase;
				if ((decoder.state.zs.flags & StateFlags.HasRex) != 0 && num >= 4)
				{
					num += 4;
				}
				instruction.Op0Register = (Register)(num + 1);
			}
			else
			{
				decoder.state.zs.flags |= (StateFlags)((uint)(flags & HandlerFlags.Lock) << 10);
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_Eb_Gb : OpCodeHandlerModRM
	{
		private readonly Code code;

		private readonly HandlerFlags flags;

		public OpCodeHandler_Eb_Gb(Code code)
		{
			this.code = code;
		}

		public OpCodeHandler_Eb_Gb(Code code, HandlerFlags flags)
		{
			this.code = code;
			this.flags = flags;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			uint num = decoder.state.reg + decoder.state.zs.extraRegisterBase;
			if ((decoder.state.zs.flags & StateFlags.HasRex) != 0 && num >= 4)
			{
				num += 4;
			}
			instruction.Op1Register = (Register)(num + 1);
			if (decoder.state.mod == 3)
			{
				num = decoder.state.rm + decoder.state.zs.extraBaseRegisterBase;
				if ((decoder.state.zs.flags & StateFlags.HasRex) != 0 && num >= 4)
				{
					num += 4;
				}
				instruction.Op0Register = (Register)(num + 1);
			}
			else
			{
				decoder.state.zs.flags |= (StateFlags)((uint)(flags & HandlerFlags.Lock) << 10);
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_Gb_Eb : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_Gb_Eb(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			uint num = decoder.state.reg + decoder.state.zs.extraRegisterBase;
			if ((decoder.state.zs.flags & StateFlags.HasRex) != 0 && num >= 4)
			{
				num += 4;
			}
			instruction.Op0Register = (Register)(num + 1);
			if (decoder.state.mod == 3)
			{
				num = decoder.state.rm + decoder.state.zs.extraBaseRegisterBase;
				if ((decoder.state.zs.flags & StateFlags.HasRex) != 0 && num >= 4)
				{
					num += 4;
				}
				instruction.Op1Register = (Register)(num + 1);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_M : OpCodeHandlerModRM
	{
		private readonly Code codeW0;

		private readonly Code codeW1;

		public OpCodeHandler_M(Code codeW0, Code codeW1)
		{
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
		}

		public OpCodeHandler_M(Code codeW0)
		{
			this.codeW0 = codeW0;
			codeW1 = codeW0;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(codeW1);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW0);
			}
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_M_REXW : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		private readonly HandlerFlags flags32;

		private readonly HandlerFlags flags64;

		public OpCodeHandler_M_REXW(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public OpCodeHandler_M_REXW(Code code32, Code code64, HandlerFlags flags32, HandlerFlags flags64)
		{
			this.code32 = code32;
			this.code64 = code64;
			this.flags32 = flags32;
			this.flags64 = flags64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			HandlerFlags handlerFlags = (((decoder.state.zs.flags & StateFlags.W) != 0) ? flags64 : flags32);
			if ((handlerFlags & (HandlerFlags.Xacquire | HandlerFlags.Xrelease)) != HandlerFlags.None)
			{
				decoder.SetXacquireXrelease(ref instruction);
			}
			decoder.state.zs.flags |= (StateFlags)((uint)(handlerFlags & HandlerFlags.Lock) << 10);
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_MemBx : OpCodeHandler
	{
		private readonly Code code;

		public OpCodeHandler_MemBx(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.InternalMemoryIndex = Register.AL;
			instruction.Op0Kind = OpKind.Memory;
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.InternalMemoryBase = Register.RBX;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.InternalMemoryBase = Register.EBX;
			}
			else
			{
				instruction.InternalMemoryBase = Register.BX;
			}
		}
	}
	internal sealed class OpCodeHandler_VW : OpCodeHandlerModRM
	{
		private readonly Code codeR;

		private readonly Code codeM;

		public OpCodeHandler_VW(Code codeR, Code codeM)
		{
			this.codeR = codeR;
			this.codeM = codeM;
		}

		public OpCodeHandler_VW(Code code)
		{
			codeR = code;
			codeM = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				instruction.InternalSetCodeNoCheck(codeR);
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeM);
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_WV : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_WV(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod < 3)
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			else
			{
				instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
			}
		}
	}
	internal sealed class OpCodeHandler_rDI_VX_RX : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_rDI_VX_RX(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op0Kind = OpKind.MemorySegRDI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op0Kind = OpKind.MemorySegEDI;
			}
			else
			{
				instruction.Op0Kind = OpKind.MemorySegDI;
			}
			instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_rDI_P_N : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_rDI_P_N(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op0Kind = OpKind.MemorySegRDI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op0Kind = OpKind.MemorySegEDI;
			}
			else
			{
				instruction.Op0Kind = OpKind.MemorySegDI;
			}
			instruction.Op1Register = (Register)(decoder.state.reg + 225);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)(decoder.state.rm + 225);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VM : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VM(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_MV : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_MV(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VQ : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VQ(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 225);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_P_Q : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_P_Q(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 225);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 225);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Q_P : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_Q_P(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)(decoder.state.reg + 225);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(decoder.state.rm + 225);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_MP : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_MP(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)(decoder.state.reg + 225);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_P_Q_Ib : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_P_Q_Ib(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 225);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 225);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_P_W : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_P_W(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 225);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_P_R : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_P_R(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 225);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_P_Ev : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_P_Ev(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)(decoder.state.reg + 225);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_P_Ev_Ib : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_P_Ev_Ib(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)(decoder.state.reg + 225);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Ev_P : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Ev_P(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op1Register = (Register)(decoder.state.reg + 225);
			Register register;
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_W : OpCodeHandlerModRM
	{
		private readonly Code codeW0;

		private readonly Code codeW1;

		public OpCodeHandler_Gv_W(Code codeW0, Code codeW1)
		{
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(codeW1);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW0);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_V_Ev : OpCodeHandlerModRM
	{
		private readonly Code codeW0;

		private readonly Code codeW1;

		public OpCodeHandler_V_Ev(Code codeW0, Code codeW1)
		{
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (decoder.state.operandSize != OpSize.Size64)
			{
				instruction.InternalSetCodeNoCheck(codeW0);
				register = Register.EAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW1);
				register = Register.RAX;
			}
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VWIb : OpCodeHandlerModRM
	{
		private readonly Code codeW0;

		private readonly Code codeW1;

		public OpCodeHandler_VWIb(Code code)
		{
			codeW0 = code;
			codeW1 = code;
		}

		public OpCodeHandler_VWIb(Code codeW0, Code codeW1)
		{
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(codeW1);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW0);
			}
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VRIbIb : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VRIbIb(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
			instruction.Op3Kind = OpKind.Immediate8_2nd;
			instruction.InternalImmediate8_2nd = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_RIbIb : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_RIbIb(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op1Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
			instruction.Op2Kind = OpKind.Immediate8_2nd;
			instruction.InternalImmediate8_2nd = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_RIb : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_RIb(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op1Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Ed_V_Ib : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Ed_V_Ib(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			Register register;
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VX_Ev : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VX_Ev(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Ev_VX : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Ev_VX(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			Register register;
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VX_E_Ib : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VX_E_Ib(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Gv_RX : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Gv_RX(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 77);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_B_MIB : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_B_MIB(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.reg > 3 || (decoder.state.zs.extraRegisterBase & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 181);
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem_MPX(ref instruction);
			if (decoder.invalidCheckMask != 0 && instruction.MemoryBase == Register.RIP)
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_MIB_B : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_MIB_B(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.reg > 3 || (decoder.state.zs.extraRegisterBase & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)(decoder.state.reg + 181);
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem_MPX(ref instruction);
			if (decoder.invalidCheckMask != 0 && instruction.MemoryBase == Register.RIP)
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_B_BM : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_B_BM(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.reg > 3 || (decoder.state.zs.extraRegisterBase & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (decoder.is64bMode)
			{
				instruction.InternalSetCodeNoCheck(code64);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			instruction.Op0Register = (Register)(decoder.state.reg + 181);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 181);
				if (decoder.state.rm > 3 || (decoder.state.zs.extraBaseRegisterBase & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem_MPX(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_BM_B : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_BM_B(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.reg > 3 || (decoder.state.zs.extraRegisterBase & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (decoder.is64bMode)
			{
				instruction.InternalSetCodeNoCheck(code64);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			instruction.Op1Register = (Register)(decoder.state.reg + 181);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)(decoder.state.rm + 181);
				if (decoder.state.rm > 3 || (decoder.state.zs.extraBaseRegisterBase & decoder.invalidCheckMask) != 0)
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem_MPX(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_B_Ev : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		private readonly uint ripRelMask;

		public OpCodeHandler_B_Ev(Code code32, Code code64, bool supportsRipRel)
		{
			this.code32 = code32;
			this.code64 = code64;
			ripRelMask = ((!supportsRipRel) ? uint.MaxValue : 0u);
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.state.reg > 3 || (decoder.state.zs.extraRegisterBase & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (decoder.is64bMode)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)(decoder.state.reg + 181);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem_MPX(ref instruction);
			if ((ripRelMask & decoder.invalidCheckMask) != 0 && instruction.MemoryBase == Register.RIP)
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_Mv_Gv_REXW : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Mv_Gv_REXW(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_N_Ib_REX : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Gv_N_Ib_REX(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 225);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Gv_N : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Gv_N(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
			}
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 225);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VN : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VN(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 225);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_Gv_Mv : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Gv_Mv(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op0Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Mv_Gv : OpCodeHandlerModRM
	{
		private readonly Code3 codes;

		public OpCodeHandler_Mv_Gv(Code code16, Code code32, Code code64)
		{
			codes = new Code3(code16, code32, code64);
		}

		public unsafe override void Decode(Decoder decoder, ref Instruction instruction)
		{
			nuint num = (nuint)decoder.state.operandSize;
			instruction.InternalSetCodeNoCheck((Code)codes.codes[num]);
			instruction.Op1Register = (Register)(((int)num << 4) + (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + 21);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_Gv_Eb_REX : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Gv_Eb_REX(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			if (decoder.state.mod == 3)
			{
				uint num = decoder.state.rm + decoder.state.zs.extraBaseRegisterBase;
				if ((decoder.state.zs.flags & StateFlags.HasRex) != 0 && num >= 4)
				{
					num += 4;
				}
				instruction.Op1Register = (Register)(num + 1);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_Gv_Ev_REX : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Gv_Ev_REX(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			if (decoder.state.mod == 3)
			{
				if ((decoder.state.zs.flags & StateFlags.W) != 0)
				{
					instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 53);
				}
				else
				{
					instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 37);
				}
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_Ev_Gv_REX : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_Ev_Gv_REX(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_GvM_VX_Ib : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_GvM_VX_Ib(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			Register register;
			if ((decoder.state.zs.flags & StateFlags.W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_Wbinvd : OpCodeHandler
	{
		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.options & DecoderOptions.NoWbnoinvd) != DecoderOptions.None || decoder.state.zs.mandatoryPrefix != MandatoryPrefixByte.PF3)
			{
				instruction.InternalSetCodeNoCheck(Code.Wbinvd);
				return;
			}
			decoder.ClearMandatoryPrefixF3(ref instruction);
			instruction.InternalSetCodeNoCheck(Code.Wbnoinvd);
		}
	}
	internal sealed class OpCodeHandler_VectorLength_VEX : OpCodeHandlerModRM
	{
		private readonly OpCodeHandler[] handlers;

		public OpCodeHandler_VectorLength_VEX(OpCodeHandler handler128, OpCodeHandler handler256)
		{
			handlers = new OpCodeHandler[4]
			{
				handler128 ?? throw new ArgumentNullException("handler128"),
				handler256 ?? throw new ArgumentNullException("handler256"),
				OpCodeHandler_Invalid.Instance,
				OpCodeHandler_Invalid.Instance
			};
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			handlers[decoder.state.vectorLength].Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VectorLength_NoModRM_VEX : OpCodeHandler
	{
		private readonly OpCodeHandler[] handlers;

		public OpCodeHandler_VectorLength_NoModRM_VEX(OpCodeHandler handler128, OpCodeHandler handler256)
		{
			handlers = new OpCodeHandler[4]
			{
				handler128 ?? throw new ArgumentNullException("handler128"),
				handler256 ?? throw new ArgumentNullException("handler256"),
				OpCodeHandler_Invalid.Instance,
				OpCodeHandler_Invalid.Instance
			};
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			handlers[decoder.state.vectorLength].Decode(decoder, ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_Simple : OpCodeHandler
	{
		private readonly Code code;

		public OpCodeHandler_VEX_Simple(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
		}
	}
	internal sealed class OpCodeHandler_VEX_VHEv : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code codeW0;

		private readonly Code codeW1;

		public OpCodeHandler_VEX_VHEv(Register baseReg, Code codeW0, Code codeW1)
		{
			this.baseReg = baseReg;
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(codeW1);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW0);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op2Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_VHEvIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code codeW0;

		private readonly Code codeW1;

		public OpCodeHandler_VEX_VHEvIb(Register baseReg, Code codeW0, Code codeW1)
		{
			this.baseReg = baseReg;
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(codeW1);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW0);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op2Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op3Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_VW : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		public OpCodeHandler_VEX_VW(Register baseReg, Code code)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
		}

		public OpCodeHandler_VEX_VW(Register baseReg1, Register baseReg2, Code code)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg2);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_VX_Ev : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_VX_Ev(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_Ev_VX : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Ev_VX(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op1Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 77);
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_WV : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		public OpCodeHandler_VEX_WV(Register baseReg, Code code)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg2);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_VM : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_VM(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_MV : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_MV(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_M : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_M(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_RdRq : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_RdRq(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 37);
			}
			if (decoder.state.mod != 3)
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_rDI_VX_RX : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_rDI_VX_RX(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.addressSize == OpSize.Size64)
			{
				instruction.Op0Kind = OpKind.MemorySegRDI;
			}
			else if (decoder.state.addressSize == OpSize.Size32)
			{
				instruction.Op0Kind = OpKind.MemorySegEDI;
			}
			else
			{
				instruction.Op0Kind = OpKind.MemorySegDI;
			}
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_VWIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code codeW0;

		private readonly Code codeW1;

		public OpCodeHandler_VEX_VWIb(Register baseReg, Code code)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			codeW0 = code;
			codeW1 = code;
		}

		public OpCodeHandler_VEX_VWIb(Register baseReg, Code codeW0, Code codeW1)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(codeW1);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW0);
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg1);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg2);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_WVIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Code code;

		public OpCodeHandler_VEX_WVIb(Register baseReg1, Register baseReg2, Code code)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg1);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg2);
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_Ed_V_Ib : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Ed_V_Ib(Register baseReg, Code code32, Code code64)
		{
			this.baseReg = baseReg;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_VHW : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Register baseReg3;

		private readonly Code codeR;

		private readonly Code codeM;

		public OpCodeHandler_VEX_VHW(Register baseReg, Code codeR, Code codeM)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			baseReg3 = baseReg;
			this.codeR = codeR;
			this.codeM = codeM;
		}

		public OpCodeHandler_VEX_VHW(Register baseReg, Code code)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			baseReg3 = baseReg;
			codeR = code;
			codeM = code;
		}

		public OpCodeHandler_VEX_VHW(Register baseReg1, Register baseReg2, Register baseReg3, Code code)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.baseReg3 = baseReg3;
			codeR = code;
			codeM = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg1);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg2);
			if (decoder.state.mod == 3)
			{
				instruction.InternalSetCodeNoCheck(codeR);
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg3);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeM);
				instruction.Op2Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_VWH : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_VWH(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			instruction.Op2Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_WHV : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code codeR;

		public OpCodeHandler_VEX_WHV(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			codeR = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(codeR);
			instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			instruction.Op2Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
		}
	}
	internal sealed class OpCodeHandler_VEX_VHM : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_VHM(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op2Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_MHV : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_MHV(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			instruction.Op2Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_VHWIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register baseReg2;

		private readonly Register baseReg3;

		private readonly Code code;

		public OpCodeHandler_VEX_VHWIb(Register baseReg, Code code)
		{
			baseReg1 = baseReg;
			baseReg2 = baseReg;
			baseReg3 = baseReg;
			this.code = code;
		}

		public OpCodeHandler_VEX_VHWIb(Register baseReg1, Register baseReg2, Register baseReg3, Code code)
		{
			this.baseReg1 = baseReg1;
			this.baseReg2 = baseReg2;
			this.baseReg3 = baseReg3;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg1);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg2);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg3);
			}
			else
			{
				instruction.Op2Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op3Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_HRIb : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_HRIb(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_VHWIs4 : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_VHWIs4(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
			}
			else
			{
				instruction.Op2Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op3Register = (Register)((int)((decoder.ReadByte() >> 4) & decoder.reg15Mask) + (int)baseReg);
		}
	}
	internal sealed class OpCodeHandler_VEX_VHIs4W : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_VHIs4W(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op3Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
			}
			else
			{
				instruction.Op3Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Register = (Register)((int)((decoder.ReadByte() >> 4) & decoder.reg15Mask) + (int)baseReg);
		}
	}
	internal sealed class OpCodeHandler_VEX_VHWIs5 : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_VHWIs5(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
			}
			else
			{
				instruction.Op2Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			uint num = decoder.ReadByte();
			instruction.Op3Register = (Register)((int)((num >> 4) & decoder.reg15Mask) + (int)baseReg);
			instruction.InternalImmediate8 = num & 0xF;
		}
	}
	internal sealed class OpCodeHandler_VEX_VHIs5W : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code;

		public OpCodeHandler_VEX_VHIs5W(Register baseReg, Code code)
		{
			this.baseReg = baseReg;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)baseReg);
			if (decoder.state.mod == 3)
			{
				instruction.Op3Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
			}
			else
			{
				instruction.Op3Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			uint num = decoder.ReadByte();
			instruction.Op2Register = (Register)((int)((num >> 4) & decoder.reg15Mask) + (int)baseReg);
			instruction.InternalImmediate8 = num & 0xF;
		}
	}
	internal sealed class OpCodeHandler_VEX_VK_HK_RK : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_VK_HK_RK(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.invalidCheckMask != 0 && (decoder.state.vvvv > 7 || decoder.state.zs.extraRegisterBase != 0))
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			instruction.Op1Register = (Register)((decoder.state.vvvv & 7) + 173);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)(decoder.state.rm + 173);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_VK_RK : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_VK_RK(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (((decoder.state.vvvv_invalidCheck | decoder.state.zs.extraRegisterBase) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 173);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_VK_RK_Ib : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_VK_RK_Ib(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (((decoder.state.vvvv_invalidCheck | decoder.state.zs.extraRegisterBase) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 173);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_VK_WK : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_VK_WK(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (((decoder.state.vvvv_invalidCheck | decoder.state.zs.extraRegisterBase) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 173);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_M_VK : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_M_VK(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (((decoder.state.vvvv_invalidCheck | decoder.state.zs.extraRegisterBase) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)(decoder.state.reg + 173);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_VK_R : OpCodeHandlerModRM
	{
		private readonly Code code;

		private readonly Register gpr;

		public OpCodeHandler_VEX_VK_R(Code code, Register gpr)
		{
			this.code = code;
			this.gpr = gpr;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (((decoder.state.vvvv_invalidCheck | decoder.state.zs.extraRegisterBase) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)gpr);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_G_VK : OpCodeHandlerModRM
	{
		private readonly Code code;

		private readonly Register gpr;

		public OpCodeHandler_VEX_G_VK(Code code, Register gpr)
		{
			this.code = code;
			this.gpr = gpr;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)gpr);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 173);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_Gv_W : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code codeW0;

		private readonly Code codeW1;

		public OpCodeHandler_VEX_Gv_W(Register baseReg, Code codeW0, Code codeW1)
		{
			this.baseReg = baseReg;
			this.codeW0 = codeW0;
			this.codeW1 = codeW1;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(codeW1);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(codeW0);
				instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 37);
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_Gv_RX : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Gv_RX(Register baseReg, Code code32, Code code64)
		{
			this.baseReg = baseReg;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_Gv_GPR_Ib : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Gv_GPR_Ib(Register baseReg, Code code32, Code code64)
		{
			this.baseReg = baseReg;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)baseReg);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_VX_VSIB_HX : OpCodeHandlerModRM
	{
		private readonly Register baseReg1;

		private readonly Register vsibIndex;

		private readonly Register baseReg3;

		private readonly Code code;

		public OpCodeHandler_VEX_VX_VSIB_HX(Register baseReg1, Register vsibIndex, Register baseReg3, Code code)
		{
			this.baseReg1 = baseReg1;
			this.vsibIndex = vsibIndex;
			this.baseReg3 = baseReg3;
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			instruction.InternalSetCodeNoCheck(code);
			int num = (int)(decoder.state.reg + decoder.state.zs.extraRegisterBase);
			instruction.Op0Register = num + baseReg1;
			instruction.Op2Register = (Register)((int)decoder.state.vvvv + (int)baseReg3);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem_VSIB(ref instruction, vsibIndex, TupleType.N1);
			if (decoder.invalidCheckMask != 0)
			{
				uint num2 = (uint)(instruction.MemoryIndex - 77) % 32u;
				if (num == (int)num2 || decoder.state.vvvv == num2 || num == (int)decoder.state.vvvv)
				{
					decoder.SetInvalidInstruction();
				}
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_Gv_Gv_Ev : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Gv_Gv_Ev(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			instruction.Op1Register = (Register)((int)decoder.state.vvvv + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op2Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_Gv_Ev_Gv : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Gv_Ev_Gv(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			instruction.Op2Register = (Register)((int)decoder.state.vvvv + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_Ev_Gv_Gv : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Ev_Gv_Gv(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			instruction.Op2Register = (Register)((int)decoder.state.vvvv + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_Hv_Ev : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Hv_Ev(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)decoder.state.vvvv + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_Hv_Ed_Id : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Hv_Ed_Id(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				instruction.Op0Register = (Register)(decoder.state.vvvv + 53);
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				instruction.Op0Register = (Register)(decoder.state.vvvv + 37);
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase + 37);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate32;
			instruction.Immediate32 = decoder.ReadUInt32();
		}
	}
	internal sealed class OpCodeHandler_VEX_GvM_VX_Ib : OpCodeHandlerModRM
	{
		private readonly Register baseReg;

		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_GvM_VX_Ib(Register baseReg, Code code32, Code code64)
		{
			this.baseReg = baseReg;
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op0Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op1Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)baseReg);
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_Gv_Ev_Ib : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Gv_Ev_Ib(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_Gv_Ev_Id : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Gv_Ev_Id(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
			}
			else
			{
				instruction.Op1Kind = OpKind.Memory;
				decoder.ReadOpMem(ref instruction);
			}
			instruction.Op2Kind = OpKind.Immediate32;
			instruction.Immediate32 = decoder.ReadUInt32();
		}
	}
	internal sealed class OpCodeHandler_VEX_VT_SIBMEM : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_VT_SIBMEM(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (((decoder.state.vvvv_invalidCheck | decoder.state.zs.extraRegisterBase) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 241);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMemSib(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_SIBMEM_VT : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_SIBMEM_VT(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (((decoder.state.vvvv_invalidCheck | decoder.state.zs.extraRegisterBase) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Register = (Register)(decoder.state.reg + 241);
			if (decoder.state.mod == 3)
			{
				decoder.SetInvalidInstruction();
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMemSib(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_VT : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_VT(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (((decoder.state.vvvv_invalidCheck | decoder.state.zs.extraRegisterBase) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 241);
		}
	}
	internal sealed class OpCodeHandler_VEX_VT_RT_HT : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_VT_RT_HT(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.invalidCheckMask != 0 && (decoder.state.vvvv > 7 || decoder.state.zs.extraRegisterBase != 0))
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 241);
			instruction.Op2Register = (Register)((decoder.state.vvvv & 7) + 241);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)(decoder.state.rm + 241);
				if (decoder.invalidCheckMask != 0 && (decoder.state.zs.extraBaseRegisterBase != 0 || decoder.state.reg == decoder.state.vvvv || decoder.state.reg == decoder.state.rm || decoder.state.rm == decoder.state.vvvv))
				{
					decoder.SetInvalidInstruction();
				}
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_Gq_HK_RK : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_Gq_HK_RK(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.invalidCheckMask != 0 && decoder.state.vvvv > 7)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + decoder.state.zs.extraRegisterBase + 53);
			instruction.Op1Register = (Register)((decoder.state.vvvv & 7) + 173);
			if (decoder.state.mod == 3)
			{
				instruction.Op2Register = (Register)(decoder.state.rm + 173);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
		}
	}
	internal sealed class OpCodeHandler_VEX_VK_R_Ib : OpCodeHandlerModRM
	{
		private readonly Code code;

		private readonly Register gpr;

		public OpCodeHandler_VEX_VK_R_Ib(Code code, Register gpr)
		{
			this.code = code;
			this.gpr = gpr;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (((decoder.state.vvvv_invalidCheck | decoder.state.zs.extraRegisterBase) & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op0Register = (Register)(decoder.state.reg + 173);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)gpr);
			}
			else
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op2Kind = OpKind.Immediate8;
			instruction.InternalImmediate8 = decoder.ReadByte();
		}
	}
	internal sealed class OpCodeHandler_VEX_K_Jb : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_K_Jb(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			decoder.state.zs.flags |= StateFlags.BranchImm8;
			if (decoder.invalidCheckMask != 0 && decoder.state.vvvv > 7)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op0Register = (Register)((decoder.state.vvvv & 7) + 173);
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Kind = OpKind.NearBranch64;
			instruction.NearBranch64 = (ulong)(sbyte)decoder.state.modrm + decoder.GetCurrentInstructionPointer64();
		}
	}
	internal sealed class OpCodeHandler_VEX_K_Jz : OpCodeHandlerModRM
	{
		private readonly Code code;

		public OpCodeHandler_VEX_K_Jz(Code code)
		{
			this.code = code;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if (decoder.invalidCheckMask != 0 && decoder.state.vvvv > 7)
			{
				decoder.SetInvalidInstruction();
			}
			instruction.Op0Register = (Register)((decoder.state.vvvv & 7) + 173);
			instruction.InternalSetCodeNoCheck(code);
			instruction.Op1Kind = OpKind.NearBranch64;
			uint num = decoder.state.modrm | (decoder.ReadByte() << 8) | (decoder.ReadByte() << 16) | (decoder.ReadByte() << 24);
			instruction.NearBranch64 = (ulong)(int)num + decoder.GetCurrentInstructionPointer64();
		}
	}
	internal sealed class OpCodeHandler_VEX_Gv_Ev : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Gv_Ev(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			instruction.Op0Register = (Register)((int)(decoder.state.reg + decoder.state.zs.extraRegisterBase) + (int)register);
			if (decoder.state.mod == 3)
			{
				instruction.Op1Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op1Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal sealed class OpCodeHandler_VEX_Ev : OpCodeHandlerModRM
	{
		private readonly Code code32;

		private readonly Code code64;

		public OpCodeHandler_VEX_Ev(Code code32, Code code64)
		{
			this.code32 = code32;
			this.code64 = code64;
		}

		public override void Decode(Decoder decoder, ref Instruction instruction)
		{
			if ((decoder.state.vvvv_invalidCheck & decoder.invalidCheckMask) != 0)
			{
				decoder.SetInvalidInstruction();
			}
			Register register;
			if (((uint)decoder.state.zs.flags & decoder.is64bMode_and_W) != 0)
			{
				instruction.InternalSetCodeNoCheck(code64);
				register = Register.RAX;
			}
			else
			{
				instruction.InternalSetCodeNoCheck(code32);
				register = Register.EAX;
			}
			if (decoder.state.mod == 3)
			{
				instruction.Op0Register = (Register)((int)(decoder.state.rm + decoder.state.zs.extraBaseRegisterBase) + (int)register);
				return;
			}
			instruction.Op0Kind = OpKind.Memory;
			decoder.ReadOpMem(ref instruction);
		}
	}
	internal enum SerializedDataKind : byte
	{
		HandlerReference,
		ArrayReference
	}
	internal abstract class OpCodeHandlerReader
	{
		public abstract int ReadHandlers(ref TableDeserializer deserializer, OpCodeHandler?[] result, int resultIndex);
	}
	internal readonly struct HandlerInfo
	{
		public readonly OpCodeHandler? handler;

		public readonly OpCodeHandler?[]? handlers;

		public HandlerInfo(OpCodeHandler handler)
		{
			this.handler = handler;
			handlers = null;
		}

		public HandlerInfo(OpCodeHandler?[] handlers)
		{
			handler = null;
			this.handlers = handlers;
		}
	}
	internal ref struct TableDeserializer
	{
		private DataReader reader;

		private readonly OpCodeHandlerReader handlerReader;

		private readonly List<HandlerInfo> idToHandler;

		private readonly OpCodeHandler[] handlerArray;

		public TableDeserializer(OpCodeHandlerReader handlerReader, int maxIds, ReadOnlySpan<byte> data)
		{
			this.handlerReader = handlerReader;
			reader = new DataReader(data);
			idToHandler = new List<HandlerInfo>(maxIds);
			handlerArray = new OpCodeHandler[1];
		}

		public void Deserialize()
		{
			while (reader.CanRead)
			{
				switch ((SerializedDataKind)reader.ReadByte())
				{
				case SerializedDataKind.HandlerReference:
					idToHandler.Add(new HandlerInfo(ReadHandler()));
					break;
				case SerializedDataKind.ArrayReference:
					idToHandler.Add(new HandlerInfo(ReadHandlers((int)reader.ReadCompressedUInt32())));
					break;
				default:
					throw new InvalidOperationException();
				}
			}
			if (reader.CanRead)
			{
				throw new InvalidOperationException();
			}
		}

		public LegacyOpCodeHandlerKind ReadLegacyOpCodeHandlerKind()
		{
			return (LegacyOpCodeHandlerKind)reader.ReadByte();
		}

		public VexOpCodeHandlerKind ReadVexOpCodeHandlerKind()
		{
			return (VexOpCodeHandlerKind)reader.ReadByte();
		}

		public EvexOpCodeHandlerKind ReadEvexOpCodeHandlerKind()
		{
			return (EvexOpCodeHandlerKind)reader.ReadByte();
		}

		public Code ReadCode()
		{
			return (Code)reader.ReadCompressedUInt32();
		}

		public Register ReadRegister()
		{
			return (Register)reader.ReadByte();
		}

		public DecoderOptions ReadDecoderOptions()
		{
			return (DecoderOptions)reader.ReadCompressedUInt32();
		}

		public HandlerFlags ReadHandlerFlags()
		{
			return (HandlerFlags)reader.ReadCompressedUInt32();
		}

		public LegacyHandlerFlags ReadLegacyHandlerFlags()
		{
			return (LegacyHandlerFlags)reader.ReadCompressedUInt32();
		}

		public TupleType ReadTupleType()
		{
			return (TupleType)reader.ReadByte();
		}

		public bool ReadBoolean()
		{
			return reader.ReadByte() != 0;
		}

		public int ReadInt32()
		{
			return (int)reader.ReadCompressedUInt32();
		}

		public OpCodeHandler ReadHandler()
		{
			return ReadHandlerOrNull() ?? throw new InvalidOperationException();
		}

		public OpCodeHandler? ReadHandlerOrNull()
		{
			if (handlerReader.ReadHandlers(ref this, handlerArray, 0) != 1)
			{
				throw new InvalidOperationException();
			}
			return handlerArray[0];
		}

		public OpCodeHandler?[] ReadHandlers(int count)
		{
			OpCodeHandler[] array = new OpCodeHandler[count];
			int num;
			for (int i = 0; i < array.Length; i += num)
			{
				num = handlerReader.ReadHandlers(ref this, array, i);
				if (num <= 0 || (uint)(i + num) > (uint)array.Length)
				{
					throw new InvalidOperationException();
				}
			}
			return array;
		}

		public OpCodeHandler ReadHandlerReference()
		{
			uint index = reader.ReadByte();
			return idToHandler[(int)index].handler ?? throw new InvalidOperationException();
		}

		public OpCodeHandler[] ReadArrayReference(uint kind)
		{
			if (reader.ReadByte() != kind)
			{
				throw new InvalidOperationException();
			}
			return GetTable(reader.ReadByte());
		}

		public OpCodeHandler[] GetTable(uint index)
		{
			return idToHandler[(int)index].handlers ?? throw new InvalidOperationException();
		}
	}
	internal enum VexOpCodeHandlerKind : byte
	{
		Invalid,
		Invalid2,
		Dup,
		Invalid_NoModRM,
		Bitness_DontReadModRM,
		HandlerReference,
		ArrayReference,
		RM,
		Group,
		W,
		MandatoryPrefix2_1,
		MandatoryPrefix2_4,
		MandatoryPrefix2_NoModRM,
		VectorLength_NoModRM,
		VectorLength,
		Ed_V_Ib,
		Ev_VX,
		G_VK,
		Gv_Ev_Gv,
		Gv_Ev_Ib,
		Gv_Ev_Id,
		Gv_GPR_Ib,
		Gv_Gv_Ev,
		Gv_RX,
		Gv_W,
		GvM_VX_Ib,
		HRIb,
		Hv_Ed_Id,
		Hv_Ev,
		M,
		MHV,
		M_VK,
		MV,
		rDI_VX_RX,
		RdRq,
		Simple,
		VHEv,
		VHEvIb,
		VHIs4W,
		VHIs5W,
		VHM,
		VHW_2,
		VHW_3,
		VHW_4,
		VHWIb_2,
		VHWIb_4,
		VHWIs4,
		VHWIs5,
		VK_HK_RK,
		VK_R,
		VK_RK,
		VK_RK_Ib,
		VK_WK,
		VM,
		VW_2,
		VW_3,
		VWH,
		VWIb_2,
		VWIb_3,
		VX_Ev,
		VX_VSIB_HX,
		WHV,
		WV,
		WVIb,
		VT_SIBMEM,
		SIBMEM_VT,
		VT,
		VT_RT_HT,
		Group8x64,
		Bitness,
		Null,
		Options_DontReadModRM,
		Gq_HK_RK,
		VK_R_Ib,
		Gv_Ev,
		Ev,
		K_Jb,
		K_Jz,
		Ev_Gv_Gv
	}
	internal sealed class VexOpCodeHandlerReader : OpCodeHandlerReader
	{
		public override int ReadHandlers(ref TableDeserializer deserializer, OpCodeHandler?[] result, int resultIndex)
		{
			ref OpCodeHandler reference = ref result[resultIndex];
			switch (deserializer.ReadVexOpCodeHandlerKind())
			{
			case VexOpCodeHandlerKind.Invalid:
				reference = OpCodeHandler_Invalid.Instance;
				return 1;
			case VexOpCodeHandlerKind.Invalid2:
				result[resultIndex] = OpCodeHandler_Invalid.Instance;
				result[resultIndex + 1] = OpCodeHandler_Invalid.Instance;
				return 2;
			case VexOpCodeHandlerKind.Dup:
			{
				int num = deserializer.ReadInt32();
				OpCodeHandler opCodeHandler = deserializer.ReadHandlerOrNull();
				for (int i = 0; i < num; i++)
				{
					result[resultIndex + i] = opCodeHandler;
				}
				return num;
			}
			case VexOpCodeHandlerKind.Null:
				reference = null;
				return 1;
			case VexOpCodeHandlerKind.Invalid_NoModRM:
				reference = OpCodeHandler_Invalid_NoModRM.Instance;
				return 1;
			case VexOpCodeHandlerKind.Bitness:
				reference = new OpCodeHandler_Bitness(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case VexOpCodeHandlerKind.Bitness_DontReadModRM:
				reference = new OpCodeHandler_Bitness_DontReadModRM(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case VexOpCodeHandlerKind.HandlerReference:
				reference = deserializer.ReadHandlerReference();
				return 1;
			case VexOpCodeHandlerKind.ArrayReference:
				throw new InvalidOperationException();
			case VexOpCodeHandlerKind.RM:
				reference = new OpCodeHandler_RM(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case VexOpCodeHandlerKind.Group:
				reference = new OpCodeHandler_Group(deserializer.ReadArrayReference(6u));
				return 1;
			case VexOpCodeHandlerKind.Group8x64:
				reference = new OpCodeHandler_Group8x64(deserializer.ReadArrayReference(6u), deserializer.ReadArrayReference(6u));
				return 1;
			case VexOpCodeHandlerKind.W:
				reference = new OpCodeHandler_W(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case VexOpCodeHandlerKind.MandatoryPrefix2_1:
				reference = new OpCodeHandler_MandatoryPrefix2(deserializer.ReadHandler());
				return 1;
			case VexOpCodeHandlerKind.MandatoryPrefix2_4:
				reference = new OpCodeHandler_MandatoryPrefix2(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case VexOpCodeHandlerKind.MandatoryPrefix2_NoModRM:
				reference = new OpCodeHandler_MandatoryPrefix2_NoModRM(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case VexOpCodeHandlerKind.VectorLength_NoModRM:
				reference = new OpCodeHandler_VectorLength_NoModRM_VEX(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case VexOpCodeHandlerKind.VectorLength:
				reference = new OpCodeHandler_VectorLength_VEX(deserializer.ReadHandler(), deserializer.ReadHandler());
				return 1;
			case VexOpCodeHandlerKind.Ed_V_Ib:
			{
				Code code;
				reference = new OpCodeHandler_VEX_Ed_V_Ib(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Ev_VX:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_Ev_VX(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.G_VK:
				reference = new OpCodeHandler_VEX_G_VK(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case VexOpCodeHandlerKind.Gv_Ev_Gv:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_Gv_Ev_Gv(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Ev_Gv_Gv:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_Ev_Gv_Gv(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Gv_Ev_Ib:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_Gv_Ev_Ib(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Gv_Ev_Id:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_Gv_Ev_Id(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Gv_GPR_Ib:
			{
				Code code;
				reference = new OpCodeHandler_VEX_Gv_GPR_Ib(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Gv_Gv_Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_Gv_Gv_Ev(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Gv_RX:
			{
				Code code;
				reference = new OpCodeHandler_VEX_Gv_RX(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Gv_W:
			{
				Code code;
				reference = new OpCodeHandler_VEX_Gv_W(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.GvM_VX_Ib:
			{
				Code code;
				reference = new OpCodeHandler_VEX_GvM_VX_Ib(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.HRIb:
				reference = new OpCodeHandler_VEX_HRIb(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.Hv_Ed_Id:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_Hv_Ed_Id(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Hv_Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_Hv_Ev(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.M:
				reference = new OpCodeHandler_VEX_M(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.MHV:
				reference = new OpCodeHandler_VEX_MHV(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.M_VK:
				reference = new OpCodeHandler_VEX_M_VK(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.MV:
				reference = new OpCodeHandler_VEX_MV(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.rDI_VX_RX:
				reference = new OpCodeHandler_VEX_rDI_VX_RX(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.RdRq:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_RdRq(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Simple:
				reference = new OpCodeHandler_VEX_Simple(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VHEv:
			{
				Code code;
				reference = new OpCodeHandler_VEX_VHEv(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.VHEvIb:
			{
				Code code;
				reference = new OpCodeHandler_VEX_VHEvIb(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.VHIs4W:
				reference = new OpCodeHandler_VEX_VHIs4W(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VHIs5W:
				reference = new OpCodeHandler_VEX_VHIs5W(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VHM:
				reference = new OpCodeHandler_VEX_VHM(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VHW_2:
				reference = new OpCodeHandler_VEX_VHW(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VHW_3:
				reference = new OpCodeHandler_VEX_VHW(deserializer.ReadRegister(), deserializer.ReadCode(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VHW_4:
				reference = new OpCodeHandler_VEX_VHW(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VHWIb_2:
				reference = new OpCodeHandler_VEX_VHWIb(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VHWIb_4:
				reference = new OpCodeHandler_VEX_VHWIb(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VHWIs4:
				reference = new OpCodeHandler_VEX_VHWIs4(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VHWIs5:
				reference = new OpCodeHandler_VEX_VHWIs5(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VK_HK_RK:
				reference = new OpCodeHandler_VEX_VK_HK_RK(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VK_R:
				reference = new OpCodeHandler_VEX_VK_R(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case VexOpCodeHandlerKind.VK_RK:
				reference = new OpCodeHandler_VEX_VK_RK(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VK_RK_Ib:
				reference = new OpCodeHandler_VEX_VK_RK_Ib(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VK_WK:
				reference = new OpCodeHandler_VEX_VK_WK(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VM:
				reference = new OpCodeHandler_VEX_VM(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VW_2:
				reference = new OpCodeHandler_VEX_VW(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VW_3:
				reference = new OpCodeHandler_VEX_VW(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VWH:
				reference = new OpCodeHandler_VEX_VWH(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VWIb_2:
				reference = new OpCodeHandler_VEX_VWIb(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VWIb_3:
			{
				Code code;
				reference = new OpCodeHandler_VEX_VWIb(deserializer.ReadRegister(), code = deserializer.ReadCode(), code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.VX_Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_VX_Ev(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.VX_VSIB_HX:
				reference = new OpCodeHandler_VEX_VX_VSIB_HX(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.WHV:
				reference = new OpCodeHandler_VEX_WHV(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.WV:
				reference = new OpCodeHandler_VEX_WV(deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.WVIb:
				reference = new OpCodeHandler_VEX_WVIb(deserializer.ReadRegister(), deserializer.ReadRegister(), deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VT_SIBMEM:
				reference = new OpCodeHandler_VEX_VT_SIBMEM(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.SIBMEM_VT:
				reference = new OpCodeHandler_VEX_SIBMEM_VT(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VT:
				reference = new OpCodeHandler_VEX_VT(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VT_RT_HT:
				reference = new OpCodeHandler_VEX_VT_RT_HT(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.Options_DontReadModRM:
				reference = new OpCodeHandler_Options_DontReadModRM(deserializer.ReadHandler(), deserializer.ReadHandler(), deserializer.ReadDecoderOptions());
				return 1;
			case VexOpCodeHandlerKind.Gq_HK_RK:
				reference = new OpCodeHandler_VEX_Gq_HK_RK(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.VK_R_Ib:
				reference = new OpCodeHandler_VEX_VK_R_Ib(deserializer.ReadCode(), deserializer.ReadRegister());
				return 1;
			case VexOpCodeHandlerKind.Gv_Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_Gv_Ev(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.Ev:
			{
				Code code = deserializer.ReadCode();
				reference = new OpCodeHandler_VEX_Ev(code, code + 1);
				return 1;
			}
			case VexOpCodeHandlerKind.K_Jb:
				reference = new OpCodeHandler_VEX_K_Jb(deserializer.ReadCode());
				return 1;
			case VexOpCodeHandlerKind.K_Jz:
				reference = new OpCodeHandler_VEX_K_Jz(deserializer.ReadCode());
				return 1;
			default:
				throw new InvalidOperationException();
			}
		}
	}
}
namespace Iced.Intel.BlockEncoderInternal
{
	internal sealed class Block
	{
		public readonly CodeWriterImpl CodeWriter;

		public readonly ulong RIP;

		public readonly List<RelocInfo>? relocInfos;

		private Instr[] instructions;

		private readonly List<BlockData> dataList;

		private readonly ulong alignment;

		private readonly List<BlockData> validData;

		private ulong validDataAddress;

		private ulong validDataAddressAligned;

		public Instr[] Instructions => instructions;

		public bool CanAddRelocInfos => relocInfos != null;

		public Block(BlockEncoder blockEncoder, CodeWriter codeWriter, ulong rip, List<RelocInfo>? relocInfos)
		{
			CodeWriter = new CodeWriterImpl(codeWriter);
			RIP = rip;
			this.relocInfos = relocInfos;
			instructions = Array2.Empty<Instr>();
			dataList = new List<BlockData>();
			alignment = (uint)blockEncoder.Bitness / 8u;
			validData = new List<BlockData>();
		}

		internal void SetInstructions(Instr[] instructions)
		{
			this.instructions = instructions;
		}

		public BlockData AllocPointerLocation()
		{
			BlockData blockData = new BlockData
			{
				IsValid = true
			};
			dataList.Add(blockData);
			return blockData;
		}

		public void InitializeData()
		{
			ulong num;
			if (Instructions.Length != 0)
			{
				Instr instr = Instructions[Instructions.Length - 1];
				num = instr.IP + instr.Size;
			}
			else
			{
				num = RIP;
			}
			validDataAddress = num;
			ulong num2 = (validDataAddressAligned = (num + alignment - 1) & ~(alignment - 1));
			foreach (BlockData data in dataList)
			{
				if (data.IsValid)
				{
					data.__dont_use_address = num2;
					data.__dont_use_address_initd = true;
					validData.Add(data);
					num2 += alignment;
				}
			}
		}

		public void WriteData()
		{
			if (validData.Count == 0)
			{
				return;
			}
			CodeWriterImpl codeWriter = CodeWriter;
			int num = (int)(validDataAddressAligned - validDataAddress);
			for (int i = 0; i < num; i++)
			{
				codeWriter.WriteByte(204);
			}
			List<RelocInfo> list = relocInfos;
			if ((int)alignment == 8)
			{
				foreach (BlockData validDatum in validData)
				{
					list?.Add(new RelocInfo(RelocKind.Offset64, validDatum.Address));
					uint num2 = (uint)validDatum.Data;
					codeWriter.WriteByte((byte)num2);
					codeWriter.WriteByte((byte)(num2 >> 8));
					codeWriter.WriteByte((byte)(num2 >> 16));
					codeWriter.WriteByte((byte)(num2 >> 24));
					num2 = (uint)(validDatum.Data >> 32);
					codeWriter.WriteByte((byte)num2);
					codeWriter.WriteByte((byte)(num2 >> 8));
					codeWriter.WriteByte((byte)(num2 >> 16));
					codeWriter.WriteByte((byte)(num2 >> 24));
				}
				return;
			}
			throw new InvalidOperationException();
		}

		public void AddRelocInfo(RelocInfo relocInfo)
		{
			relocInfos?.Add(relocInfo);
		}
	}
	internal sealed class BlockData
	{
		internal ulong __dont_use_address;

		internal bool __dont_use_address_initd;

		public bool IsValid;

		public ulong Data;

		public ulong Address
		{
			get
			{
				if (!IsValid)
				{
					ThrowHelper.ThrowInvalidOperationException();
				}
				if (!__dont_use_address_initd)
				{
					ThrowHelper.ThrowInvalidOperationException();
				}
				return __dont_use_address;
			}
		}
	}
	internal sealed class CallInstr : Instr
	{
		private readonly byte bitness;

		private Instruction instruction;

		private TargetInstr targetInstr;

		private readonly byte origInstructionSize;

		private BlockData pointerData;

		private bool useOrigInstruction;

		public CallInstr(BlockEncoder blockEncoder, Block block, in Instruction instruction)
			: base(block, instruction.IP)
		{
			bitness = (byte)blockEncoder.Bitness;
			this.instruction = instruction;
			Instruction instruction2 = instruction;
			instruction2.NearBranch64 = 0uL;
			origInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, 0uL);
			if (!blockEncoder.FixBranches)
			{
				Size = origInstructionSize;
				useOrigInstruction = true;
			}
			else if (blockEncoder.Bitness == 64)
			{
				Size = Math.Max(origInstructionSize, 6u);
			}
			else
			{
				Size = origInstructionSize;
			}
		}

		public override void Initialize(BlockEncoder blockEncoder)
		{
			targetInstr = blockEncoder.GetTarget(instruction.NearBranchTarget);
		}

		public override bool Optimize(ulong gained)
		{
			return TryOptimize(gained);
		}

		private bool TryOptimize(ulong gained)
		{
			if (Done || useOrigInstruction)
			{
				Done = true;
				return false;
			}
			bool flag = bitness != 64 || targetInstr.IsInBlock(Block);
			if (!flag)
			{
				ulong address = targetInstr.GetAddress();
				ulong num = IP + origInstructionSize;
				long diff = (long)(address - num);
				diff = Instr.CorrectDiff(targetInstr.IsInBlock(Block), diff, gained);
				flag = int.MinValue <= diff && diff <= int.MaxValue;
			}
			if (flag)
			{
				if (pointerData != null)
				{
					pointerData.IsValid = false;
				}
				Size = origInstructionSize;
				useOrigInstruction = true;
				Done = true;
				return true;
			}
			if (pointerData == null)
			{
				pointerData = Block.AllocPointerLocation();
			}
			return false;
		}

		public override string? TryEncode(Encoder encoder, out ConstantOffsets constantOffsets, out bool isOriginalInstruction)
		{
			uint size;
			if (useOrigInstruction)
			{
				isOriginalInstruction = true;
				instruction.NearBranch64 = targetInstr.GetAddress();
				if (!encoder.TryEncode(in instruction, IP, out size, out string errorMessage))
				{
					constantOffsets = default(ConstantOffsets);
					return Instr.CreateErrorMessage(errorMessage, in instruction);
				}
				constantOffsets = encoder.GetConstantOffsets();
				return null;
			}
			isOriginalInstruction = false;
			constantOffsets = default(ConstantOffsets);
			pointerData.Data = targetInstr.GetAddress();
			string text = EncodeBranchToPointerData(encoder, isCall: true, IP, pointerData, out size, Size);
			if (text != null)
			{
				return Instr.CreateErrorMessage(text, in instruction);
			}
			return null;
		}
	}
	internal sealed class CodeWriterImpl : CodeWriter
	{
		public uint BytesWritten;

		private readonly CodeWriter codeWriter;

		public CodeWriterImpl(CodeWriter codeWriter)
		{
			if (codeWriter == null)
			{
				ThrowHelper.ThrowArgumentNullException_codeWriter();
			}
			this.codeWriter = codeWriter;
		}

		public override void WriteByte(byte value)
		{
			BytesWritten++;
			codeWriter.WriteByte(value);
		}
	}
	internal abstract class Instr
	{
		public readonly Block Block;

		public uint Size;

		public ulong IP;

		public readonly ulong OrigIP;

		public bool Done;

		protected const uint CallOrJmpPointerDataInstructionSize64 = 6u;

		protected Instr(Block block, ulong origIp)
		{
			OrigIP = origIp;
			Block = block;
		}

		public abstract void Initialize(BlockEncoder blockEncoder);

		public abstract bool Optimize(ulong gained);

		public abstract string? TryEncode(Encoder encoder, out ConstantOffsets constantOffsets, out bool isOriginalInstruction);

		protected static string CreateErrorMessage(string errorMessage, in Instruction instruction)
		{
			return $"{errorMessage} : 0x{instruction.IP:X} {instruction.ToString()}";
		}

		public static Instr Create(BlockEncoder blockEncoder, Block block, in Instruction instruction)
		{
			switch (instruction.Code)
			{
			case Code.Jo_rel8_16:
			case Code.Jo_rel8_32:
			case Code.Jo_rel8_64:
			case Code.Jno_rel8_16:
			case Code.Jno_rel8_32:
			case Code.Jno_rel8_64:
			case Code.Jb_rel8_16:
			case Code.Jb_rel8_32:
			case Code.Jb_rel8_64:
			case Code.Jae_rel8_16:
			case Code.Jae_rel8_32:
			case Code.Jae_rel8_64:
			case Code.Je_rel8_16:
			case Code.Je_rel8_32:
			case Code.Je_rel8_64:
			case Code.Jne_rel8_16:
			case Code.Jne_rel8_32:
			case Code.Jne_rel8_64:
			case Code.Jbe_rel8_16:
			case Code.Jbe_rel8_32:
			case Code.Jbe_rel8_64:
			case Code.Ja_rel8_16:
			case Code.Ja_rel8_32:
			case Code.Ja_rel8_64:
			case Code.Js_rel8_16:
			case Code.Js_rel8_32:
			case Code.Js_rel8_64:
			case Code.Jns_rel8_16:
			case Code.Jns_rel8_32:
			case Code.Jns_rel8_64:
			case Code.Jp_rel8_16:
			case Code.Jp_rel8_32:
			case Code.Jp_rel8_64:
			case Code.Jnp_rel8_16:
			case Code.Jnp_rel8_32:
			case Code.Jnp_rel8_64:
			case Code.Jl_rel8_16:
			case Code.Jl_rel8_32:
			case Code.Jl_rel8_64:
			case Code.Jge_rel8_16:
			case Code.Jge_rel8_32:
			case Code.Jge_rel8_64:
			case Code.Jle_rel8_16:
			case Code.Jle_rel8_32:
			case Code.Jle_rel8_64:
			case Code.Jg_rel8_16:
			case Code.Jg_rel8_32:
			case Code.Jg_rel8_64:
			case Code.Jo_rel16:
			case Code.Jo_rel32_32:
			case Code.Jo_rel32_64:
			case Code.Jno_rel16:
			case Code.Jno_rel32_32:
			case Code.Jno_rel32_64:
			case Code.Jb_rel16:
			case Code.Jb_rel32_32:
			case Code.Jb_rel32_64:
			case Code.Jae_rel16:
			case Code.Jae_rel32_32:
			case Code.Jae_rel32_64:
			case Code.Je_rel16:
			case Code.Je_rel32_32:
			case Code.Je_rel32_64:
			case Code.Jne_rel16:
			case Code.Jne_rel32_32:
			case Code.Jne_rel32_64:
			case Code.Jbe_rel16:
			case Code.Jbe_rel32_32:
			case Code.Jbe_rel32_64:
			case Code.Ja_rel16:
			case Code.Ja_rel32_32:
			case Code.Ja_rel32_64:
			case Code.Js_rel16:
			case Code.Js_rel32_32:
			case Code.Js_rel32_64:
			case Code.Jns_rel16:
			case Code.Jns_rel32_32:
			case Code.Jns_rel32_64:
			case Code.Jp_rel16:
			case Code.Jp_rel32_32:
			case Code.Jp_rel32_64:
			case Code.Jnp_rel16:
			case Code.Jnp_rel32_32:
			case Code.Jnp_rel32_64:
			case Code.Jl_rel16:
			case Code.Jl_rel32_32:
			case Code.Jl_rel32_64:
			case Code.Jge_rel16:
			case Code.Jge_rel32_32:
			case Code.Jge_rel32_64:
			case Code.Jle_rel16:
			case Code.Jle_rel32_32:
			case Code.Jle_rel32_64:
			case Code.Jg_rel16:
			case Code.Jg_rel32_32:
			case Code.Jg_rel32_64:
			case Code.VEX_KNC_Jkzd_kr_rel8_64:
			case Code.VEX_KNC_Jknzd_kr_rel8_64:
			case Code.VEX_KNC_Jkzd_kr_rel32_64:
			case Code.VEX_KNC_Jknzd_kr_rel32_64:
				return new JccInstr(blockEncoder, block, in instruction);
			case Code.Loopne_rel8_16_CX:
			case Code.Loopne_rel8_32_CX:
			case Code.Loopne_rel8_16_ECX:
			case Code.Loopne_rel8_32_ECX:
			case Code.Loopne_rel8_64_ECX:
			case Code.Loopne_rel8_16_RCX:
			case Code.Loopne_rel8_64_RCX:
			case Code.Loope_rel8_16_CX:
			case Code.Loope_rel8_32_CX:
			case Code.Loope_rel8_16_ECX:
			case Code.Loope_rel8_32_ECX:
			case Code.Loope_rel8_64_ECX:
			case Code.Loope_rel8_16_RCX:
			case Code.Loope_rel8_64_RCX:
			case Code.Loop_rel8_16_CX:
			case Code.Loop_rel8_32_CX:
			case Code.Loop_rel8_16_ECX:
			case Code.Loop_rel8_32_ECX:
			case Code.Loop_rel8_64_ECX:
			case Code.Loop_rel8_16_RCX:
			case Code.Loop_rel8_64_RCX:
			case Code.Jcxz_rel8_16:
			case Code.Jcxz_rel8_32:
			case Code.Jecxz_rel8_16:
			case Code.Jecxz_rel8_32:
			case Code.Jecxz_rel8_64:
			case Code.Jrcxz_rel8_16:
			case Code.Jrcxz_rel8_64:
				return new SimpleBranchInstr(blockEncoder, block, in instruction);
			case Code.Call_rel16:
			case Code.Call_rel32_32:
			case Code.Call_rel32_64:
				return new CallInstr(blockEncoder, block, in instruction);
			case Code.Jmp_rel16:
			case Code.Jmp_rel32_32:
			case Code.Jmp_rel32_64:
			case Code.Jmp_rel8_16:
			case Code.Jmp_rel8_32:
			case Code.Jmp_rel8_64:
				return new JmpInstr(blockEncoder, block, in instruction);
			case Code.Xbegin_rel16:
			case Code.Xbegin_rel32:
				return new XbeginInstr(blockEncoder, block, in instruction);
			default:
				if (blockEncoder.Bitness == 64)
				{
					int opCount = instruction.OpCount;
					for (int i = 0; i < opCount; i++)
					{
						if (instruction.GetOpKind(i) == OpKind.Memory)
						{
							if (!instruction.IsIPRelativeMemoryOperand)
							{
								break;
							}
							return new IpRelMemOpInstr(blockEncoder, block, in instruction);
						}
					}
				}
				return new SimpleInstr(blockEncoder, block, in instruction);
			}
		}

		protected string? EncodeBranchToPointerData(Encoder encoder, bool isCall, ulong ip, BlockData pointerData, out uint size, uint minSize)
		{
			if (minSize > int.MaxValue)
			{
				throw new ArgumentOutOfRangeException("minSize");
			}
			Instruction instruction = new Instruction
			{
				Op0Kind = OpKind.Memory,
				MemoryDisplSize = encoder.Bitness / 8
			};
			if (encoder.Bitness == 64)
			{
				instruction.InternalSetCodeNoCheck(isCall ? Code.Call_rm64 : Code.Jmp_rm64);
				instruction.MemoryBase = Register.RIP;
				ulong num = ip + 6;
				long num2 = (long)(pointerData.Address - num);
				if (int.MinValue > num2 || num2 > int.MaxValue)
				{
					size = 0u;
					return "Block is too big";
				}
				instruction.MemoryDisplacement64 = pointerData.Address;
				RelocKind relocKind = RelocKind.Offset64;
				if (!encoder.TryEncode(in instruction, ip, out size, out string errorMessage))
				{
					return errorMessage;
				}
				if (Block.CanAddRelocInfos && relocKind != RelocKind.Offset64)
				{
					ConstantOffsets constantOffsets = encoder.GetConstantOffsets();
					if (!constantOffsets.HasDisplacement)
					{
						return "Internal error: no displ";
					}
					Block.AddRelocInfo(new RelocInfo(relocKind, IP + constantOffsets.DisplacementOffset));
				}
				while (size < minSize)
				{
					size++;
					Block.CodeWriter.WriteByte(144);
				}
				return null;
			}
			throw new InvalidOperationException();
		}

		protected static long CorrectDiff(bool inBlock, long diff, ulong gained)
		{
			if (inBlock && diff >= 0)
			{
				return diff - (long)gained;
			}
			return diff;
		}

		protected static long ConvertDiffToBitnessDiff(int bitness, long diff)
		{
			return bitness switch
			{
				16 => (short)diff, 
				32 => (int)diff, 
				_ => diff, 
			};
		}
	}
	internal sealed class IpRelMemOpInstr : Instr
	{
		private enum InstrKind : byte
		{
			Unchanged,
			Rip,
			Eip,
			Long,
			Uninitialized
		}

		private Instruction instruction;

		private InstrKind instrKind;

		private readonly byte eipInstructionSize;

		private readonly byte ripInstructionSize;

		private TargetInstr targetInstr;

		public IpRelMemOpInstr(BlockEncoder blockEncoder, Block block, in Instruction instruction)
			: base(block, instruction.IP)
		{
			this.instruction = instruction;
			instrKind = InstrKind.Uninitialized;
			Instruction instruction2 = instruction;
			instruction2.MemoryBase = Register.RIP;
			instruction2.MemoryDisplacement64 = 0uL;
			ripInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, instruction2.IPRelativeMemoryAddress);
			instruction2.MemoryBase = Register.EIP;
			eipInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, instruction2.IPRelativeMemoryAddress);
			Size = eipInstructionSize;
		}

		public override void Initialize(BlockEncoder blockEncoder)
		{
			targetInstr = blockEncoder.GetTarget(instruction.IPRelativeMemoryAddress);
		}

		public override bool Optimize(ulong gained)
		{
			return TryOptimize(gained);
		}

		private bool TryOptimize(ulong gained)
		{
			if (instrKind == InstrKind.Unchanged || instrKind == InstrKind.Rip || instrKind == InstrKind.Eip)
			{
				Done = true;
				return false;
			}
			bool flag = targetInstr.IsInBlock(Block);
			ulong address = targetInstr.GetAddress();
			if (!flag)
			{
				ulong num = IP + ripInstructionSize;
				long diff = (long)(address - num);
				diff = Instr.CorrectDiff(targetInstr.IsInBlock(Block), diff, gained);
				flag = int.MinValue <= diff && diff <= int.MaxValue;
			}
			if (flag)
			{
				Size = ripInstructionSize;
				instrKind = InstrKind.Rip;
				Done = true;
				return true;
			}
			if (address <= uint.MaxValue)
			{
				Size = eipInstructionSize;
				instrKind = InstrKind.Eip;
				Done = true;
				return true;
			}
			instrKind = InstrKind.Long;
			return false;
		}

		public override string? TryEncode(Encoder encoder, out ConstantOffsets constantOffsets, out bool isOriginalInstruction)
		{
			switch (instrKind)
			{
			case InstrKind.Unchanged:
			case InstrKind.Rip:
			case InstrKind.Eip:
			{
				isOriginalInstruction = true;
				if (instrKind == InstrKind.Rip)
				{
					instruction.MemoryBase = Register.RIP;
				}
				else if (instrKind == InstrKind.Eip)
				{
					instruction.MemoryBase = Register.EIP;
				}
				ulong address = targetInstr.GetAddress();
				instruction.MemoryDisplacement64 = address;
				encoder.TryEncode(in instruction, IP, out uint _, out string errorMessage);
				if (instruction.IPRelativeMemoryAddress != ((instruction.MemoryBase == Register.EIP) ? ((uint)address) : address))
				{
					errorMessage = "Invalid IP relative address";
				}
				if (errorMessage != null)
				{
					constantOffsets = default(ConstantOffsets);
					return Instr.CreateErrorMessage(errorMessage, in instruction);
				}
				constantOffsets = encoder.GetConstantOffsets();
				return null;
			}
			case InstrKind.Long:
				isOriginalInstruction = false;
				constantOffsets = default(ConstantOffsets);
				return "IP relative memory operand is too far away and isn't currently supported. Try to allocate memory close to the original instruction (+/-2GB).";
			default:
				throw new InvalidOperationException();
			}
		}
	}
	internal sealed class JccInstr : Instr
	{
		private enum InstrKind : byte
		{
			Unchanged,
			Short,
			Near,
			Long,
			Uninitialized
		}

		private readonly byte bitness;

		private Instruction instruction;

		private TargetInstr targetInstr;

		private BlockData pointerData;

		private InstrKind instrKind;

		private readonly byte shortInstructionSize;

		private readonly byte nearInstructionSize;

		private readonly byte longInstructionSize64;

		private static uint GetLongInstructionSize64(in Instruction instruction)
		{
			return 8u;
		}

		public JccInstr(BlockEncoder blockEncoder, Block block, in Instruction instruction)
			: base(block, instruction.IP)
		{
			bitness = (byte)blockEncoder.Bitness;
			this.instruction = instruction;
			instrKind = InstrKind.Uninitialized;
			longInstructionSize64 = (byte)GetLongInstructionSize64(in instruction);
			Instruction instruction2;
			if (!blockEncoder.FixBranches)
			{
				instrKind = InstrKind.Unchanged;
				instruction2 = instruction;
				instruction2.NearBranch64 = 0uL;
				Size = blockEncoder.GetInstructionSize(in instruction2, 0uL);
				return;
			}
			instruction2 = instruction;
			instruction2.InternalSetCodeNoCheck(instruction.Code.ToShortBranch());
			instruction2.NearBranch64 = 0uL;
			shortInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, 0uL);
			instruction2 = instruction;
			instruction2.InternalSetCodeNoCheck(instruction.Code.ToNearBranch());
			instruction2.NearBranch64 = 0uL;
			nearInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, 0uL);
			if (blockEncoder.Bitness == 64)
			{
				Size = Math.Max(nearInstructionSize, longInstructionSize64);
			}
			else
			{
				Size = nearInstructionSize;
			}
		}

		public override void Initialize(BlockEncoder blockEncoder)
		{
			targetInstr = blockEncoder.GetTarget(instruction.NearBranchTarget);
		}

		public override bool Optimize(ulong gained)
		{
			return TryOptimize(gained);
		}

		private bool TryOptimize(ulong gained)
		{
			if (instrKind == InstrKind.Unchanged || instrKind == InstrKind.Short)
			{
				Done = true;
				return false;
			}
			ulong address = targetInstr.GetAddress();
			ulong num = IP + shortInstructionSize;
			long diff = (long)(address - num);
			diff = Instr.ConvertDiffToBitnessDiff(bitness, Instr.CorrectDiff(targetInstr.IsInBlock(Block), diff, gained));
			if (-128 <= diff && diff <= 127)
			{
				if (pointerData != null)
				{
					pointerData.IsValid = false;
				}
				instrKind = InstrKind.Short;
				Size = shortInstructionSize;
				Done = true;
				return true;
			}
			bool flag = bitness != 64 || targetInstr.IsInBlock(Block);
			if (!flag)
			{
				ulong address2 = targetInstr.GetAddress();
				num = IP + nearInstructionSize;
				diff = (long)(address2 - num);
				diff = Instr.ConvertDiffToBitnessDiff(bitness, Instr.CorrectDiff(targetInstr.IsInBlock(Block), diff, gained));
				flag = int.MinValue <= diff && diff <= int.MaxValue;
			}
			if (flag)
			{
				if (pointerData != null)
				{
					pointerData.IsValid = false;
				}
				if (diff < -1920 || diff > 1905)
				{
					Done = true;
				}
				instrKind = InstrKind.Near;
				Size = nearInstructionSize;
				return true;
			}
			if (pointerData == null)
			{
				pointerData = Block.AllocPointerLocation();
			}
			instrKind = InstrKind.Long;
			return false;
		}

		public override string? TryEncode(Encoder encoder, out ConstantOffsets constantOffsets, out bool isOriginalInstruction)
		{
			uint encodedLength2;
			string errorMessage;
			switch (instrKind)
			{
			case InstrKind.Unchanged:
			case InstrKind.Short:
			case InstrKind.Near:
				isOriginalInstruction = true;
				if (instrKind != InstrKind.Unchanged)
				{
					if (instrKind == InstrKind.Short)
					{
						this.instruction.InternalSetCodeNoCheck(this.instruction.Code.ToShortBranch());
					}
					else
					{
						this.instruction.InternalSetCodeNoCheck(this.instruction.Code.ToNearBranch());
					}
				}
				this.instruction.NearBranch64 = targetInstr.GetAddress();
				if (!encoder.TryEncode(in this.instruction, IP, out encodedLength2, out errorMessage))
				{
					constantOffsets = default(ConstantOffsets);
					return Instr.CreateErrorMessage(errorMessage, in this.instruction);
				}
				constantOffsets = encoder.GetConstantOffsets();
				return null;
			case InstrKind.Long:
			{
				isOriginalInstruction = false;
				constantOffsets = default(ConstantOffsets);
				pointerData.Data = targetInstr.GetAddress();
				Instruction instruction = default(Instruction);
				instruction.InternalSetCodeNoCheck(ShortBrToNativeBr(this.instruction.Code.NegateConditionCode().ToShortBranch(), encoder.Bitness));
				if (this.instruction.OpCount == 1)
				{
					instruction.Op0Kind = OpKind.NearBranch64;
					instruction.NearBranch64 = IP + longInstructionSize64;
					if (!encoder.TryEncode(in instruction, IP, out uint encodedLength, out errorMessage))
					{
						return Instr.CreateErrorMessage(errorMessage, in this.instruction);
					}
					errorMessage = EncodeBranchToPointerData(encoder, isCall: false, IP + encodedLength, pointerData, out encodedLength2, Size - encodedLength);
					if (errorMessage != null)
					{
						return Instr.CreateErrorMessage(errorMessage, in this.instruction);
					}
					return null;
				}
				throw new InvalidOperationException();
			}
			default:
				throw new InvalidOperationException();
			}
		}

		private static Code ShortBrToNativeBr(Code code, int bitness)
		{
			Code code2;
			Code code3;
			Code code4;
			switch (code)
			{
			case Code.Jo_rel8_16:
			case Code.Jo_rel8_32:
			case Code.Jo_rel8_64:
				code2 = Code.Jo_rel8_16;
				code3 = Code.Jo_rel8_32;
				code4 = Code.Jo_rel8_64;
				break;
			case Code.Jno_rel8_16:
			case Code.Jno_rel8_32:
			case Code.Jno_rel8_64:
				code2 = Code.Jno_rel8_16;
				code3 = Code.Jno_rel8_32;
				code4 = Code.Jno_rel8_64;
				break;
			case Code.Jb_rel8_16:
			case Code.Jb_rel8_32:
			case Code.Jb_rel8_64:
				code2 = Code.Jb_rel8_16;
				code3 = Code.Jb_rel8_32;
				code4 = Code.Jb_rel8_64;
				break;
			case Code.Jae_rel8_16:
			case Code.Jae_rel8_32:
			case Code.Jae_rel8_64:
				code2 = Code.Jae_rel8_16;
				code3 = Code.Jae_rel8_32;
				code4 = Code.Jae_rel8_64;
				break;
			case Code.Je_rel8_16:
			case Code.Je_rel8_32:
			case Code.Je_rel8_64:
				code2 = Code.Je_rel8_16;
				code3 = Code.Je_rel8_32;
				code4 = Code.Je_rel8_64;
				break;
			case Code.Jne_rel8_16:
			case Code.Jne_rel8_32:
			case Code.Jne_rel8_64:
				code2 = Code.Jne_rel8_16;
				code3 = Code.Jne_rel8_32;
				code4 = Code.Jne_rel8_64;
				break;
			case Code.Jbe_rel8_16:
			case Code.Jbe_rel8_32:
			case Code.Jbe_rel8_64:
				code2 = Code.Jbe_rel8_16;
				code3 = Code.Jbe_rel8_32;
				code4 = Code.Jbe_rel8_64;
				break;
			case Code.Ja_rel8_16:
			case Code.Ja_rel8_32:
			case Code.Ja_rel8_64:
				code2 = Code.Ja_rel8_16;
				code3 = Code.Ja_rel8_32;
				code4 = Code.Ja_rel8_64;
				break;
			case Code.Js_rel8_16:
			case Code.Js_rel8_32:
			case Code.Js_rel8_64:
				code2 = Code.Js_rel8_16;
				code3 = Code.Js_rel8_32;
				code4 = Code.Js_rel8_64;
				break;
			case Code.Jns_rel8_16:
			case Code.Jns_rel8_32:
			case Code.Jns_rel8_64:
				code2 = Code.Jns_rel8_16;
				code3 = Code.Jns_rel8_32;
				code4 = Code.Jns_rel8_64;
				break;
			case Code.Jp_rel8_16:
			case Code.Jp_rel8_32:
			case Code.Jp_rel8_64:
				code2 = Code.Jp_rel8_16;
				code3 = Code.Jp_rel8_32;
				code4 = Code.Jp_rel8_64;
				break;
			case Code.Jnp_rel8_16:
			case Code.Jnp_rel8_32:
			case Code.Jnp_rel8_64:
				code2 = Code.Jnp_rel8_16;
				code3 = Code.Jnp_rel8_32;
				code4 = Code.Jnp_rel8_64;
				break;
			case Code.Jl_rel8_16:
			case Code.Jl_rel8_32:
			case Code.Jl_rel8_64:
				code2 = Code.Jl_rel8_16;
				code3 = Code.Jl_rel8_32;
				code4 = Code.Jl_rel8_64;
				break;
			case Code.Jge_rel8_16:
			case Code.Jge_rel8_32:
			case Code.Jge_rel8_64:
				code2 = Code.Jge_rel8_16;
				code3 = Code.Jge_rel8_32;
				code4 = Code.Jge_rel8_64;
				break;
			case Code.Jle_rel8_16:
			case Code.Jle_rel8_32:
			case Code.Jle_rel8_64:
				code2 = Code.Jle_rel8_16;
				code3 = Code.Jle_rel8_32;
				code4 = Code.Jle_rel8_64;
				break;
			case Code.Jg_rel8_16:
			case Code.Jg_rel8_32:
			case Code.Jg_rel8_64:
				code2 = Code.Jg_rel8_16;
				code3 = Code.Jg_rel8_32;
				code4 = Code.Jg_rel8_64;
				break;
			default:
				throw new ArgumentOutOfRangeException("code");
			}
			return bitness switch
			{
				16 => code2, 
				32 => code3, 
				64 => code4, 
				_ => throw new ArgumentOutOfRangeException("bitness"), 
			};
		}
	}
	internal sealed class JmpInstr : Instr
	{
		private enum InstrKind : byte
		{
			Unchanged,
			Short,
			Near,
			Long,
			Uninitialized
		}

		private readonly byte bitness;

		private Instruction instruction;

		private TargetInstr targetInstr;

		private BlockData pointerData;

		private InstrKind instrKind;

		private readonly byte shortInstructionSize;

		private readonly byte nearInstructionSize;

		public JmpInstr(BlockEncoder blockEncoder, Block block, in Instruction instruction)
			: base(block, instruction.IP)
		{
			bitness = (byte)blockEncoder.Bitness;
			this.instruction = instruction;
			instrKind = InstrKind.Uninitialized;
			Instruction instruction2;
			if (!blockEncoder.FixBranches)
			{
				instrKind = InstrKind.Unchanged;
				instruction2 = instruction;
				instruction2.NearBranch64 = 0uL;
				Size = blockEncoder.GetInstructionSize(in instruction2, 0uL);
				return;
			}
			instruction2 = instruction;
			instruction2.InternalSetCodeNoCheck(instruction.Code.ToShortBranch());
			instruction2.NearBranch64 = 0uL;
			shortInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, 0uL);
			instruction2 = instruction;
			instruction2.InternalSetCodeNoCheck(instruction.Code.ToNearBranch());
			instruction2.NearBranch64 = 0uL;
			nearInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, 0uL);
			if (blockEncoder.Bitness == 64)
			{
				Size = Math.Max(nearInstructionSize, 6u);
			}
			else
			{
				Size = nearInstructionSize;
			}
		}

		public override void Initialize(BlockEncoder blockEncoder)
		{
			targetInstr = blockEncoder.GetTarget(instruction.NearBranchTarget);
		}

		public override bool Optimize(ulong gained)
		{
			return TryOptimize(gained);
		}

		private bool TryOptimize(ulong gained)
		{
			if (instrKind == InstrKind.Unchanged || instrKind == InstrKind.Short)
			{
				Done = true;
				return false;
			}
			ulong address = targetInstr.GetAddress();
			ulong num = IP + shortInstructionSize;
			long diff = (long)(address - num);
			diff = Instr.ConvertDiffToBitnessDiff(bitness, Instr.CorrectDiff(targetInstr.IsInBlock(Block), diff, gained));
			if (-128 <= diff && diff <= 127)
			{
				if (pointerData != null)
				{
					pointerData.IsValid = false;
				}
				instrKind = InstrKind.Short;
				Size = shortInstructionSize;
				Done = true;
				return true;
			}
			bool flag = bitness != 64 || targetInstr.IsInBlock(Block);
			if (!flag)
			{
				ulong address2 = targetInstr.GetAddress();
				num = IP + nearInstructionSize;
				diff = (long)(address2 - num);
				diff = Instr.ConvertDiffToBitnessDiff(bitness, Instr.CorrectDiff(targetInstr.IsInBlock(Block), diff, gained));
				flag = int.MinValue <= diff && diff <= int.MaxValue;
			}
			if (flag)
			{
				if (pointerData != null)
				{
					pointerData.IsValid = false;
				}
				if (diff < -1920 || diff > 1905)
				{
					Done = true;
				}
				instrKind = InstrKind.Near;
				Size = nearInstructionSize;
				return true;
			}
			if (pointerData == null)
			{
				pointerData = Block.AllocPointerLocation();
			}
			instrKind = InstrKind.Long;
			return false;
		}

		public override string? TryEncode(Encoder encoder, out ConstantOffsets constantOffsets, out bool isOriginalInstruction)
		{
			uint encodedLength;
			switch (instrKind)
			{
			case InstrKind.Unchanged:
			case InstrKind.Short:
			case InstrKind.Near:
			{
				isOriginalInstruction = true;
				if (instrKind != InstrKind.Unchanged)
				{
					if (instrKind == InstrKind.Short)
					{
						instruction.InternalSetCodeNoCheck(instruction.Code.ToShortBranch());
					}
					else
					{
						instruction.InternalSetCodeNoCheck(instruction.Code.ToNearBranch());
					}
				}
				instruction.NearBranch64 = targetInstr.GetAddress();
				if (!encoder.TryEncode(in instruction, IP, out encodedLength, out string text))
				{
					constantOffsets = default(ConstantOffsets);
					return Instr.CreateErrorMessage(text, in instruction);
				}
				constantOffsets = encoder.GetConstantOffsets();
				return null;
			}
			case InstrKind.Long:
			{
				isOriginalInstruction = false;
				constantOffsets = default(ConstantOffsets);
				pointerData.Data = targetInstr.GetAddress();
				string text = EncodeBranchToPointerData(encoder, isCall: false, IP, pointerData, out encodedLength, Size);
				if (text != null)
				{
					return Instr.CreateErrorMessage(text, in instruction);
				}
				return null;
			}
			default:
				throw new InvalidOperationException();
			}
		}
	}
	internal sealed class SimpleBranchInstr : Instr
	{
		private enum InstrKind : byte
		{
			Unchanged,
			Short,
			Near,
			Long,
			Uninitialized
		}

		private readonly byte bitness;

		private Instruction instruction;

		private TargetInstr targetInstr;

		private BlockData pointerData;

		private InstrKind instrKind;

		private readonly byte shortInstructionSize;

		private readonly byte nearInstructionSize;

		private readonly byte longInstructionSize;

		private readonly byte nativeInstructionSize;

		private readonly Code nativeCode;

		public SimpleBranchInstr(BlockEncoder blockEncoder, Block block, in Instruction instruction)
			: base(block, instruction.IP)
		{
			bitness = (byte)blockEncoder.Bitness;
			this.instruction = instruction;
			instrKind = InstrKind.Uninitialized;
			Instruction instruction2;
			if (!blockEncoder.FixBranches)
			{
				instrKind = InstrKind.Unchanged;
				instruction2 = instruction;
				instruction2.NearBranch64 = 0uL;
				Size = blockEncoder.GetInstructionSize(in instruction2, 0uL);
				return;
			}
			instruction2 = instruction;
			instruction2.NearBranch64 = 0uL;
			shortInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, 0uL);
			nativeCode = ToNativeBranchCode(instruction.Code, blockEncoder.Bitness);
			if (nativeCode == instruction.Code)
			{
				nativeInstructionSize = shortInstructionSize;
			}
			else
			{
				instruction2 = instruction;
				instruction2.InternalSetCodeNoCheck(nativeCode);
				instruction2.NearBranch64 = 0uL;
				nativeInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, 0uL);
			}
			int num;
			switch (blockEncoder.Bitness)
			{
			case 16:
				num = nativeInstructionSize + 2 + 3;
				break;
			case 32:
			case 64:
				num = nativeInstructionSize + 2 + 5;
				break;
			default:
				throw new InvalidOperationException();
			}
			nearInstructionSize = (byte)num;
			if (blockEncoder.Bitness == 64)
			{
				longInstructionSize = (byte)((ulong)(nativeInstructionSize + 2) + 6uL);
				Size = Math.Max(Math.Max(shortInstructionSize, nearInstructionSize), longInstructionSize);
			}
			else
			{
				Size = Math.Max(shortInstructionSize, nearInstructionSize);
			}
		}

		private static Code ToNativeBranchCode(Code code, int bitness)
		{
			Code code2;
			Code code3;
			Code code4;
			switch (code)
			{
			case Code.Loopne_rel8_16_CX:
			case Code.Loopne_rel8_32_CX:
				code2 = Code.Loopne_rel8_16_CX;
				code3 = Code.Loopne_rel8_32_CX;
				code4 = Code.INVALID;
				break;
			case Code.Loopne_rel8_16_ECX:
			case Code.Loopne_rel8_32_ECX:
			case Code.Loopne_rel8_64_ECX:
				code2 = Code.Loopne_rel8_16_ECX;
				code3 = Code.Loopne_rel8_32_ECX;
				code4 = Code.Loopne_rel8_64_ECX;
				break;
			case Code.Loopne_rel8_16_RCX:
			case Code.Loopne_rel8_64_RCX:
				code2 = Code.Loopne_rel8_16_RCX;
				code3 = Code.INVALID;
				code4 = Code.Loopne_rel8_64_RCX;
				break;
			case Code.Loope_rel8_16_CX:
			case Code.Loope_rel8_32_CX:
				code2 = Code.Loope_rel8_16_CX;
				code3 = Code.Loope_rel8_32_CX;
				code4 = Code.INVALID;
				break;
			case Code.Loope_rel8_16_ECX:
			case Code.Loope_rel8_32_ECX:
			case Code.Loope_rel8_64_ECX:
				code2 = Code.Loope_rel8_16_ECX;
				code3 = Code.Loope_rel8_32_ECX;
				code4 = Code.Loope_rel8_64_ECX;
				break;
			case Code.Loope_rel8_16_RCX:
			case Code.Loope_rel8_64_RCX:
				code2 = Code.Loope_rel8_16_RCX;
				code3 = Code.INVALID;
				code4 = Code.Loope_rel8_64_RCX;
				break;
			case Code.Loop_rel8_16_CX:
			case Code.Loop_rel8_32_CX:
				code2 = Code.Loop_rel8_16_CX;
				code3 = Code.Loop_rel8_32_CX;
				code4 = Code.INVALID;
				break;
			case Code.Loop_rel8_16_ECX:
			case Code.Loop_rel8_32_ECX:
			case Code.Loop_rel8_64_ECX:
				code2 = Code.Loop_rel8_16_ECX;
				code3 = Code.Loop_rel8_32_ECX;
				code4 = Code.Loop_rel8_64_ECX;
				break;
			case Code.Loop_rel8_16_RCX:
			case Code.Loop_rel8_64_RCX:
				code2 = Code.Loop_rel8_16_RCX;
				code3 = Code.INVALID;
				code4 = Code.Loop_rel8_64_RCX;
				break;
			case Code.Jcxz_rel8_16:
			case Code.Jcxz_rel8_32:
				code2 = Code.Jcxz_rel8_16;
				code3 = Code.Jcxz_rel8_32;
				code4 = Code.INVALID;
				break;
			case Code.Jecxz_rel8_16:
			case Code.Jecxz_rel8_32:
			case Code.Jecxz_rel8_64:
				code2 = Code.Jecxz_rel8_16;
				code3 = Code.Jecxz_rel8_32;
				code4 = Code.Jecxz_rel8_64;
				break;
			case Code.Jrcxz_rel8_16:
			case Code.Jrcxz_rel8_64:
				code2 = Code.Jrcxz_rel8_16;
				code3 = Code.INVALID;
				code4 = Code.Jrcxz_rel8_64;
				break;
			default:
				throw new ArgumentOutOfRangeException("code");
			}
			return bitness switch
			{
				16 => code2, 
				32 => code3, 
				64 => code4, 
				_ => throw new ArgumentOutOfRangeException("bitness"), 
			};
		}

		public override void Initialize(BlockEncoder blockEncoder)
		{
			targetInstr = blockEncoder.GetTarget(instruction.NearBranchTarget);
		}

		public override bool Optimize(ulong gained)
		{
			return TryOptimize(gained);
		}

		private bool TryOptimize(ulong gained)
		{
			if (instrKind == InstrKind.Unchanged || instrKind == InstrKind.Short)
			{
				Done = true;
				return false;
			}
			ulong address = targetInstr.GetAddress();
			ulong num = IP + shortInstructionSize;
			long diff = (long)(address - num);
			diff = Instr.ConvertDiffToBitnessDiff(bitness, Instr.CorrectDiff(targetInstr.IsInBlock(Block), diff, gained));
			if (-128 <= diff && diff <= 127)
			{
				if (pointerData != null)
				{
					pointerData.IsValid = false;
				}
				instrKind = InstrKind.Short;
				Size = shortInstructionSize;
				Done = true;
				return true;
			}
			bool flag = bitness != 64 || targetInstr.IsInBlock(Block);
			if (!flag)
			{
				ulong address2 = targetInstr.GetAddress();
				num = IP + nearInstructionSize;
				diff = (long)(address2 - num);
				diff = Instr.ConvertDiffToBitnessDiff(bitness, Instr.CorrectDiff(targetInstr.IsInBlock(Block), diff, gained));
				flag = int.MinValue <= diff && diff <= int.MaxValue;
			}
			if (flag)
			{
				if (pointerData != null)
				{
					pointerData.IsValid = false;
				}
				if (diff < -1920 || diff > 1905)
				{
					Done = true;
				}
				instrKind = InstrKind.Near;
				Size = nearInstructionSize;
				return true;
			}
			if (pointerData == null)
			{
				pointerData = Block.AllocPointerLocation();
			}
			instrKind = InstrKind.Long;
			return false;
		}

		public override string? TryEncode(Encoder encoder, out ConstantOffsets constantOffsets, out bool isOriginalInstruction)
		{
			uint encodedLength2;
			uint encodedLength;
			string errorMessage;
			switch (instrKind)
			{
			case InstrKind.Unchanged:
			case InstrKind.Short:
				isOriginalInstruction = true;
				this.instruction.NearBranch64 = targetInstr.GetAddress();
				if (!encoder.TryEncode(in this.instruction, IP, out encodedLength2, out errorMessage))
				{
					constantOffsets = default(ConstantOffsets);
					return Instr.CreateErrorMessage(errorMessage, in this.instruction);
				}
				constantOffsets = encoder.GetConstantOffsets();
				return null;
			case InstrKind.Near:
			{
				isOriginalInstruction = false;
				constantOffsets = default(ConstantOffsets);
				Instruction instruction = this.instruction;
				instruction.InternalSetCodeNoCheck(nativeCode);
				instruction.NearBranch64 = IP + nativeInstructionSize + 2;
				if (!encoder.TryEncode(in instruction, IP, out uint num, out errorMessage))
				{
					return Instr.CreateErrorMessage(errorMessage, in this.instruction);
				}
				instruction = new Instruction
				{
					NearBranch64 = IP + nearInstructionSize
				};
				Code code;
				switch (encoder.Bitness)
				{
				case 16:
					instruction.InternalSetCodeNoCheck(Code.Jmp_rel8_16);
					code = Code.Jmp_rel16;
					instruction.Op0Kind = OpKind.NearBranch16;
					break;
				case 32:
					instruction.InternalSetCodeNoCheck(Code.Jmp_rel8_32);
					code = Code.Jmp_rel32_32;
					instruction.Op0Kind = OpKind.NearBranch32;
					break;
				case 64:
					instruction.InternalSetCodeNoCheck(Code.Jmp_rel8_64);
					code = Code.Jmp_rel32_64;
					instruction.Op0Kind = OpKind.NearBranch64;
					break;
				default:
					throw new InvalidOperationException();
				}
				if (!encoder.TryEncode(in instruction, IP + num, out encodedLength, out errorMessage))
				{
					return Instr.CreateErrorMessage(errorMessage, in this.instruction);
				}
				num += encodedLength;
				instruction.InternalSetCodeNoCheck(code);
				instruction.NearBranch64 = targetInstr.GetAddress();
				encoder.TryEncode(in instruction, IP + num, out encodedLength, out errorMessage);
				if (errorMessage != null)
				{
					return Instr.CreateErrorMessage(errorMessage, in this.instruction);
				}
				return null;
			}
			case InstrKind.Long:
			{
				isOriginalInstruction = false;
				constantOffsets = default(ConstantOffsets);
				pointerData.Data = targetInstr.GetAddress();
				Instruction instruction = this.instruction;
				instruction.InternalSetCodeNoCheck(nativeCode);
				instruction.NearBranch64 = IP + nativeInstructionSize + 2;
				if (!encoder.TryEncode(in instruction, IP, out encodedLength, out errorMessage))
				{
					return Instr.CreateErrorMessage(errorMessage, in this.instruction);
				}
				uint num = encodedLength;
				instruction = new Instruction
				{
					NearBranch64 = IP + longInstructionSize
				};
				switch (encoder.Bitness)
				{
				case 16:
					instruction.InternalSetCodeNoCheck(Code.Jmp_rel8_16);
					instruction.Op0Kind = OpKind.NearBranch16;
					break;
				case 32:
					instruction.InternalSetCodeNoCheck(Code.Jmp_rel8_32);
					instruction.Op0Kind = OpKind.NearBranch32;
					break;
				case 64:
					instruction.InternalSetCodeNoCheck(Code.Jmp_rel8_64);
					instruction.Op0Kind = OpKind.NearBranch64;
					break;
				default:
					throw new InvalidOperationException();
				}
				if (!encoder.TryEncode(in instruction, IP + num, out encodedLength, out errorMessage))
				{
					return Instr.CreateErrorMessage(errorMessage, in this.instruction);
				}
				num += encodedLength;
				errorMessage = EncodeBranchToPointerData(encoder, isCall: false, IP + num, pointerData, out encodedLength2, Size - num);
				if (errorMessage != null)
				{
					return Instr.CreateErrorMessage(errorMessage, in this.instruction);
				}
				return null;
			}
			default:
				throw new InvalidOperationException();
			}
		}
	}
	internal sealed class SimpleInstr : Instr
	{
		private Instruction instruction;

		public SimpleInstr(BlockEncoder blockEncoder, Block block, in Instruction instruction)
			: base(block, instruction.IP)
		{
			Done = true;
			this.instruction = instruction;
			Size = blockEncoder.GetInstructionSize(in instruction, instruction.IP);
		}

		public override void Initialize(BlockEncoder blockEncoder)
		{
		}

		public override bool Optimize(ulong gained)
		{
			return false;
		}

		public override string? TryEncode(Encoder encoder, out ConstantOffsets constantOffsets, out bool isOriginalInstruction)
		{
			isOriginalInstruction = true;
			if (!encoder.TryEncode(in instruction, IP, out uint _, out string errorMessage))
			{
				constantOffsets = default(ConstantOffsets);
				return Instr.CreateErrorMessage(errorMessage, in instruction);
			}
			constantOffsets = encoder.GetConstantOffsets();
			return null;
		}
	}
	internal readonly struct TargetInstr
	{
		private readonly Instr instruction;

		private readonly ulong address;

		public TargetInstr(Instr instruction)
		{
			this.instruction = instruction;
			address = 0uL;
		}

		public TargetInstr(ulong address)
		{
			instruction = null;
			this.address = address;
		}

		public bool IsInBlock(Block block)
		{
			return instruction?.Block == block;
		}

		public ulong GetAddress()
		{
			return instruction?.IP ?? address;
		}
	}
	internal sealed class XbeginInstr : Instr
	{
		private enum InstrKind : byte
		{
			Unchanged,
			Rel16,
			Rel32,
			Uninitialized
		}

		private Instruction instruction;

		private TargetInstr targetInstr;

		private InstrKind instrKind;

		private readonly byte shortInstructionSize;

		private readonly byte nearInstructionSize;

		public XbeginInstr(BlockEncoder blockEncoder, Block block, in Instruction instruction)
			: base(block, instruction.IP)
		{
			this.instruction = instruction;
			instrKind = InstrKind.Uninitialized;
			Instruction instruction2;
			if (!blockEncoder.FixBranches)
			{
				instrKind = InstrKind.Unchanged;
				instruction2 = instruction;
				instruction2.NearBranch64 = 0uL;
				Size = blockEncoder.GetInstructionSize(in instruction2, 0uL);
				return;
			}
			instruction2 = instruction;
			instruction2.InternalSetCodeNoCheck(Code.Xbegin_rel16);
			instruction2.NearBranch64 = 0uL;
			shortInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, 0uL);
			instruction2 = instruction;
			instruction2.InternalSetCodeNoCheck(Code.Xbegin_rel32);
			instruction2.NearBranch64 = 0uL;
			nearInstructionSize = (byte)blockEncoder.GetInstructionSize(in instruction2, 0uL);
			Size = nearInstructionSize;
		}

		public override void Initialize(BlockEncoder blockEncoder)
		{
			targetInstr = blockEncoder.GetTarget(instruction.NearBranchTarget);
		}

		public override bool Optimize(ulong gained)
		{
			return TryOptimize(gained);
		}

		private bool TryOptimize(ulong gained)
		{
			if (instrKind == InstrKind.Unchanged || instrKind == InstrKind.Rel16)
			{
				Done = true;
				return false;
			}
			ulong address = targetInstr.GetAddress();
			ulong num = IP + shortInstructionSize;
			long diff = (long)(address - num);
			diff = Instr.CorrectDiff(targetInstr.IsInBlock(Block), diff, gained);
			if (-32768 <= diff && diff <= 32767)
			{
				instrKind = InstrKind.Rel16;
				Size = shortInstructionSize;
				return true;
			}
			instrKind = InstrKind.Rel32;
			Size = nearInstructionSize;
			return false;
		}

		public override string? TryEncode(Encoder encoder, out ConstantOffsets constantOffsets, out bool isOriginalInstruction)
		{
			switch (instrKind)
			{
			case InstrKind.Unchanged:
			case InstrKind.Rel16:
			case InstrKind.Rel32:
			{
				isOriginalInstruction = true;
				if (instrKind != InstrKind.Unchanged)
				{
					if (instrKind == InstrKind.Rel16)
					{
						instruction.InternalSetCodeNoCheck(Code.Xbegin_rel16);
					}
					else
					{
						instruction.InternalSetCodeNoCheck(Code.Xbegin_rel32);
					}
				}
				instruction.NearBranch64 = targetInstr.GetAddress();
				if (!encoder.TryEncode(in instruction, IP, out uint _, out string errorMessage))
				{
					constantOffsets = default(ConstantOffsets);
					return Instr.CreateErrorMessage(errorMessage, in instruction);
				}
				constantOffsets = encoder.GetConstantOffsets();
				return null;
			}
			default:
				throw new InvalidOperationException();
			}
		}
	}
}
namespace System
{
	internal static class Array2
	{
		private static class EmptyClass<T>
		{
			public static readonly T[] Empty = new T[0];
		}

		public static T[] Empty<T>()
		{
			return EmptyClass<T>.Empty;
		}
	}
	internal static class string2
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNullOrEmpty([NotNullWhen(false)] string? value)
		{
			return string.IsNullOrEmpty(value);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal static class IsExternalInit
	{
	}
}
namespace System.Diagnostics
{
	internal static class Debug2
	{
		[Conditional("DEBUG")]
		public static void Assert([DoesNotReturnIf(false)] bool condition)
		{
		}
	}
}