diff --git a/src/csharp/Intel/Generator/Decoder/Java/EnumHashTableGen.cs b/src/csharp/Intel/Generator/Decoder/Java/EnumHashTableGen.cs new file mode 100644 index 000000000..fb7313075 --- /dev/null +++ b/src/csharp/Intel/Generator/Decoder/Java/EnumHashTableGen.cs @@ -0,0 +1,146 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +using System; +using System.Linq; +using Generator.Enums; +using Generator.IO; + +namespace Generator.Decoder.Java { + [Generator(TargetLanguage.Java)] + sealed class EnumHashTableGen { + readonly IdentifierConverter idConverter; + readonly GeneratorContext generatorContext; + + public EnumHashTableGen(GeneratorContext generatorContext) { + idConverter = JavaIdentifierConverter.Create(); + this.generatorContext = generatorContext; + } + + public void Generate() { + var genTypes = generatorContext.Types; + var infos = new (EnumType enumType, bool lowerCase, string enumPackage, string name)[] { + (genTypes[TypeIds.Code], false, JavaConstants.IcedPackage, "Code"), + (genTypes[TypeIds.CpuidFeature], false, JavaConstants.IcedPackage, "CpuidFeature"), + (genTypes[TypeIds.DecoderError], false, JavaConstants.DecoderPackage, "DecoderError"), + (genTypes[TypeIds.DecoderOptions], false, JavaConstants.DecoderPackage, "DecoderOptions"), + (genTypes[TypeIds.EncodingKind], false, JavaConstants.IcedPackage, "EncodingKind"), + (genTypes[TypeIds.FlowControl], false, JavaConstants.IcedPackage, "FlowControl"), + (genTypes[TypeIds.MemorySize], false, JavaConstants.IcedPackage, "MemorySize"), + (genTypes[TypeIds.Mnemonic], false, JavaConstants.IcedPackage, "Mnemonic"), + (genTypes[TypeIds.OpCodeOperandKind], false, JavaConstants.InstructionInfoPackage, "OpCodeOperandKind"), + (genTypes[TypeIds.Register], true, JavaConstants.IcedPackage, "Register"), + (genTypes[TypeIds.TupleType], false, JavaConstants.IcedPackage, "TupleType"), + (genTypes[TypeIds.ConditionCode], false, JavaConstants.IcedPackage, "ConditionCode"), + (genTypes[TypeIds.MemorySizeOptions], false, JavaConstants.FormatterPackage, "MemorySizeOptions"), + (genTypes[TypeIds.NumberBase], false, JavaConstants.FormatterPackage, "NumberBase"), + (genTypes[TypeIds.OptionsProps], false, JavaConstants.FormatterPackage, "OptionsProps"), + (genTypes[TypeIds.CC_b], false, JavaConstants.FormatterPackage, "CC_b"), + (genTypes[TypeIds.CC_ae], false, JavaConstants.FormatterPackage, "CC_ae"), + (genTypes[TypeIds.CC_e], false, JavaConstants.FormatterPackage, "CC_e"), + (genTypes[TypeIds.CC_ne], false, JavaConstants.FormatterPackage, "CC_ne"), + (genTypes[TypeIds.CC_be], false, JavaConstants.FormatterPackage, "CC_be"), + (genTypes[TypeIds.CC_a], false, JavaConstants.FormatterPackage, "CC_a"), + (genTypes[TypeIds.CC_p], false, JavaConstants.FormatterPackage, "CC_p"), + (genTypes[TypeIds.CC_np], false, JavaConstants.FormatterPackage, "CC_np"), + (genTypes[TypeIds.CC_l], false, JavaConstants.FormatterPackage, "CC_l"), + (genTypes[TypeIds.CC_ge], false, JavaConstants.FormatterPackage, "CC_ge"), + (genTypes[TypeIds.CC_le], false, JavaConstants.FormatterPackage, "CC_le"), + (genTypes[TypeIds.CC_g], false, JavaConstants.FormatterPackage, "CC_g"), + (genTypes[TypeIds.MvexConvFn], false, JavaConstants.IcedPackage, "MvexConvFn"), + (genTypes[TypeIds.MvexTupleTypeLutKind], false, JavaConstants.IcedPackage, "MvexTupleTypeLutKind"), + }; + foreach (var info in infos) { + // Java method byte code limitations + const int maxVariantsPerMethod = 500; + + var className = "To" + info.name; + var filename = JavaConstants.GetTestFilename(genTypes, JavaConstants.IcedPackage, className + ".java"); + using (var writer = new FileWriter(TargetLanguage.Java, FileUtils.OpenWrite(filename))) { + writer.WriteFileHeader(); + writer.WriteLine($"package {JavaConstants.IcedPackage};"); + writer.WriteLine(); + writer.WriteLine("import java.util.HashMap;"); + writer.WriteLine("import java.util.Iterator;"); + if (info.enumPackage != JavaConstants.IcedPackage) { + writer.WriteLine(); + writer.WriteLine($"import {info.enumPackage}.{info.name};"); + } + writer.WriteLine(); + writer.WriteLine($"public final class {className} {{"); + using (writer.Indent()) { + var enumValues = info.enumType.Values. + Where(a => !a.DeprecatedInfo.IsDeprecatedAndRenamed && + !(a.DeprecatedInfo.IsDeprecated && a.DeprecatedInfo.IsError)).ToArray(); + writer.WriteLine("static Integer tryGet(String key) {"); + using (writer.Indent()) + writer.WriteLine("return map.get(key);"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("static Integer get(String key) {"); + using (writer.Indent()) { + writer.WriteLine("Integer value = tryGet(key);"); + writer.WriteLine("if (value == null)"); + using (writer.Indent()) + writer.WriteLine($"throw new UnsupportedOperationException(String.format(\"Couldn't find enum variant {info.name}.%s\", key));"); + writer.WriteLine("return value;"); + } + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("static Iterator names() {"); + using (writer.Indent()) + writer.WriteLine("return map.keySet().iterator();"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("static Iterator values() {"); + using (writer.Indent()) + writer.WriteLine("return map.values().iterator();"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("static int size() {"); + using (writer.Indent()) + writer.WriteLine("return map.size();"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("static HashMap copy() {"); + using (writer.Indent()) + writer.WriteLine("return new HashMap(map);"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("private static final HashMap map = getMap();"); + writer.WriteLine(); + int variantMethods = (info.enumType.Values.Length + maxVariantsPerMethod - 1) / maxVariantsPerMethod; + writer.WriteLine("private static HashMap getMap() {"); + using (writer.Indent()) { + writer.WriteLine($"HashMap map = new HashMap({enumValues.Length});"); + for (int i = 0; i < variantMethods; i++) + writer.WriteLine($"initMap{i}(map);"); + writer.WriteLine("return map;"); + } + writer.WriteLine("}"); + for (int i = 0; i < variantMethods; i++) { + writer.WriteLine(); + int start = i * maxVariantsPerMethod; + int end = Math.Min(start + maxVariantsPerMethod, enumValues.Length); + bool anyDeprec = enumValues.Skip(start).Take(end - start).Any(a => a.DeprecatedInfo.IsDeprecated); + if (anyDeprec) + writer.WriteLine("@SuppressWarnings(\"deprecation\")"); + writer.WriteLine($"private static void initMap{i}(HashMap map) {{"); + using (writer.Indent()) { + for (int j = start; j < end; j++) { + var value = enumValues[j]; + var key = value.RawName; + if (info.lowerCase) + key = key.ToLowerInvariant(); + writer.WriteLine($"map.put(\"{key}\", {idConverter.ToDeclTypeAndValue(value)});"); + } + } + writer.WriteLine("}"); + } + } + writer.WriteLine("}"); + } + } + } + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_a.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_a.java new file mode 100644 index 000000000..034a97cfa --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_a.java @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_a; + +public final class ToCC_a { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_a.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(2); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("a", CC_a.A); + map.put("nbe", CC_a.NBE); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_ae.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_ae.java new file mode 100644 index 000000000..10ba3e238 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_ae.java @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_ae; + +public final class ToCC_ae { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_ae.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(3); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("ae", CC_ae.AE); + map.put("nb", CC_ae.NB); + map.put("nc", CC_ae.NC); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_b.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_b.java new file mode 100644 index 000000000..a215b3db2 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_b.java @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_b; + +public final class ToCC_b { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_b.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(3); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("b", CC_b.B); + map.put("c", CC_b.C); + map.put("nae", CC_b.NAE); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_be.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_be.java new file mode 100644 index 000000000..56fbd5041 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_be.java @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_be; + +public final class ToCC_be { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_be.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(2); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("be", CC_be.BE); + map.put("na", CC_be.NA); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_e.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_e.java new file mode 100644 index 000000000..3404585fb --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_e.java @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_e; + +public final class ToCC_e { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_e.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(2); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("e", CC_e.E); + map.put("z", CC_e.Z); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_g.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_g.java new file mode 100644 index 000000000..67ed9eeea --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_g.java @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_g; + +public final class ToCC_g { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_g.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(2); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("g", CC_g.G); + map.put("nle", CC_g.NLE); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_ge.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_ge.java new file mode 100644 index 000000000..5fea55a20 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_ge.java @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_ge; + +public final class ToCC_ge { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_ge.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(2); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("ge", CC_ge.GE); + map.put("nl", CC_ge.NL); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_l.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_l.java new file mode 100644 index 000000000..19456235b --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_l.java @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_l; + +public final class ToCC_l { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_l.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(2); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("l", CC_l.L); + map.put("nge", CC_l.NGE); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_le.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_le.java new file mode 100644 index 000000000..de9a89129 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_le.java @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_le; + +public final class ToCC_le { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_le.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(2); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("le", CC_le.LE); + map.put("ng", CC_le.NG); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_ne.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_ne.java new file mode 100644 index 000000000..a138ee184 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_ne.java @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_ne; + +public final class ToCC_ne { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_ne.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(2); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("ne", CC_ne.NE); + map.put("nz", CC_ne.NZ); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_np.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_np.java new file mode 100644 index 000000000..51467d128 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_np.java @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_np; + +public final class ToCC_np { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_np.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(2); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("np", CC_np.NP); + map.put("po", CC_np.PO); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_p.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_p.java new file mode 100644 index 000000000..62135154b --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCC_p.java @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.CC_p; + +public final class ToCC_p { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CC_p.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(2); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("p", CC_p.P); + map.put("pe", CC_p.PE); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCode.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCode.java new file mode 100644 index 000000000..e3c196062 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCode.java @@ -0,0 +1,4919 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToCode { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant Code.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(4834); + initMap0(map); + initMap1(map); + initMap2(map); + initMap3(map); + initMap4(map); + initMap5(map); + initMap6(map); + initMap7(map); + initMap8(map); + initMap9(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("INVALID", Code.INVALID); + map.put("DeclareByte", Code.DECLAREBYTE); + map.put("DeclareWord", Code.DECLAREWORD); + map.put("DeclareDword", Code.DECLAREDWORD); + map.put("DeclareQword", Code.DECLAREQWORD); + map.put("Add_rm8_r8", Code.ADD_RM8_R8); + map.put("Add_rm16_r16", Code.ADD_RM16_R16); + map.put("Add_rm32_r32", Code.ADD_RM32_R32); + map.put("Add_rm64_r64", Code.ADD_RM64_R64); + map.put("Add_r8_rm8", Code.ADD_R8_RM8); + map.put("Add_r16_rm16", Code.ADD_R16_RM16); + map.put("Add_r32_rm32", Code.ADD_R32_RM32); + map.put("Add_r64_rm64", Code.ADD_R64_RM64); + map.put("Add_AL_imm8", Code.ADD_AL_IMM8); + map.put("Add_AX_imm16", Code.ADD_AX_IMM16); + map.put("Add_EAX_imm32", Code.ADD_EAX_IMM32); + map.put("Add_RAX_imm32", Code.ADD_RAX_IMM32); + map.put("Pushw_ES", Code.PUSHW_ES); + map.put("Pushd_ES", Code.PUSHD_ES); + map.put("Popw_ES", Code.POPW_ES); + map.put("Popd_ES", Code.POPD_ES); + map.put("Or_rm8_r8", Code.OR_RM8_R8); + map.put("Or_rm16_r16", Code.OR_RM16_R16); + map.put("Or_rm32_r32", Code.OR_RM32_R32); + map.put("Or_rm64_r64", Code.OR_RM64_R64); + map.put("Or_r8_rm8", Code.OR_R8_RM8); + map.put("Or_r16_rm16", Code.OR_R16_RM16); + map.put("Or_r32_rm32", Code.OR_R32_RM32); + map.put("Or_r64_rm64", Code.OR_R64_RM64); + map.put("Or_AL_imm8", Code.OR_AL_IMM8); + map.put("Or_AX_imm16", Code.OR_AX_IMM16); + map.put("Or_EAX_imm32", Code.OR_EAX_IMM32); + map.put("Or_RAX_imm32", Code.OR_RAX_IMM32); + map.put("Pushw_CS", Code.PUSHW_CS); + map.put("Pushd_CS", Code.PUSHD_CS); + map.put("Popw_CS", Code.POPW_CS); + map.put("Adc_rm8_r8", Code.ADC_RM8_R8); + map.put("Adc_rm16_r16", Code.ADC_RM16_R16); + map.put("Adc_rm32_r32", Code.ADC_RM32_R32); + map.put("Adc_rm64_r64", Code.ADC_RM64_R64); + map.put("Adc_r8_rm8", Code.ADC_R8_RM8); + map.put("Adc_r16_rm16", Code.ADC_R16_RM16); + map.put("Adc_r32_rm32", Code.ADC_R32_RM32); + map.put("Adc_r64_rm64", Code.ADC_R64_RM64); + map.put("Adc_AL_imm8", Code.ADC_AL_IMM8); + map.put("Adc_AX_imm16", Code.ADC_AX_IMM16); + map.put("Adc_EAX_imm32", Code.ADC_EAX_IMM32); + map.put("Adc_RAX_imm32", Code.ADC_RAX_IMM32); + map.put("Pushw_SS", Code.PUSHW_SS); + map.put("Pushd_SS", Code.PUSHD_SS); + map.put("Popw_SS", Code.POPW_SS); + map.put("Popd_SS", Code.POPD_SS); + map.put("Sbb_rm8_r8", Code.SBB_RM8_R8); + map.put("Sbb_rm16_r16", Code.SBB_RM16_R16); + map.put("Sbb_rm32_r32", Code.SBB_RM32_R32); + map.put("Sbb_rm64_r64", Code.SBB_RM64_R64); + map.put("Sbb_r8_rm8", Code.SBB_R8_RM8); + map.put("Sbb_r16_rm16", Code.SBB_R16_RM16); + map.put("Sbb_r32_rm32", Code.SBB_R32_RM32); + map.put("Sbb_r64_rm64", Code.SBB_R64_RM64); + map.put("Sbb_AL_imm8", Code.SBB_AL_IMM8); + map.put("Sbb_AX_imm16", Code.SBB_AX_IMM16); + map.put("Sbb_EAX_imm32", Code.SBB_EAX_IMM32); + map.put("Sbb_RAX_imm32", Code.SBB_RAX_IMM32); + map.put("Pushw_DS", Code.PUSHW_DS); + map.put("Pushd_DS", Code.PUSHD_DS); + map.put("Popw_DS", Code.POPW_DS); + map.put("Popd_DS", Code.POPD_DS); + map.put("And_rm8_r8", Code.AND_RM8_R8); + map.put("And_rm16_r16", Code.AND_RM16_R16); + map.put("And_rm32_r32", Code.AND_RM32_R32); + map.put("And_rm64_r64", Code.AND_RM64_R64); + map.put("And_r8_rm8", Code.AND_R8_RM8); + map.put("And_r16_rm16", Code.AND_R16_RM16); + map.put("And_r32_rm32", Code.AND_R32_RM32); + map.put("And_r64_rm64", Code.AND_R64_RM64); + map.put("And_AL_imm8", Code.AND_AL_IMM8); + map.put("And_AX_imm16", Code.AND_AX_IMM16); + map.put("And_EAX_imm32", Code.AND_EAX_IMM32); + map.put("And_RAX_imm32", Code.AND_RAX_IMM32); + map.put("Daa", Code.DAA); + map.put("Sub_rm8_r8", Code.SUB_RM8_R8); + map.put("Sub_rm16_r16", Code.SUB_RM16_R16); + map.put("Sub_rm32_r32", Code.SUB_RM32_R32); + map.put("Sub_rm64_r64", Code.SUB_RM64_R64); + map.put("Sub_r8_rm8", Code.SUB_R8_RM8); + map.put("Sub_r16_rm16", Code.SUB_R16_RM16); + map.put("Sub_r32_rm32", Code.SUB_R32_RM32); + map.put("Sub_r64_rm64", Code.SUB_R64_RM64); + map.put("Sub_AL_imm8", Code.SUB_AL_IMM8); + map.put("Sub_AX_imm16", Code.SUB_AX_IMM16); + map.put("Sub_EAX_imm32", Code.SUB_EAX_IMM32); + map.put("Sub_RAX_imm32", Code.SUB_RAX_IMM32); + map.put("Das", Code.DAS); + map.put("Xor_rm8_r8", Code.XOR_RM8_R8); + map.put("Xor_rm16_r16", Code.XOR_RM16_R16); + map.put("Xor_rm32_r32", Code.XOR_RM32_R32); + map.put("Xor_rm64_r64", Code.XOR_RM64_R64); + map.put("Xor_r8_rm8", Code.XOR_R8_RM8); + map.put("Xor_r16_rm16", Code.XOR_R16_RM16); + map.put("Xor_r32_rm32", Code.XOR_R32_RM32); + map.put("Xor_r64_rm64", Code.XOR_R64_RM64); + map.put("Xor_AL_imm8", Code.XOR_AL_IMM8); + map.put("Xor_AX_imm16", Code.XOR_AX_IMM16); + map.put("Xor_EAX_imm32", Code.XOR_EAX_IMM32); + map.put("Xor_RAX_imm32", Code.XOR_RAX_IMM32); + map.put("Aaa", Code.AAA); + map.put("Cmp_rm8_r8", Code.CMP_RM8_R8); + map.put("Cmp_rm16_r16", Code.CMP_RM16_R16); + map.put("Cmp_rm32_r32", Code.CMP_RM32_R32); + map.put("Cmp_rm64_r64", Code.CMP_RM64_R64); + map.put("Cmp_r8_rm8", Code.CMP_R8_RM8); + map.put("Cmp_r16_rm16", Code.CMP_R16_RM16); + map.put("Cmp_r32_rm32", Code.CMP_R32_RM32); + map.put("Cmp_r64_rm64", Code.CMP_R64_RM64); + map.put("Cmp_AL_imm8", Code.CMP_AL_IMM8); + map.put("Cmp_AX_imm16", Code.CMP_AX_IMM16); + map.put("Cmp_EAX_imm32", Code.CMP_EAX_IMM32); + map.put("Cmp_RAX_imm32", Code.CMP_RAX_IMM32); + map.put("Aas", Code.AAS); + map.put("Inc_r16", Code.INC_R16); + map.put("Inc_r32", Code.INC_R32); + map.put("Dec_r16", Code.DEC_R16); + map.put("Dec_r32", Code.DEC_R32); + map.put("Push_r16", Code.PUSH_R16); + map.put("Push_r32", Code.PUSH_R32); + map.put("Push_r64", Code.PUSH_R64); + map.put("Pop_r16", Code.POP_R16); + map.put("Pop_r32", Code.POP_R32); + map.put("Pop_r64", Code.POP_R64); + map.put("Pushaw", Code.PUSHAW); + map.put("Pushad", Code.PUSHAD); + map.put("Popaw", Code.POPAW); + map.put("Popad", Code.POPAD); + map.put("Bound_r16_m1616", Code.BOUND_R16_M1616); + map.put("Bound_r32_m3232", Code.BOUND_R32_M3232); + map.put("Arpl_rm16_r16", Code.ARPL_RM16_R16); + map.put("Arpl_r32m16_r32", Code.ARPL_R32M16_R32); + map.put("Movsxd_r16_rm16", Code.MOVSXD_R16_RM16); + map.put("Movsxd_r32_rm32", Code.MOVSXD_R32_RM32); + map.put("Movsxd_r64_rm32", Code.MOVSXD_R64_RM32); + map.put("Push_imm16", Code.PUSH_IMM16); + map.put("Pushd_imm32", Code.PUSHD_IMM32); + map.put("Pushq_imm32", Code.PUSHQ_IMM32); + map.put("Imul_r16_rm16_imm16", Code.IMUL_R16_RM16_IMM16); + map.put("Imul_r32_rm32_imm32", Code.IMUL_R32_RM32_IMM32); + map.put("Imul_r64_rm64_imm32", Code.IMUL_R64_RM64_IMM32); + map.put("Pushw_imm8", Code.PUSHW_IMM8); + map.put("Pushd_imm8", Code.PUSHD_IMM8); + map.put("Pushq_imm8", Code.PUSHQ_IMM8); + map.put("Imul_r16_rm16_imm8", Code.IMUL_R16_RM16_IMM8); + map.put("Imul_r32_rm32_imm8", Code.IMUL_R32_RM32_IMM8); + map.put("Imul_r64_rm64_imm8", Code.IMUL_R64_RM64_IMM8); + map.put("Insb_m8_DX", Code.INSB_M8_DX); + map.put("Insw_m16_DX", Code.INSW_M16_DX); + map.put("Insd_m32_DX", Code.INSD_M32_DX); + map.put("Outsb_DX_m8", Code.OUTSB_DX_M8); + map.put("Outsw_DX_m16", Code.OUTSW_DX_M16); + map.put("Outsd_DX_m32", Code.OUTSD_DX_M32); + map.put("Jo_rel8_16", Code.JO_REL8_16); + map.put("Jo_rel8_32", Code.JO_REL8_32); + map.put("Jo_rel8_64", Code.JO_REL8_64); + map.put("Jno_rel8_16", Code.JNO_REL8_16); + map.put("Jno_rel8_32", Code.JNO_REL8_32); + map.put("Jno_rel8_64", Code.JNO_REL8_64); + map.put("Jb_rel8_16", Code.JB_REL8_16); + map.put("Jb_rel8_32", Code.JB_REL8_32); + map.put("Jb_rel8_64", Code.JB_REL8_64); + map.put("Jae_rel8_16", Code.JAE_REL8_16); + map.put("Jae_rel8_32", Code.JAE_REL8_32); + map.put("Jae_rel8_64", Code.JAE_REL8_64); + map.put("Je_rel8_16", Code.JE_REL8_16); + map.put("Je_rel8_32", Code.JE_REL8_32); + map.put("Je_rel8_64", Code.JE_REL8_64); + map.put("Jne_rel8_16", Code.JNE_REL8_16); + map.put("Jne_rel8_32", Code.JNE_REL8_32); + map.put("Jne_rel8_64", Code.JNE_REL8_64); + map.put("Jbe_rel8_16", Code.JBE_REL8_16); + map.put("Jbe_rel8_32", Code.JBE_REL8_32); + map.put("Jbe_rel8_64", Code.JBE_REL8_64); + map.put("Ja_rel8_16", Code.JA_REL8_16); + map.put("Ja_rel8_32", Code.JA_REL8_32); + map.put("Ja_rel8_64", Code.JA_REL8_64); + map.put("Js_rel8_16", Code.JS_REL8_16); + map.put("Js_rel8_32", Code.JS_REL8_32); + map.put("Js_rel8_64", Code.JS_REL8_64); + map.put("Jns_rel8_16", Code.JNS_REL8_16); + map.put("Jns_rel8_32", Code.JNS_REL8_32); + map.put("Jns_rel8_64", Code.JNS_REL8_64); + map.put("Jp_rel8_16", Code.JP_REL8_16); + map.put("Jp_rel8_32", Code.JP_REL8_32); + map.put("Jp_rel8_64", Code.JP_REL8_64); + map.put("Jnp_rel8_16", Code.JNP_REL8_16); + map.put("Jnp_rel8_32", Code.JNP_REL8_32); + map.put("Jnp_rel8_64", Code.JNP_REL8_64); + map.put("Jl_rel8_16", Code.JL_REL8_16); + map.put("Jl_rel8_32", Code.JL_REL8_32); + map.put("Jl_rel8_64", Code.JL_REL8_64); + map.put("Jge_rel8_16", Code.JGE_REL8_16); + map.put("Jge_rel8_32", Code.JGE_REL8_32); + map.put("Jge_rel8_64", Code.JGE_REL8_64); + map.put("Jle_rel8_16", Code.JLE_REL8_16); + map.put("Jle_rel8_32", Code.JLE_REL8_32); + map.put("Jle_rel8_64", Code.JLE_REL8_64); + map.put("Jg_rel8_16", Code.JG_REL8_16); + map.put("Jg_rel8_32", Code.JG_REL8_32); + map.put("Jg_rel8_64", Code.JG_REL8_64); + map.put("Add_rm8_imm8", Code.ADD_RM8_IMM8); + map.put("Or_rm8_imm8", Code.OR_RM8_IMM8); + map.put("Adc_rm8_imm8", Code.ADC_RM8_IMM8); + map.put("Sbb_rm8_imm8", Code.SBB_RM8_IMM8); + map.put("And_rm8_imm8", Code.AND_RM8_IMM8); + map.put("Sub_rm8_imm8", Code.SUB_RM8_IMM8); + map.put("Xor_rm8_imm8", Code.XOR_RM8_IMM8); + map.put("Cmp_rm8_imm8", Code.CMP_RM8_IMM8); + map.put("Add_rm16_imm16", Code.ADD_RM16_IMM16); + map.put("Add_rm32_imm32", Code.ADD_RM32_IMM32); + map.put("Add_rm64_imm32", Code.ADD_RM64_IMM32); + map.put("Or_rm16_imm16", Code.OR_RM16_IMM16); + map.put("Or_rm32_imm32", Code.OR_RM32_IMM32); + map.put("Or_rm64_imm32", Code.OR_RM64_IMM32); + map.put("Adc_rm16_imm16", Code.ADC_RM16_IMM16); + map.put("Adc_rm32_imm32", Code.ADC_RM32_IMM32); + map.put("Adc_rm64_imm32", Code.ADC_RM64_IMM32); + map.put("Sbb_rm16_imm16", Code.SBB_RM16_IMM16); + map.put("Sbb_rm32_imm32", Code.SBB_RM32_IMM32); + map.put("Sbb_rm64_imm32", Code.SBB_RM64_IMM32); + map.put("And_rm16_imm16", Code.AND_RM16_IMM16); + map.put("And_rm32_imm32", Code.AND_RM32_IMM32); + map.put("And_rm64_imm32", Code.AND_RM64_IMM32); + map.put("Sub_rm16_imm16", Code.SUB_RM16_IMM16); + map.put("Sub_rm32_imm32", Code.SUB_RM32_IMM32); + map.put("Sub_rm64_imm32", Code.SUB_RM64_IMM32); + map.put("Xor_rm16_imm16", Code.XOR_RM16_IMM16); + map.put("Xor_rm32_imm32", Code.XOR_RM32_IMM32); + map.put("Xor_rm64_imm32", Code.XOR_RM64_IMM32); + map.put("Cmp_rm16_imm16", Code.CMP_RM16_IMM16); + map.put("Cmp_rm32_imm32", Code.CMP_RM32_IMM32); + map.put("Cmp_rm64_imm32", Code.CMP_RM64_IMM32); + map.put("Add_rm8_imm8_82", Code.ADD_RM8_IMM8_82); + map.put("Or_rm8_imm8_82", Code.OR_RM8_IMM8_82); + map.put("Adc_rm8_imm8_82", Code.ADC_RM8_IMM8_82); + map.put("Sbb_rm8_imm8_82", Code.SBB_RM8_IMM8_82); + map.put("And_rm8_imm8_82", Code.AND_RM8_IMM8_82); + map.put("Sub_rm8_imm8_82", Code.SUB_RM8_IMM8_82); + map.put("Xor_rm8_imm8_82", Code.XOR_RM8_IMM8_82); + map.put("Cmp_rm8_imm8_82", Code.CMP_RM8_IMM8_82); + map.put("Add_rm16_imm8", Code.ADD_RM16_IMM8); + map.put("Add_rm32_imm8", Code.ADD_RM32_IMM8); + map.put("Add_rm64_imm8", Code.ADD_RM64_IMM8); + map.put("Or_rm16_imm8", Code.OR_RM16_IMM8); + map.put("Or_rm32_imm8", Code.OR_RM32_IMM8); + map.put("Or_rm64_imm8", Code.OR_RM64_IMM8); + map.put("Adc_rm16_imm8", Code.ADC_RM16_IMM8); + map.put("Adc_rm32_imm8", Code.ADC_RM32_IMM8); + map.put("Adc_rm64_imm8", Code.ADC_RM64_IMM8); + map.put("Sbb_rm16_imm8", Code.SBB_RM16_IMM8); + map.put("Sbb_rm32_imm8", Code.SBB_RM32_IMM8); + map.put("Sbb_rm64_imm8", Code.SBB_RM64_IMM8); + map.put("And_rm16_imm8", Code.AND_RM16_IMM8); + map.put("And_rm32_imm8", Code.AND_RM32_IMM8); + map.put("And_rm64_imm8", Code.AND_RM64_IMM8); + map.put("Sub_rm16_imm8", Code.SUB_RM16_IMM8); + map.put("Sub_rm32_imm8", Code.SUB_RM32_IMM8); + map.put("Sub_rm64_imm8", Code.SUB_RM64_IMM8); + map.put("Xor_rm16_imm8", Code.XOR_RM16_IMM8); + map.put("Xor_rm32_imm8", Code.XOR_RM32_IMM8); + map.put("Xor_rm64_imm8", Code.XOR_RM64_IMM8); + map.put("Cmp_rm16_imm8", Code.CMP_RM16_IMM8); + map.put("Cmp_rm32_imm8", Code.CMP_RM32_IMM8); + map.put("Cmp_rm64_imm8", Code.CMP_RM64_IMM8); + map.put("Test_rm8_r8", Code.TEST_RM8_R8); + map.put("Test_rm16_r16", Code.TEST_RM16_R16); + map.put("Test_rm32_r32", Code.TEST_RM32_R32); + map.put("Test_rm64_r64", Code.TEST_RM64_R64); + map.put("Xchg_rm8_r8", Code.XCHG_RM8_R8); + map.put("Xchg_rm16_r16", Code.XCHG_RM16_R16); + map.put("Xchg_rm32_r32", Code.XCHG_RM32_R32); + map.put("Xchg_rm64_r64", Code.XCHG_RM64_R64); + map.put("Mov_rm8_r8", Code.MOV_RM8_R8); + map.put("Mov_rm16_r16", Code.MOV_RM16_R16); + map.put("Mov_rm32_r32", Code.MOV_RM32_R32); + map.put("Mov_rm64_r64", Code.MOV_RM64_R64); + map.put("Mov_r8_rm8", Code.MOV_R8_RM8); + map.put("Mov_r16_rm16", Code.MOV_R16_RM16); + map.put("Mov_r32_rm32", Code.MOV_R32_RM32); + map.put("Mov_r64_rm64", Code.MOV_R64_RM64); + map.put("Mov_rm16_Sreg", Code.MOV_RM16_SREG); + map.put("Mov_r32m16_Sreg", Code.MOV_R32M16_SREG); + map.put("Mov_r64m16_Sreg", Code.MOV_R64M16_SREG); + map.put("Lea_r16_m", Code.LEA_R16_M); + map.put("Lea_r32_m", Code.LEA_R32_M); + map.put("Lea_r64_m", Code.LEA_R64_M); + map.put("Mov_Sreg_rm16", Code.MOV_SREG_RM16); + map.put("Mov_Sreg_r32m16", Code.MOV_SREG_R32M16); + map.put("Mov_Sreg_r64m16", Code.MOV_SREG_R64M16); + map.put("Pop_rm16", Code.POP_RM16); + map.put("Pop_rm32", Code.POP_RM32); + map.put("Pop_rm64", Code.POP_RM64); + map.put("Nopw", Code.NOPW); + map.put("Nopd", Code.NOPD); + map.put("Nopq", Code.NOPQ); + map.put("Xchg_r16_AX", Code.XCHG_R16_AX); + map.put("Xchg_r32_EAX", Code.XCHG_R32_EAX); + map.put("Xchg_r64_RAX", Code.XCHG_R64_RAX); + map.put("Pause", Code.PAUSE); + map.put("Cbw", Code.CBW); + map.put("Cwde", Code.CWDE); + map.put("Cdqe", Code.CDQE); + map.put("Cwd", Code.CWD); + map.put("Cdq", Code.CDQ); + map.put("Cqo", Code.CQO); + map.put("Call_ptr1616", Code.CALL_PTR1616); + map.put("Call_ptr1632", Code.CALL_PTR1632); + map.put("Wait", Code.WAIT); + map.put("Pushfw", Code.PUSHFW); + map.put("Pushfd", Code.PUSHFD); + map.put("Pushfq", Code.PUSHFQ); + map.put("Popfw", Code.POPFW); + map.put("Popfd", Code.POPFD); + map.put("Popfq", Code.POPFQ); + map.put("Sahf", Code.SAHF); + map.put("Lahf", Code.LAHF); + map.put("Mov_AL_moffs8", Code.MOV_AL_MOFFS8); + map.put("Mov_AX_moffs16", Code.MOV_AX_MOFFS16); + map.put("Mov_EAX_moffs32", Code.MOV_EAX_MOFFS32); + map.put("Mov_RAX_moffs64", Code.MOV_RAX_MOFFS64); + map.put("Mov_moffs8_AL", Code.MOV_MOFFS8_AL); + map.put("Mov_moffs16_AX", Code.MOV_MOFFS16_AX); + map.put("Mov_moffs32_EAX", Code.MOV_MOFFS32_EAX); + map.put("Mov_moffs64_RAX", Code.MOV_MOFFS64_RAX); + map.put("Movsb_m8_m8", Code.MOVSB_M8_M8); + map.put("Movsw_m16_m16", Code.MOVSW_M16_M16); + map.put("Movsd_m32_m32", Code.MOVSD_M32_M32); + map.put("Movsq_m64_m64", Code.MOVSQ_M64_M64); + map.put("Cmpsb_m8_m8", Code.CMPSB_M8_M8); + map.put("Cmpsw_m16_m16", Code.CMPSW_M16_M16); + map.put("Cmpsd_m32_m32", Code.CMPSD_M32_M32); + map.put("Cmpsq_m64_m64", Code.CMPSQ_M64_M64); + map.put("Test_AL_imm8", Code.TEST_AL_IMM8); + map.put("Test_AX_imm16", Code.TEST_AX_IMM16); + map.put("Test_EAX_imm32", Code.TEST_EAX_IMM32); + map.put("Test_RAX_imm32", Code.TEST_RAX_IMM32); + map.put("Stosb_m8_AL", Code.STOSB_M8_AL); + map.put("Stosw_m16_AX", Code.STOSW_M16_AX); + map.put("Stosd_m32_EAX", Code.STOSD_M32_EAX); + map.put("Stosq_m64_RAX", Code.STOSQ_M64_RAX); + map.put("Lodsb_AL_m8", Code.LODSB_AL_M8); + map.put("Lodsw_AX_m16", Code.LODSW_AX_M16); + map.put("Lodsd_EAX_m32", Code.LODSD_EAX_M32); + map.put("Lodsq_RAX_m64", Code.LODSQ_RAX_M64); + map.put("Scasb_AL_m8", Code.SCASB_AL_M8); + map.put("Scasw_AX_m16", Code.SCASW_AX_M16); + map.put("Scasd_EAX_m32", Code.SCASD_EAX_M32); + map.put("Scasq_RAX_m64", Code.SCASQ_RAX_M64); + map.put("Mov_r8_imm8", Code.MOV_R8_IMM8); + map.put("Mov_r16_imm16", Code.MOV_R16_IMM16); + map.put("Mov_r32_imm32", Code.MOV_R32_IMM32); + map.put("Mov_r64_imm64", Code.MOV_R64_IMM64); + map.put("Rol_rm8_imm8", Code.ROL_RM8_IMM8); + map.put("Ror_rm8_imm8", Code.ROR_RM8_IMM8); + map.put("Rcl_rm8_imm8", Code.RCL_RM8_IMM8); + map.put("Rcr_rm8_imm8", Code.RCR_RM8_IMM8); + map.put("Shl_rm8_imm8", Code.SHL_RM8_IMM8); + map.put("Shr_rm8_imm8", Code.SHR_RM8_IMM8); + map.put("Sal_rm8_imm8", Code.SAL_RM8_IMM8); + map.put("Sar_rm8_imm8", Code.SAR_RM8_IMM8); + map.put("Rol_rm16_imm8", Code.ROL_RM16_IMM8); + map.put("Rol_rm32_imm8", Code.ROL_RM32_IMM8); + map.put("Rol_rm64_imm8", Code.ROL_RM64_IMM8); + map.put("Ror_rm16_imm8", Code.ROR_RM16_IMM8); + map.put("Ror_rm32_imm8", Code.ROR_RM32_IMM8); + map.put("Ror_rm64_imm8", Code.ROR_RM64_IMM8); + map.put("Rcl_rm16_imm8", Code.RCL_RM16_IMM8); + map.put("Rcl_rm32_imm8", Code.RCL_RM32_IMM8); + map.put("Rcl_rm64_imm8", Code.RCL_RM64_IMM8); + map.put("Rcr_rm16_imm8", Code.RCR_RM16_IMM8); + map.put("Rcr_rm32_imm8", Code.RCR_RM32_IMM8); + map.put("Rcr_rm64_imm8", Code.RCR_RM64_IMM8); + map.put("Shl_rm16_imm8", Code.SHL_RM16_IMM8); + map.put("Shl_rm32_imm8", Code.SHL_RM32_IMM8); + map.put("Shl_rm64_imm8", Code.SHL_RM64_IMM8); + map.put("Shr_rm16_imm8", Code.SHR_RM16_IMM8); + map.put("Shr_rm32_imm8", Code.SHR_RM32_IMM8); + map.put("Shr_rm64_imm8", Code.SHR_RM64_IMM8); + map.put("Sal_rm16_imm8", Code.SAL_RM16_IMM8); + map.put("Sal_rm32_imm8", Code.SAL_RM32_IMM8); + map.put("Sal_rm64_imm8", Code.SAL_RM64_IMM8); + map.put("Sar_rm16_imm8", Code.SAR_RM16_IMM8); + map.put("Sar_rm32_imm8", Code.SAR_RM32_IMM8); + map.put("Sar_rm64_imm8", Code.SAR_RM64_IMM8); + map.put("Retnw_imm16", Code.RETNW_IMM16); + map.put("Retnd_imm16", Code.RETND_IMM16); + map.put("Retnq_imm16", Code.RETNQ_IMM16); + map.put("Retnw", Code.RETNW); + map.put("Retnd", Code.RETND); + map.put("Retnq", Code.RETNQ); + map.put("Les_r16_m1616", Code.LES_R16_M1616); + map.put("Les_r32_m1632", Code.LES_R32_M1632); + map.put("Lds_r16_m1616", Code.LDS_R16_M1616); + map.put("Lds_r32_m1632", Code.LDS_R32_M1632); + map.put("Mov_rm8_imm8", Code.MOV_RM8_IMM8); + map.put("Xabort_imm8", Code.XABORT_IMM8); + map.put("Mov_rm16_imm16", Code.MOV_RM16_IMM16); + map.put("Mov_rm32_imm32", Code.MOV_RM32_IMM32); + map.put("Mov_rm64_imm32", Code.MOV_RM64_IMM32); + map.put("Xbegin_rel16", Code.XBEGIN_REL16); + map.put("Xbegin_rel32", Code.XBEGIN_REL32); + map.put("Enterw_imm16_imm8", Code.ENTERW_IMM16_IMM8); + map.put("Enterd_imm16_imm8", Code.ENTERD_IMM16_IMM8); + map.put("Enterq_imm16_imm8", Code.ENTERQ_IMM16_IMM8); + map.put("Leavew", Code.LEAVEW); + map.put("Leaved", Code.LEAVED); + map.put("Leaveq", Code.LEAVEQ); + map.put("Retfw_imm16", Code.RETFW_IMM16); + map.put("Retfd_imm16", Code.RETFD_IMM16); + map.put("Retfq_imm16", Code.RETFQ_IMM16); + map.put("Retfw", Code.RETFW); + map.put("Retfd", Code.RETFD); + map.put("Retfq", Code.RETFQ); + map.put("Int3", Code.INT3); + map.put("Int_imm8", Code.INT_IMM8); + map.put("Into", Code.INTO); + map.put("Iretw", Code.IRETW); + map.put("Iretd", Code.IRETD); + map.put("Iretq", Code.IRETQ); + map.put("Rol_rm8_1", Code.ROL_RM8_1); + map.put("Ror_rm8_1", Code.ROR_RM8_1); + map.put("Rcl_rm8_1", Code.RCL_RM8_1); + map.put("Rcr_rm8_1", Code.RCR_RM8_1); + map.put("Shl_rm8_1", Code.SHL_RM8_1); + map.put("Shr_rm8_1", Code.SHR_RM8_1); + map.put("Sal_rm8_1", Code.SAL_RM8_1); + map.put("Sar_rm8_1", Code.SAR_RM8_1); + map.put("Rol_rm16_1", Code.ROL_RM16_1); + map.put("Rol_rm32_1", Code.ROL_RM32_1); + map.put("Rol_rm64_1", Code.ROL_RM64_1); + map.put("Ror_rm16_1", Code.ROR_RM16_1); + map.put("Ror_rm32_1", Code.ROR_RM32_1); + map.put("Ror_rm64_1", Code.ROR_RM64_1); + map.put("Rcl_rm16_1", Code.RCL_RM16_1); + map.put("Rcl_rm32_1", Code.RCL_RM32_1); + map.put("Rcl_rm64_1", Code.RCL_RM64_1); + map.put("Rcr_rm16_1", Code.RCR_RM16_1); + map.put("Rcr_rm32_1", Code.RCR_RM32_1); + map.put("Rcr_rm64_1", Code.RCR_RM64_1); + map.put("Shl_rm16_1", Code.SHL_RM16_1); + map.put("Shl_rm32_1", Code.SHL_RM32_1); + map.put("Shl_rm64_1", Code.SHL_RM64_1); + map.put("Shr_rm16_1", Code.SHR_RM16_1); + map.put("Shr_rm32_1", Code.SHR_RM32_1); + map.put("Shr_rm64_1", Code.SHR_RM64_1); + map.put("Sal_rm16_1", Code.SAL_RM16_1); + map.put("Sal_rm32_1", Code.SAL_RM32_1); + map.put("Sal_rm64_1", Code.SAL_RM64_1); + map.put("Sar_rm16_1", Code.SAR_RM16_1); + map.put("Sar_rm32_1", Code.SAR_RM32_1); + map.put("Sar_rm64_1", Code.SAR_RM64_1); + map.put("Rol_rm8_CL", Code.ROL_RM8_CL); + map.put("Ror_rm8_CL", Code.ROR_RM8_CL); + map.put("Rcl_rm8_CL", Code.RCL_RM8_CL); + map.put("Rcr_rm8_CL", Code.RCR_RM8_CL); + map.put("Shl_rm8_CL", Code.SHL_RM8_CL); + map.put("Shr_rm8_CL", Code.SHR_RM8_CL); + map.put("Sal_rm8_CL", Code.SAL_RM8_CL); + map.put("Sar_rm8_CL", Code.SAR_RM8_CL); + map.put("Rol_rm16_CL", Code.ROL_RM16_CL); + map.put("Rol_rm32_CL", Code.ROL_RM32_CL); + map.put("Rol_rm64_CL", Code.ROL_RM64_CL); + map.put("Ror_rm16_CL", Code.ROR_RM16_CL); + map.put("Ror_rm32_CL", Code.ROR_RM32_CL); + map.put("Ror_rm64_CL", Code.ROR_RM64_CL); + map.put("Rcl_rm16_CL", Code.RCL_RM16_CL); + map.put("Rcl_rm32_CL", Code.RCL_RM32_CL); + map.put("Rcl_rm64_CL", Code.RCL_RM64_CL); + map.put("Rcr_rm16_CL", Code.RCR_RM16_CL); + map.put("Rcr_rm32_CL", Code.RCR_RM32_CL); + map.put("Rcr_rm64_CL", Code.RCR_RM64_CL); + map.put("Shl_rm16_CL", Code.SHL_RM16_CL); + map.put("Shl_rm32_CL", Code.SHL_RM32_CL); + map.put("Shl_rm64_CL", Code.SHL_RM64_CL); + map.put("Shr_rm16_CL", Code.SHR_RM16_CL); + map.put("Shr_rm32_CL", Code.SHR_RM32_CL); + map.put("Shr_rm64_CL", Code.SHR_RM64_CL); + map.put("Sal_rm16_CL", Code.SAL_RM16_CL); + map.put("Sal_rm32_CL", Code.SAL_RM32_CL); + map.put("Sal_rm64_CL", Code.SAL_RM64_CL); + map.put("Sar_rm16_CL", Code.SAR_RM16_CL); + map.put("Sar_rm32_CL", Code.SAR_RM32_CL); + map.put("Sar_rm64_CL", Code.SAR_RM64_CL); + map.put("Aam_imm8", Code.AAM_IMM8); + map.put("Aad_imm8", Code.AAD_IMM8); + map.put("Salc", Code.SALC); + map.put("Xlat_m8", Code.XLAT_M8); + map.put("Fadd_m32fp", Code.FADD_M32FP); + map.put("Fmul_m32fp", Code.FMUL_M32FP); + map.put("Fcom_m32fp", Code.FCOM_M32FP); + map.put("Fcomp_m32fp", Code.FCOMP_M32FP); + map.put("Fsub_m32fp", Code.FSUB_M32FP); + map.put("Fsubr_m32fp", Code.FSUBR_M32FP); + } + + private static void initMap1(HashMap map) { + map.put("Fdiv_m32fp", Code.FDIV_M32FP); + map.put("Fdivr_m32fp", Code.FDIVR_M32FP); + map.put("Fadd_st0_sti", Code.FADD_ST0_STI); + map.put("Fmul_st0_sti", Code.FMUL_ST0_STI); + map.put("Fcom_st0_sti", Code.FCOM_ST0_STI); + map.put("Fcomp_st0_sti", Code.FCOMP_ST0_STI); + map.put("Fsub_st0_sti", Code.FSUB_ST0_STI); + map.put("Fsubr_st0_sti", Code.FSUBR_ST0_STI); + map.put("Fdiv_st0_sti", Code.FDIV_ST0_STI); + map.put("Fdivr_st0_sti", Code.FDIVR_ST0_STI); + map.put("Fld_m32fp", Code.FLD_M32FP); + map.put("Fst_m32fp", Code.FST_M32FP); + map.put("Fstp_m32fp", Code.FSTP_M32FP); + map.put("Fldenv_m14byte", Code.FLDENV_M14BYTE); + map.put("Fldenv_m28byte", Code.FLDENV_M28BYTE); + map.put("Fldcw_m2byte", Code.FLDCW_M2BYTE); + map.put("Fnstenv_m14byte", Code.FNSTENV_M14BYTE); + map.put("Fstenv_m14byte", Code.FSTENV_M14BYTE); + map.put("Fnstenv_m28byte", Code.FNSTENV_M28BYTE); + map.put("Fstenv_m28byte", Code.FSTENV_M28BYTE); + map.put("Fnstcw_m2byte", Code.FNSTCW_M2BYTE); + map.put("Fstcw_m2byte", Code.FSTCW_M2BYTE); + map.put("Fld_sti", Code.FLD_STI); + map.put("Fxch_st0_sti", Code.FXCH_ST0_STI); + map.put("Fnop", Code.FNOP); + map.put("Fstpnce_sti", Code.FSTPNCE_STI); + map.put("Fchs", Code.FCHS); + map.put("Fabs", Code.FABS); + map.put("Ftst", Code.FTST); + map.put("Fxam", Code.FXAM); + map.put("Fld1", Code.FLD1); + map.put("Fldl2t", Code.FLDL2T); + map.put("Fldl2e", Code.FLDL2E); + map.put("Fldpi", Code.FLDPI); + map.put("Fldlg2", Code.FLDLG2); + map.put("Fldln2", Code.FLDLN2); + map.put("Fldz", Code.FLDZ); + map.put("F2xm1", Code.F2XM1); + map.put("Fyl2x", Code.FYL2X); + map.put("Fptan", Code.FPTAN); + map.put("Fpatan", Code.FPATAN); + map.put("Fxtract", Code.FXTRACT); + map.put("Fprem1", Code.FPREM1); + map.put("Fdecstp", Code.FDECSTP); + map.put("Fincstp", Code.FINCSTP); + map.put("Fprem", Code.FPREM); + map.put("Fyl2xp1", Code.FYL2XP1); + map.put("Fsqrt", Code.FSQRT); + map.put("Fsincos", Code.FSINCOS); + map.put("Frndint", Code.FRNDINT); + map.put("Fscale", Code.FSCALE); + map.put("Fsin", Code.FSIN); + map.put("Fcos", Code.FCOS); + map.put("Fiadd_m32int", Code.FIADD_M32INT); + map.put("Fimul_m32int", Code.FIMUL_M32INT); + map.put("Ficom_m32int", Code.FICOM_M32INT); + map.put("Ficomp_m32int", Code.FICOMP_M32INT); + map.put("Fisub_m32int", Code.FISUB_M32INT); + map.put("Fisubr_m32int", Code.FISUBR_M32INT); + map.put("Fidiv_m32int", Code.FIDIV_M32INT); + map.put("Fidivr_m32int", Code.FIDIVR_M32INT); + map.put("Fcmovb_st0_sti", Code.FCMOVB_ST0_STI); + map.put("Fcmove_st0_sti", Code.FCMOVE_ST0_STI); + map.put("Fcmovbe_st0_sti", Code.FCMOVBE_ST0_STI); + map.put("Fcmovu_st0_sti", Code.FCMOVU_ST0_STI); + map.put("Fucompp", Code.FUCOMPP); + map.put("Fild_m32int", Code.FILD_M32INT); + map.put("Fisttp_m32int", Code.FISTTP_M32INT); + map.put("Fist_m32int", Code.FIST_M32INT); + map.put("Fistp_m32int", Code.FISTP_M32INT); + map.put("Fld_m80fp", Code.FLD_M80FP); + map.put("Fstp_m80fp", Code.FSTP_M80FP); + map.put("Fcmovnb_st0_sti", Code.FCMOVNB_ST0_STI); + map.put("Fcmovne_st0_sti", Code.FCMOVNE_ST0_STI); + map.put("Fcmovnbe_st0_sti", Code.FCMOVNBE_ST0_STI); + map.put("Fcmovnu_st0_sti", Code.FCMOVNU_ST0_STI); + map.put("Fneni", Code.FNENI); + map.put("Feni", Code.FENI); + map.put("Fndisi", Code.FNDISI); + map.put("Fdisi", Code.FDISI); + map.put("Fnclex", Code.FNCLEX); + map.put("Fclex", Code.FCLEX); + map.put("Fninit", Code.FNINIT); + map.put("Finit", Code.FINIT); + map.put("Fnsetpm", Code.FNSETPM); + map.put("Fsetpm", Code.FSETPM); + map.put("Frstpm", Code.FRSTPM); + map.put("Fucomi_st0_sti", Code.FUCOMI_ST0_STI); + map.put("Fcomi_st0_sti", Code.FCOMI_ST0_STI); + map.put("Fadd_m64fp", Code.FADD_M64FP); + map.put("Fmul_m64fp", Code.FMUL_M64FP); + map.put("Fcom_m64fp", Code.FCOM_M64FP); + map.put("Fcomp_m64fp", Code.FCOMP_M64FP); + map.put("Fsub_m64fp", Code.FSUB_M64FP); + map.put("Fsubr_m64fp", Code.FSUBR_M64FP); + map.put("Fdiv_m64fp", Code.FDIV_M64FP); + map.put("Fdivr_m64fp", Code.FDIVR_M64FP); + map.put("Fadd_sti_st0", Code.FADD_STI_ST0); + map.put("Fmul_sti_st0", Code.FMUL_STI_ST0); + map.put("Fcom_st0_sti_DCD0", Code.FCOM_ST0_STI_DCD0); + map.put("Fcomp_st0_sti_DCD8", Code.FCOMP_ST0_STI_DCD8); + map.put("Fsubr_sti_st0", Code.FSUBR_STI_ST0); + map.put("Fsub_sti_st0", Code.FSUB_STI_ST0); + map.put("Fdivr_sti_st0", Code.FDIVR_STI_ST0); + map.put("Fdiv_sti_st0", Code.FDIV_STI_ST0); + map.put("Fld_m64fp", Code.FLD_M64FP); + map.put("Fisttp_m64int", Code.FISTTP_M64INT); + map.put("Fst_m64fp", Code.FST_M64FP); + map.put("Fstp_m64fp", Code.FSTP_M64FP); + map.put("Frstor_m94byte", Code.FRSTOR_M94BYTE); + map.put("Frstor_m108byte", Code.FRSTOR_M108BYTE); + map.put("Fnsave_m94byte", Code.FNSAVE_M94BYTE); + map.put("Fsave_m94byte", Code.FSAVE_M94BYTE); + map.put("Fnsave_m108byte", Code.FNSAVE_M108BYTE); + map.put("Fsave_m108byte", Code.FSAVE_M108BYTE); + map.put("Fnstsw_m2byte", Code.FNSTSW_M2BYTE); + map.put("Fstsw_m2byte", Code.FSTSW_M2BYTE); + map.put("Ffree_sti", Code.FFREE_STI); + map.put("Fxch_st0_sti_DDC8", Code.FXCH_ST0_STI_DDC8); + map.put("Fst_sti", Code.FST_STI); + map.put("Fstp_sti", Code.FSTP_STI); + map.put("Fucom_st0_sti", Code.FUCOM_ST0_STI); + map.put("Fucomp_st0_sti", Code.FUCOMP_ST0_STI); + map.put("Fiadd_m16int", Code.FIADD_M16INT); + map.put("Fimul_m16int", Code.FIMUL_M16INT); + map.put("Ficom_m16int", Code.FICOM_M16INT); + map.put("Ficomp_m16int", Code.FICOMP_M16INT); + map.put("Fisub_m16int", Code.FISUB_M16INT); + map.put("Fisubr_m16int", Code.FISUBR_M16INT); + map.put("Fidiv_m16int", Code.FIDIV_M16INT); + map.put("Fidivr_m16int", Code.FIDIVR_M16INT); + map.put("Faddp_sti_st0", Code.FADDP_STI_ST0); + map.put("Fmulp_sti_st0", Code.FMULP_STI_ST0); + map.put("Fcomp_st0_sti_DED0", Code.FCOMP_ST0_STI_DED0); + map.put("Fcompp", Code.FCOMPP); + map.put("Fsubrp_sti_st0", Code.FSUBRP_STI_ST0); + map.put("Fsubp_sti_st0", Code.FSUBP_STI_ST0); + map.put("Fdivrp_sti_st0", Code.FDIVRP_STI_ST0); + map.put("Fdivp_sti_st0", Code.FDIVP_STI_ST0); + map.put("Fild_m16int", Code.FILD_M16INT); + map.put("Fisttp_m16int", Code.FISTTP_M16INT); + map.put("Fist_m16int", Code.FIST_M16INT); + map.put("Fistp_m16int", Code.FISTP_M16INT); + map.put("Fbld_m80bcd", Code.FBLD_M80BCD); + map.put("Fild_m64int", Code.FILD_M64INT); + map.put("Fbstp_m80bcd", Code.FBSTP_M80BCD); + map.put("Fistp_m64int", Code.FISTP_M64INT); + map.put("Ffreep_sti", Code.FFREEP_STI); + map.put("Fxch_st0_sti_DFC8", Code.FXCH_ST0_STI_DFC8); + map.put("Fstp_sti_DFD0", Code.FSTP_STI_DFD0); + map.put("Fstp_sti_DFD8", Code.FSTP_STI_DFD8); + map.put("Fnstsw_AX", Code.FNSTSW_AX); + map.put("Fstsw_AX", Code.FSTSW_AX); + map.put("Fstdw_AX", Code.FSTDW_AX); + map.put("Fstsg_AX", Code.FSTSG_AX); + map.put("Fucomip_st0_sti", Code.FUCOMIP_ST0_STI); + map.put("Fcomip_st0_sti", Code.FCOMIP_ST0_STI); + map.put("Loopne_rel8_16_CX", Code.LOOPNE_REL8_16_CX); + map.put("Loopne_rel8_32_CX", Code.LOOPNE_REL8_32_CX); + map.put("Loopne_rel8_16_ECX", Code.LOOPNE_REL8_16_ECX); + map.put("Loopne_rel8_32_ECX", Code.LOOPNE_REL8_32_ECX); + map.put("Loopne_rel8_64_ECX", Code.LOOPNE_REL8_64_ECX); + map.put("Loopne_rel8_16_RCX", Code.LOOPNE_REL8_16_RCX); + map.put("Loopne_rel8_64_RCX", Code.LOOPNE_REL8_64_RCX); + map.put("Loope_rel8_16_CX", Code.LOOPE_REL8_16_CX); + map.put("Loope_rel8_32_CX", Code.LOOPE_REL8_32_CX); + map.put("Loope_rel8_16_ECX", Code.LOOPE_REL8_16_ECX); + map.put("Loope_rel8_32_ECX", Code.LOOPE_REL8_32_ECX); + map.put("Loope_rel8_64_ECX", Code.LOOPE_REL8_64_ECX); + map.put("Loope_rel8_16_RCX", Code.LOOPE_REL8_16_RCX); + map.put("Loope_rel8_64_RCX", Code.LOOPE_REL8_64_RCX); + map.put("Loop_rel8_16_CX", Code.LOOP_REL8_16_CX); + map.put("Loop_rel8_32_CX", Code.LOOP_REL8_32_CX); + map.put("Loop_rel8_16_ECX", Code.LOOP_REL8_16_ECX); + map.put("Loop_rel8_32_ECX", Code.LOOP_REL8_32_ECX); + map.put("Loop_rel8_64_ECX", Code.LOOP_REL8_64_ECX); + map.put("Loop_rel8_16_RCX", Code.LOOP_REL8_16_RCX); + map.put("Loop_rel8_64_RCX", Code.LOOP_REL8_64_RCX); + map.put("Jcxz_rel8_16", Code.JCXZ_REL8_16); + map.put("Jcxz_rel8_32", Code.JCXZ_REL8_32); + map.put("Jecxz_rel8_16", Code.JECXZ_REL8_16); + map.put("Jecxz_rel8_32", Code.JECXZ_REL8_32); + map.put("Jecxz_rel8_64", Code.JECXZ_REL8_64); + map.put("Jrcxz_rel8_16", Code.JRCXZ_REL8_16); + map.put("Jrcxz_rel8_64", Code.JRCXZ_REL8_64); + map.put("In_AL_imm8", Code.IN_AL_IMM8); + map.put("In_AX_imm8", Code.IN_AX_IMM8); + map.put("In_EAX_imm8", Code.IN_EAX_IMM8); + map.put("Out_imm8_AL", Code.OUT_IMM8_AL); + map.put("Out_imm8_AX", Code.OUT_IMM8_AX); + map.put("Out_imm8_EAX", Code.OUT_IMM8_EAX); + map.put("Call_rel16", Code.CALL_REL16); + map.put("Call_rel32_32", Code.CALL_REL32_32); + map.put("Call_rel32_64", Code.CALL_REL32_64); + map.put("Jmp_rel16", Code.JMP_REL16); + map.put("Jmp_rel32_32", Code.JMP_REL32_32); + map.put("Jmp_rel32_64", Code.JMP_REL32_64); + map.put("Jmp_ptr1616", Code.JMP_PTR1616); + map.put("Jmp_ptr1632", Code.JMP_PTR1632); + map.put("Jmp_rel8_16", Code.JMP_REL8_16); + map.put("Jmp_rel8_32", Code.JMP_REL8_32); + map.put("Jmp_rel8_64", Code.JMP_REL8_64); + map.put("In_AL_DX", Code.IN_AL_DX); + map.put("In_AX_DX", Code.IN_AX_DX); + map.put("In_EAX_DX", Code.IN_EAX_DX); + map.put("Out_DX_AL", Code.OUT_DX_AL); + map.put("Out_DX_AX", Code.OUT_DX_AX); + map.put("Out_DX_EAX", Code.OUT_DX_EAX); + map.put("Int1", Code.INT1); + map.put("Hlt", Code.HLT); + map.put("Cmc", Code.CMC); + map.put("Test_rm8_imm8", Code.TEST_RM8_IMM8); + map.put("Test_rm8_imm8_F6r1", Code.TEST_RM8_IMM8_F6R1); + map.put("Not_rm8", Code.NOT_RM8); + map.put("Neg_rm8", Code.NEG_RM8); + map.put("Mul_rm8", Code.MUL_RM8); + map.put("Imul_rm8", Code.IMUL_RM8); + map.put("Div_rm8", Code.DIV_RM8); + map.put("Idiv_rm8", Code.IDIV_RM8); + map.put("Test_rm16_imm16", Code.TEST_RM16_IMM16); + map.put("Test_rm32_imm32", Code.TEST_RM32_IMM32); + map.put("Test_rm64_imm32", Code.TEST_RM64_IMM32); + map.put("Test_rm16_imm16_F7r1", Code.TEST_RM16_IMM16_F7R1); + map.put("Test_rm32_imm32_F7r1", Code.TEST_RM32_IMM32_F7R1); + map.put("Test_rm64_imm32_F7r1", Code.TEST_RM64_IMM32_F7R1); + map.put("Not_rm16", Code.NOT_RM16); + map.put("Not_rm32", Code.NOT_RM32); + map.put("Not_rm64", Code.NOT_RM64); + map.put("Neg_rm16", Code.NEG_RM16); + map.put("Neg_rm32", Code.NEG_RM32); + map.put("Neg_rm64", Code.NEG_RM64); + map.put("Mul_rm16", Code.MUL_RM16); + map.put("Mul_rm32", Code.MUL_RM32); + map.put("Mul_rm64", Code.MUL_RM64); + map.put("Imul_rm16", Code.IMUL_RM16); + map.put("Imul_rm32", Code.IMUL_RM32); + map.put("Imul_rm64", Code.IMUL_RM64); + map.put("Div_rm16", Code.DIV_RM16); + map.put("Div_rm32", Code.DIV_RM32); + map.put("Div_rm64", Code.DIV_RM64); + map.put("Idiv_rm16", Code.IDIV_RM16); + map.put("Idiv_rm32", Code.IDIV_RM32); + map.put("Idiv_rm64", Code.IDIV_RM64); + map.put("Clc", Code.CLC); + map.put("Stc", Code.STC); + map.put("Cli", Code.CLI); + map.put("Sti", Code.STI); + map.put("Cld", Code.CLD); + map.put("Std", Code.STD); + map.put("Inc_rm8", Code.INC_RM8); + map.put("Dec_rm8", Code.DEC_RM8); + map.put("Inc_rm16", Code.INC_RM16); + map.put("Inc_rm32", Code.INC_RM32); + map.put("Inc_rm64", Code.INC_RM64); + map.put("Dec_rm16", Code.DEC_RM16); + map.put("Dec_rm32", Code.DEC_RM32); + map.put("Dec_rm64", Code.DEC_RM64); + map.put("Call_rm16", Code.CALL_RM16); + map.put("Call_rm32", Code.CALL_RM32); + map.put("Call_rm64", Code.CALL_RM64); + map.put("Call_m1616", Code.CALL_M1616); + map.put("Call_m1632", Code.CALL_M1632); + map.put("Call_m1664", Code.CALL_M1664); + map.put("Jmp_rm16", Code.JMP_RM16); + map.put("Jmp_rm32", Code.JMP_RM32); + map.put("Jmp_rm64", Code.JMP_RM64); + map.put("Jmp_m1616", Code.JMP_M1616); + map.put("Jmp_m1632", Code.JMP_M1632); + map.put("Jmp_m1664", Code.JMP_M1664); + map.put("Push_rm16", Code.PUSH_RM16); + map.put("Push_rm32", Code.PUSH_RM32); + map.put("Push_rm64", Code.PUSH_RM64); + map.put("Sldt_rm16", Code.SLDT_RM16); + map.put("Sldt_r32m16", Code.SLDT_R32M16); + map.put("Sldt_r64m16", Code.SLDT_R64M16); + map.put("Str_rm16", Code.STR_RM16); + map.put("Str_r32m16", Code.STR_R32M16); + map.put("Str_r64m16", Code.STR_R64M16); + map.put("Lldt_rm16", Code.LLDT_RM16); + map.put("Lldt_r32m16", Code.LLDT_R32M16); + map.put("Lldt_r64m16", Code.LLDT_R64M16); + map.put("Ltr_rm16", Code.LTR_RM16); + map.put("Ltr_r32m16", Code.LTR_R32M16); + map.put("Ltr_r64m16", Code.LTR_R64M16); + map.put("Verr_rm16", Code.VERR_RM16); + map.put("Verr_r32m16", Code.VERR_R32M16); + map.put("Verr_r64m16", Code.VERR_R64M16); + map.put("Verw_rm16", Code.VERW_RM16); + map.put("Verw_r32m16", Code.VERW_R32M16); + map.put("Verw_r64m16", Code.VERW_R64M16); + map.put("Jmpe_rm16", Code.JMPE_RM16); + map.put("Jmpe_rm32", Code.JMPE_RM32); + map.put("Sgdt_m1632_16", Code.SGDT_M1632_16); + map.put("Sgdt_m1632", Code.SGDT_M1632); + map.put("Sgdt_m1664", Code.SGDT_M1664); + map.put("Sidt_m1632_16", Code.SIDT_M1632_16); + map.put("Sidt_m1632", Code.SIDT_M1632); + map.put("Sidt_m1664", Code.SIDT_M1664); + map.put("Lgdt_m1632_16", Code.LGDT_M1632_16); + map.put("Lgdt_m1632", Code.LGDT_M1632); + map.put("Lgdt_m1664", Code.LGDT_M1664); + map.put("Lidt_m1632_16", Code.LIDT_M1632_16); + map.put("Lidt_m1632", Code.LIDT_M1632); + map.put("Lidt_m1664", Code.LIDT_M1664); + map.put("Smsw_rm16", Code.SMSW_RM16); + map.put("Smsw_r32m16", Code.SMSW_R32M16); + map.put("Smsw_r64m16", Code.SMSW_R64M16); + map.put("Rstorssp_m64", Code.RSTORSSP_M64); + map.put("Lmsw_rm16", Code.LMSW_RM16); + map.put("Lmsw_r32m16", Code.LMSW_R32M16); + map.put("Lmsw_r64m16", Code.LMSW_R64M16); + map.put("Invlpg_m", Code.INVLPG_M); + map.put("Enclv", Code.ENCLV); + map.put("Vmcall", Code.VMCALL); + map.put("Vmlaunch", Code.VMLAUNCH); + map.put("Vmresume", Code.VMRESUME); + map.put("Vmxoff", Code.VMXOFF); + map.put("Pconfig", Code.PCONFIG); + map.put("Monitorw", Code.MONITORW); + map.put("Monitord", Code.MONITORD); + map.put("Monitorq", Code.MONITORQ); + map.put("Mwait", Code.MWAIT); + map.put("Clac", Code.CLAC); + map.put("Stac", Code.STAC); + map.put("Encls", Code.ENCLS); + map.put("Xgetbv", Code.XGETBV); + map.put("Xsetbv", Code.XSETBV); + map.put("Vmfunc", Code.VMFUNC); + map.put("Xend", Code.XEND); + map.put("Xtest", Code.XTEST); + map.put("Enclu", Code.ENCLU); + map.put("Vmrunw", Code.VMRUNW); + map.put("Vmrund", Code.VMRUND); + map.put("Vmrunq", Code.VMRUNQ); + map.put("Vmmcall", Code.VMMCALL); + map.put("Vmloadw", Code.VMLOADW); + map.put("Vmloadd", Code.VMLOADD); + map.put("Vmloadq", Code.VMLOADQ); + map.put("Vmsavew", Code.VMSAVEW); + map.put("Vmsaved", Code.VMSAVED); + map.put("Vmsaveq", Code.VMSAVEQ); + map.put("Stgi", Code.STGI); + map.put("Clgi", Code.CLGI); + map.put("Skinit", Code.SKINIT); + map.put("Invlpgaw", Code.INVLPGAW); + map.put("Invlpgad", Code.INVLPGAD); + map.put("Invlpgaq", Code.INVLPGAQ); + map.put("Setssbsy", Code.SETSSBSY); + map.put("Saveprevssp", Code.SAVEPREVSSP); + map.put("Rdpkru", Code.RDPKRU); + map.put("Wrpkru", Code.WRPKRU); + map.put("Swapgs", Code.SWAPGS); + map.put("Rdtscp", Code.RDTSCP); + map.put("Monitorxw", Code.MONITORXW); + map.put("Monitorxd", Code.MONITORXD); + map.put("Monitorxq", Code.MONITORXQ); + map.put("Mcommit", Code.MCOMMIT); + map.put("Mwaitx", Code.MWAITX); + map.put("Clzerow", Code.CLZEROW); + map.put("Clzerod", Code.CLZEROD); + map.put("Clzeroq", Code.CLZEROQ); + map.put("Rdpru", Code.RDPRU); + map.put("Lar_r16_rm16", Code.LAR_R16_RM16); + map.put("Lar_r32_r32m16", Code.LAR_R32_R32M16); + map.put("Lar_r64_r64m16", Code.LAR_R64_R64M16); + map.put("Lsl_r16_rm16", Code.LSL_R16_RM16); + map.put("Lsl_r32_r32m16", Code.LSL_R32_R32M16); + map.put("Lsl_r64_r64m16", Code.LSL_R64_R64M16); + map.put("Storeall", Code.STOREALL); + map.put("Loadall286", Code.LOADALL286); + map.put("Syscall", Code.SYSCALL); + map.put("Clts", Code.CLTS); + map.put("Loadall386", Code.LOADALL386); + map.put("Sysretd", Code.SYSRETD); + map.put("Sysretq", Code.SYSRETQ); + map.put("Invd", Code.INVD); + map.put("Wbinvd", Code.WBINVD); + map.put("Wbnoinvd", Code.WBNOINVD); + map.put("Cl1invmb", Code.CL1INVMB); + map.put("Ud2", Code.UD2); + map.put("Reservednop_rm16_r16_0F0D", Code.RESERVEDNOP_RM16_R16_0F0D); + map.put("Reservednop_rm32_r32_0F0D", Code.RESERVEDNOP_RM32_R32_0F0D); + map.put("Reservednop_rm64_r64_0F0D", Code.RESERVEDNOP_RM64_R64_0F0D); + map.put("Prefetch_m8", Code.PREFETCH_M8); + map.put("Prefetchw_m8", Code.PREFETCHW_M8); + map.put("Prefetchwt1_m8", Code.PREFETCHWT1_M8); + map.put("Femms", Code.FEMMS); + map.put("Umov_rm8_r8", Code.UMOV_RM8_R8); + map.put("Umov_rm16_r16", Code.UMOV_RM16_R16); + map.put("Umov_rm32_r32", Code.UMOV_RM32_R32); + map.put("Umov_r8_rm8", Code.UMOV_R8_RM8); + map.put("Umov_r16_rm16", Code.UMOV_R16_RM16); + map.put("Umov_r32_rm32", Code.UMOV_R32_RM32); + map.put("Movups_xmm_xmmm128", Code.MOVUPS_XMM_XMMM128); + map.put("VEX_Vmovups_xmm_xmmm128", Code.VEX_VMOVUPS_XMM_XMMM128); + map.put("VEX_Vmovups_ymm_ymmm256", Code.VEX_VMOVUPS_YMM_YMMM256); + map.put("EVEX_Vmovups_xmm_k1z_xmmm128", Code.EVEX_VMOVUPS_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovups_ymm_k1z_ymmm256", Code.EVEX_VMOVUPS_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovups_zmm_k1z_zmmm512", Code.EVEX_VMOVUPS_ZMM_K1Z_ZMMM512); + map.put("Movupd_xmm_xmmm128", Code.MOVUPD_XMM_XMMM128); + map.put("VEX_Vmovupd_xmm_xmmm128", Code.VEX_VMOVUPD_XMM_XMMM128); + map.put("VEX_Vmovupd_ymm_ymmm256", Code.VEX_VMOVUPD_YMM_YMMM256); + map.put("EVEX_Vmovupd_xmm_k1z_xmmm128", Code.EVEX_VMOVUPD_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovupd_ymm_k1z_ymmm256", Code.EVEX_VMOVUPD_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovupd_zmm_k1z_zmmm512", Code.EVEX_VMOVUPD_ZMM_K1Z_ZMMM512); + map.put("Movss_xmm_xmmm32", Code.MOVSS_XMM_XMMM32); + map.put("VEX_Vmovss_xmm_xmm_xmm", Code.VEX_VMOVSS_XMM_XMM_XMM); + map.put("VEX_Vmovss_xmm_m32", Code.VEX_VMOVSS_XMM_M32); + map.put("EVEX_Vmovss_xmm_k1z_xmm_xmm", Code.EVEX_VMOVSS_XMM_K1Z_XMM_XMM); + map.put("EVEX_Vmovss_xmm_k1z_m32", Code.EVEX_VMOVSS_XMM_K1Z_M32); + map.put("Movsd_xmm_xmmm64", Code.MOVSD_XMM_XMMM64); + map.put("VEX_Vmovsd_xmm_xmm_xmm", Code.VEX_VMOVSD_XMM_XMM_XMM); + map.put("VEX_Vmovsd_xmm_m64", Code.VEX_VMOVSD_XMM_M64); + map.put("EVEX_Vmovsd_xmm_k1z_xmm_xmm", Code.EVEX_VMOVSD_XMM_K1Z_XMM_XMM); + map.put("EVEX_Vmovsd_xmm_k1z_m64", Code.EVEX_VMOVSD_XMM_K1Z_M64); + map.put("Movups_xmmm128_xmm", Code.MOVUPS_XMMM128_XMM); + map.put("VEX_Vmovups_xmmm128_xmm", Code.VEX_VMOVUPS_XMMM128_XMM); + map.put("VEX_Vmovups_ymmm256_ymm", Code.VEX_VMOVUPS_YMMM256_YMM); + map.put("EVEX_Vmovups_xmmm128_k1z_xmm", Code.EVEX_VMOVUPS_XMMM128_K1Z_XMM); + map.put("EVEX_Vmovups_ymmm256_k1z_ymm", Code.EVEX_VMOVUPS_YMMM256_K1Z_YMM); + map.put("EVEX_Vmovups_zmmm512_k1z_zmm", Code.EVEX_VMOVUPS_ZMMM512_K1Z_ZMM); + map.put("Movupd_xmmm128_xmm", Code.MOVUPD_XMMM128_XMM); + map.put("VEX_Vmovupd_xmmm128_xmm", Code.VEX_VMOVUPD_XMMM128_XMM); + map.put("VEX_Vmovupd_ymmm256_ymm", Code.VEX_VMOVUPD_YMMM256_YMM); + map.put("EVEX_Vmovupd_xmmm128_k1z_xmm", Code.EVEX_VMOVUPD_XMMM128_K1Z_XMM); + map.put("EVEX_Vmovupd_ymmm256_k1z_ymm", Code.EVEX_VMOVUPD_YMMM256_K1Z_YMM); + map.put("EVEX_Vmovupd_zmmm512_k1z_zmm", Code.EVEX_VMOVUPD_ZMMM512_K1Z_ZMM); + map.put("Movss_xmmm32_xmm", Code.MOVSS_XMMM32_XMM); + map.put("VEX_Vmovss_xmm_xmm_xmm_0F11", Code.VEX_VMOVSS_XMM_XMM_XMM_0F11); + map.put("VEX_Vmovss_m32_xmm", Code.VEX_VMOVSS_M32_XMM); + map.put("EVEX_Vmovss_xmm_k1z_xmm_xmm_0F11", Code.EVEX_VMOVSS_XMM_K1Z_XMM_XMM_0F11); + map.put("EVEX_Vmovss_m32_k1_xmm", Code.EVEX_VMOVSS_M32_K1_XMM); + map.put("Movsd_xmmm64_xmm", Code.MOVSD_XMMM64_XMM); + map.put("VEX_Vmovsd_xmm_xmm_xmm_0F11", Code.VEX_VMOVSD_XMM_XMM_XMM_0F11); + map.put("VEX_Vmovsd_m64_xmm", Code.VEX_VMOVSD_M64_XMM); + map.put("EVEX_Vmovsd_xmm_k1z_xmm_xmm_0F11", Code.EVEX_VMOVSD_XMM_K1Z_XMM_XMM_0F11); + map.put("EVEX_Vmovsd_m64_k1_xmm", Code.EVEX_VMOVSD_M64_K1_XMM); + map.put("Movhlps_xmm_xmm", Code.MOVHLPS_XMM_XMM); + map.put("Movlps_xmm_m64", Code.MOVLPS_XMM_M64); + map.put("VEX_Vmovhlps_xmm_xmm_xmm", Code.VEX_VMOVHLPS_XMM_XMM_XMM); + map.put("VEX_Vmovlps_xmm_xmm_m64", Code.VEX_VMOVLPS_XMM_XMM_M64); + map.put("EVEX_Vmovhlps_xmm_xmm_xmm", Code.EVEX_VMOVHLPS_XMM_XMM_XMM); + map.put("EVEX_Vmovlps_xmm_xmm_m64", Code.EVEX_VMOVLPS_XMM_XMM_M64); + map.put("Movlpd_xmm_m64", Code.MOVLPD_XMM_M64); + map.put("VEX_Vmovlpd_xmm_xmm_m64", Code.VEX_VMOVLPD_XMM_XMM_M64); + map.put("EVEX_Vmovlpd_xmm_xmm_m64", Code.EVEX_VMOVLPD_XMM_XMM_M64); + map.put("Movsldup_xmm_xmmm128", Code.MOVSLDUP_XMM_XMMM128); + map.put("VEX_Vmovsldup_xmm_xmmm128", Code.VEX_VMOVSLDUP_XMM_XMMM128); + map.put("VEX_Vmovsldup_ymm_ymmm256", Code.VEX_VMOVSLDUP_YMM_YMMM256); + map.put("EVEX_Vmovsldup_xmm_k1z_xmmm128", Code.EVEX_VMOVSLDUP_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovsldup_ymm_k1z_ymmm256", Code.EVEX_VMOVSLDUP_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovsldup_zmm_k1z_zmmm512", Code.EVEX_VMOVSLDUP_ZMM_K1Z_ZMMM512); + map.put("Movddup_xmm_xmmm64", Code.MOVDDUP_XMM_XMMM64); + map.put("VEX_Vmovddup_xmm_xmmm64", Code.VEX_VMOVDDUP_XMM_XMMM64); + map.put("VEX_Vmovddup_ymm_ymmm256", Code.VEX_VMOVDDUP_YMM_YMMM256); + map.put("EVEX_Vmovddup_xmm_k1z_xmmm64", Code.EVEX_VMOVDDUP_XMM_K1Z_XMMM64); + map.put("EVEX_Vmovddup_ymm_k1z_ymmm256", Code.EVEX_VMOVDDUP_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovddup_zmm_k1z_zmmm512", Code.EVEX_VMOVDDUP_ZMM_K1Z_ZMMM512); + map.put("Movlps_m64_xmm", Code.MOVLPS_M64_XMM); + map.put("VEX_Vmovlps_m64_xmm", Code.VEX_VMOVLPS_M64_XMM); + map.put("EVEX_Vmovlps_m64_xmm", Code.EVEX_VMOVLPS_M64_XMM); + map.put("Movlpd_m64_xmm", Code.MOVLPD_M64_XMM); + map.put("VEX_Vmovlpd_m64_xmm", Code.VEX_VMOVLPD_M64_XMM); + map.put("EVEX_Vmovlpd_m64_xmm", Code.EVEX_VMOVLPD_M64_XMM); + map.put("Unpcklps_xmm_xmmm128", Code.UNPCKLPS_XMM_XMMM128); + map.put("VEX_Vunpcklps_xmm_xmm_xmmm128", Code.VEX_VUNPCKLPS_XMM_XMM_XMMM128); + map.put("VEX_Vunpcklps_ymm_ymm_ymmm256", Code.VEX_VUNPCKLPS_YMM_YMM_YMMM256); + map.put("EVEX_Vunpcklps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VUNPCKLPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vunpcklps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VUNPCKLPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vunpcklps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VUNPCKLPS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Unpcklpd_xmm_xmmm128", Code.UNPCKLPD_XMM_XMMM128); + map.put("VEX_Vunpcklpd_xmm_xmm_xmmm128", Code.VEX_VUNPCKLPD_XMM_XMM_XMMM128); + map.put("VEX_Vunpcklpd_ymm_ymm_ymmm256", Code.VEX_VUNPCKLPD_YMM_YMM_YMMM256); + map.put("EVEX_Vunpcklpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VUNPCKLPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vunpcklpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VUNPCKLPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vunpcklpd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VUNPCKLPD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Unpckhps_xmm_xmmm128", Code.UNPCKHPS_XMM_XMMM128); + map.put("VEX_Vunpckhps_xmm_xmm_xmmm128", Code.VEX_VUNPCKHPS_XMM_XMM_XMMM128); + map.put("VEX_Vunpckhps_ymm_ymm_ymmm256", Code.VEX_VUNPCKHPS_YMM_YMM_YMMM256); + map.put("EVEX_Vunpckhps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VUNPCKHPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vunpckhps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VUNPCKHPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vunpckhps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VUNPCKHPS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Unpckhpd_xmm_xmmm128", Code.UNPCKHPD_XMM_XMMM128); + map.put("VEX_Vunpckhpd_xmm_xmm_xmmm128", Code.VEX_VUNPCKHPD_XMM_XMM_XMMM128); + map.put("VEX_Vunpckhpd_ymm_ymm_ymmm256", Code.VEX_VUNPCKHPD_YMM_YMM_YMMM256); + map.put("EVEX_Vunpckhpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VUNPCKHPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vunpckhpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VUNPCKHPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vunpckhpd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VUNPCKHPD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Movlhps_xmm_xmm", Code.MOVLHPS_XMM_XMM); + map.put("VEX_Vmovlhps_xmm_xmm_xmm", Code.VEX_VMOVLHPS_XMM_XMM_XMM); + map.put("EVEX_Vmovlhps_xmm_xmm_xmm", Code.EVEX_VMOVLHPS_XMM_XMM_XMM); + map.put("Movhps_xmm_m64", Code.MOVHPS_XMM_M64); + map.put("VEX_Vmovhps_xmm_xmm_m64", Code.VEX_VMOVHPS_XMM_XMM_M64); + map.put("EVEX_Vmovhps_xmm_xmm_m64", Code.EVEX_VMOVHPS_XMM_XMM_M64); + map.put("Movhpd_xmm_m64", Code.MOVHPD_XMM_M64); + map.put("VEX_Vmovhpd_xmm_xmm_m64", Code.VEX_VMOVHPD_XMM_XMM_M64); + map.put("EVEX_Vmovhpd_xmm_xmm_m64", Code.EVEX_VMOVHPD_XMM_XMM_M64); + map.put("Movshdup_xmm_xmmm128", Code.MOVSHDUP_XMM_XMMM128); + map.put("VEX_Vmovshdup_xmm_xmmm128", Code.VEX_VMOVSHDUP_XMM_XMMM128); + map.put("VEX_Vmovshdup_ymm_ymmm256", Code.VEX_VMOVSHDUP_YMM_YMMM256); + } + + private static void initMap2(HashMap map) { + map.put("EVEX_Vmovshdup_xmm_k1z_xmmm128", Code.EVEX_VMOVSHDUP_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovshdup_ymm_k1z_ymmm256", Code.EVEX_VMOVSHDUP_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovshdup_zmm_k1z_zmmm512", Code.EVEX_VMOVSHDUP_ZMM_K1Z_ZMMM512); + map.put("Movhps_m64_xmm", Code.MOVHPS_M64_XMM); + map.put("VEX_Vmovhps_m64_xmm", Code.VEX_VMOVHPS_M64_XMM); + map.put("EVEX_Vmovhps_m64_xmm", Code.EVEX_VMOVHPS_M64_XMM); + map.put("Movhpd_m64_xmm", Code.MOVHPD_M64_XMM); + map.put("VEX_Vmovhpd_m64_xmm", Code.VEX_VMOVHPD_M64_XMM); + map.put("EVEX_Vmovhpd_m64_xmm", Code.EVEX_VMOVHPD_M64_XMM); + map.put("Reservednop_rm16_r16_0F18", Code.RESERVEDNOP_RM16_R16_0F18); + map.put("Reservednop_rm32_r32_0F18", Code.RESERVEDNOP_RM32_R32_0F18); + map.put("Reservednop_rm64_r64_0F18", Code.RESERVEDNOP_RM64_R64_0F18); + map.put("Reservednop_rm16_r16_0F19", Code.RESERVEDNOP_RM16_R16_0F19); + map.put("Reservednop_rm32_r32_0F19", Code.RESERVEDNOP_RM32_R32_0F19); + map.put("Reservednop_rm64_r64_0F19", Code.RESERVEDNOP_RM64_R64_0F19); + map.put("Reservednop_rm16_r16_0F1A", Code.RESERVEDNOP_RM16_R16_0F1A); + map.put("Reservednop_rm32_r32_0F1A", Code.RESERVEDNOP_RM32_R32_0F1A); + map.put("Reservednop_rm64_r64_0F1A", Code.RESERVEDNOP_RM64_R64_0F1A); + map.put("Reservednop_rm16_r16_0F1B", Code.RESERVEDNOP_RM16_R16_0F1B); + map.put("Reservednop_rm32_r32_0F1B", Code.RESERVEDNOP_RM32_R32_0F1B); + map.put("Reservednop_rm64_r64_0F1B", Code.RESERVEDNOP_RM64_R64_0F1B); + map.put("Reservednop_rm16_r16_0F1C", Code.RESERVEDNOP_RM16_R16_0F1C); + map.put("Reservednop_rm32_r32_0F1C", Code.RESERVEDNOP_RM32_R32_0F1C); + map.put("Reservednop_rm64_r64_0F1C", Code.RESERVEDNOP_RM64_R64_0F1C); + map.put("Reservednop_rm16_r16_0F1D", Code.RESERVEDNOP_RM16_R16_0F1D); + map.put("Reservednop_rm32_r32_0F1D", Code.RESERVEDNOP_RM32_R32_0F1D); + map.put("Reservednop_rm64_r64_0F1D", Code.RESERVEDNOP_RM64_R64_0F1D); + map.put("Reservednop_rm16_r16_0F1E", Code.RESERVEDNOP_RM16_R16_0F1E); + map.put("Reservednop_rm32_r32_0F1E", Code.RESERVEDNOP_RM32_R32_0F1E); + map.put("Reservednop_rm64_r64_0F1E", Code.RESERVEDNOP_RM64_R64_0F1E); + map.put("Reservednop_rm16_r16_0F1F", Code.RESERVEDNOP_RM16_R16_0F1F); + map.put("Reservednop_rm32_r32_0F1F", Code.RESERVEDNOP_RM32_R32_0F1F); + map.put("Reservednop_rm64_r64_0F1F", Code.RESERVEDNOP_RM64_R64_0F1F); + map.put("Prefetchnta_m8", Code.PREFETCHNTA_M8); + map.put("Prefetcht0_m8", Code.PREFETCHT0_M8); + map.put("Prefetcht1_m8", Code.PREFETCHT1_M8); + map.put("Prefetcht2_m8", Code.PREFETCHT2_M8); + map.put("Bndldx_bnd_mib", Code.BNDLDX_BND_MIB); + map.put("Bndmov_bnd_bndm64", Code.BNDMOV_BND_BNDM64); + map.put("Bndmov_bnd_bndm128", Code.BNDMOV_BND_BNDM128); + map.put("Bndcl_bnd_rm32", Code.BNDCL_BND_RM32); + map.put("Bndcl_bnd_rm64", Code.BNDCL_BND_RM64); + map.put("Bndcu_bnd_rm32", Code.BNDCU_BND_RM32); + map.put("Bndcu_bnd_rm64", Code.BNDCU_BND_RM64); + map.put("Bndstx_mib_bnd", Code.BNDSTX_MIB_BND); + map.put("Bndmov_bndm64_bnd", Code.BNDMOV_BNDM64_BND); + map.put("Bndmov_bndm128_bnd", Code.BNDMOV_BNDM128_BND); + map.put("Bndmk_bnd_m32", Code.BNDMK_BND_M32); + map.put("Bndmk_bnd_m64", Code.BNDMK_BND_M64); + map.put("Bndcn_bnd_rm32", Code.BNDCN_BND_RM32); + map.put("Bndcn_bnd_rm64", Code.BNDCN_BND_RM64); + map.put("Cldemote_m8", Code.CLDEMOTE_M8); + map.put("Rdsspd_r32", Code.RDSSPD_R32); + map.put("Rdsspq_r64", Code.RDSSPQ_R64); + map.put("Endbr64", Code.ENDBR64); + map.put("Endbr32", Code.ENDBR32); + map.put("Nop_rm16", Code.NOP_RM16); + map.put("Nop_rm32", Code.NOP_RM32); + map.put("Nop_rm64", Code.NOP_RM64); + map.put("Mov_r32_cr", Code.MOV_R32_CR); + map.put("Mov_r64_cr", Code.MOV_R64_CR); + map.put("Mov_r32_dr", Code.MOV_R32_DR); + map.put("Mov_r64_dr", Code.MOV_R64_DR); + map.put("Mov_cr_r32", Code.MOV_CR_R32); + map.put("Mov_cr_r64", Code.MOV_CR_R64); + map.put("Mov_dr_r32", Code.MOV_DR_R32); + map.put("Mov_dr_r64", Code.MOV_DR_R64); + map.put("Mov_r32_tr", Code.MOV_R32_TR); + map.put("Mov_tr_r32", Code.MOV_TR_R32); + map.put("Movaps_xmm_xmmm128", Code.MOVAPS_XMM_XMMM128); + map.put("VEX_Vmovaps_xmm_xmmm128", Code.VEX_VMOVAPS_XMM_XMMM128); + map.put("VEX_Vmovaps_ymm_ymmm256", Code.VEX_VMOVAPS_YMM_YMMM256); + map.put("EVEX_Vmovaps_xmm_k1z_xmmm128", Code.EVEX_VMOVAPS_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovaps_ymm_k1z_ymmm256", Code.EVEX_VMOVAPS_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovaps_zmm_k1z_zmmm512", Code.EVEX_VMOVAPS_ZMM_K1Z_ZMMM512); + map.put("Movapd_xmm_xmmm128", Code.MOVAPD_XMM_XMMM128); + map.put("VEX_Vmovapd_xmm_xmmm128", Code.VEX_VMOVAPD_XMM_XMMM128); + map.put("VEX_Vmovapd_ymm_ymmm256", Code.VEX_VMOVAPD_YMM_YMMM256); + map.put("EVEX_Vmovapd_xmm_k1z_xmmm128", Code.EVEX_VMOVAPD_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovapd_ymm_k1z_ymmm256", Code.EVEX_VMOVAPD_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovapd_zmm_k1z_zmmm512", Code.EVEX_VMOVAPD_ZMM_K1Z_ZMMM512); + map.put("Movaps_xmmm128_xmm", Code.MOVAPS_XMMM128_XMM); + map.put("VEX_Vmovaps_xmmm128_xmm", Code.VEX_VMOVAPS_XMMM128_XMM); + map.put("VEX_Vmovaps_ymmm256_ymm", Code.VEX_VMOVAPS_YMMM256_YMM); + map.put("EVEX_Vmovaps_xmmm128_k1z_xmm", Code.EVEX_VMOVAPS_XMMM128_K1Z_XMM); + map.put("EVEX_Vmovaps_ymmm256_k1z_ymm", Code.EVEX_VMOVAPS_YMMM256_K1Z_YMM); + map.put("EVEX_Vmovaps_zmmm512_k1z_zmm", Code.EVEX_VMOVAPS_ZMMM512_K1Z_ZMM); + map.put("Movapd_xmmm128_xmm", Code.MOVAPD_XMMM128_XMM); + map.put("VEX_Vmovapd_xmmm128_xmm", Code.VEX_VMOVAPD_XMMM128_XMM); + map.put("VEX_Vmovapd_ymmm256_ymm", Code.VEX_VMOVAPD_YMMM256_YMM); + map.put("EVEX_Vmovapd_xmmm128_k1z_xmm", Code.EVEX_VMOVAPD_XMMM128_K1Z_XMM); + map.put("EVEX_Vmovapd_ymmm256_k1z_ymm", Code.EVEX_VMOVAPD_YMMM256_K1Z_YMM); + map.put("EVEX_Vmovapd_zmmm512_k1z_zmm", Code.EVEX_VMOVAPD_ZMMM512_K1Z_ZMM); + map.put("Cvtpi2ps_xmm_mmm64", Code.CVTPI2PS_XMM_MMM64); + map.put("Cvtpi2pd_xmm_mmm64", Code.CVTPI2PD_XMM_MMM64); + map.put("Cvtsi2ss_xmm_rm32", Code.CVTSI2SS_XMM_RM32); + map.put("Cvtsi2ss_xmm_rm64", Code.CVTSI2SS_XMM_RM64); + map.put("VEX_Vcvtsi2ss_xmm_xmm_rm32", Code.VEX_VCVTSI2SS_XMM_XMM_RM32); + map.put("VEX_Vcvtsi2ss_xmm_xmm_rm64", Code.VEX_VCVTSI2SS_XMM_XMM_RM64); + map.put("EVEX_Vcvtsi2ss_xmm_xmm_rm32_er", Code.EVEX_VCVTSI2SS_XMM_XMM_RM32_ER); + map.put("EVEX_Vcvtsi2ss_xmm_xmm_rm64_er", Code.EVEX_VCVTSI2SS_XMM_XMM_RM64_ER); + map.put("Cvtsi2sd_xmm_rm32", Code.CVTSI2SD_XMM_RM32); + map.put("Cvtsi2sd_xmm_rm64", Code.CVTSI2SD_XMM_RM64); + map.put("VEX_Vcvtsi2sd_xmm_xmm_rm32", Code.VEX_VCVTSI2SD_XMM_XMM_RM32); + map.put("VEX_Vcvtsi2sd_xmm_xmm_rm64", Code.VEX_VCVTSI2SD_XMM_XMM_RM64); + map.put("EVEX_Vcvtsi2sd_xmm_xmm_rm32_er", Code.EVEX_VCVTSI2SD_XMM_XMM_RM32_ER); + map.put("EVEX_Vcvtsi2sd_xmm_xmm_rm64_er", Code.EVEX_VCVTSI2SD_XMM_XMM_RM64_ER); + map.put("Movntps_m128_xmm", Code.MOVNTPS_M128_XMM); + map.put("VEX_Vmovntps_m128_xmm", Code.VEX_VMOVNTPS_M128_XMM); + map.put("VEX_Vmovntps_m256_ymm", Code.VEX_VMOVNTPS_M256_YMM); + map.put("EVEX_Vmovntps_m128_xmm", Code.EVEX_VMOVNTPS_M128_XMM); + map.put("EVEX_Vmovntps_m256_ymm", Code.EVEX_VMOVNTPS_M256_YMM); + map.put("EVEX_Vmovntps_m512_zmm", Code.EVEX_VMOVNTPS_M512_ZMM); + map.put("Movntpd_m128_xmm", Code.MOVNTPD_M128_XMM); + map.put("VEX_Vmovntpd_m128_xmm", Code.VEX_VMOVNTPD_M128_XMM); + map.put("VEX_Vmovntpd_m256_ymm", Code.VEX_VMOVNTPD_M256_YMM); + map.put("EVEX_Vmovntpd_m128_xmm", Code.EVEX_VMOVNTPD_M128_XMM); + map.put("EVEX_Vmovntpd_m256_ymm", Code.EVEX_VMOVNTPD_M256_YMM); + map.put("EVEX_Vmovntpd_m512_zmm", Code.EVEX_VMOVNTPD_M512_ZMM); + map.put("Movntss_m32_xmm", Code.MOVNTSS_M32_XMM); + map.put("Movntsd_m64_xmm", Code.MOVNTSD_M64_XMM); + map.put("Cvttps2pi_mm_xmmm64", Code.CVTTPS2PI_MM_XMMM64); + map.put("Cvttpd2pi_mm_xmmm128", Code.CVTTPD2PI_MM_XMMM128); + map.put("Cvttss2si_r32_xmmm32", Code.CVTTSS2SI_R32_XMMM32); + map.put("Cvttss2si_r64_xmmm32", Code.CVTTSS2SI_R64_XMMM32); + map.put("VEX_Vcvttss2si_r32_xmmm32", Code.VEX_VCVTTSS2SI_R32_XMMM32); + map.put("VEX_Vcvttss2si_r64_xmmm32", Code.VEX_VCVTTSS2SI_R64_XMMM32); + map.put("EVEX_Vcvttss2si_r32_xmmm32_sae", Code.EVEX_VCVTTSS2SI_R32_XMMM32_SAE); + map.put("EVEX_Vcvttss2si_r64_xmmm32_sae", Code.EVEX_VCVTTSS2SI_R64_XMMM32_SAE); + map.put("Cvttsd2si_r32_xmmm64", Code.CVTTSD2SI_R32_XMMM64); + map.put("Cvttsd2si_r64_xmmm64", Code.CVTTSD2SI_R64_XMMM64); + map.put("VEX_Vcvttsd2si_r32_xmmm64", Code.VEX_VCVTTSD2SI_R32_XMMM64); + map.put("VEX_Vcvttsd2si_r64_xmmm64", Code.VEX_VCVTTSD2SI_R64_XMMM64); + map.put("EVEX_Vcvttsd2si_r32_xmmm64_sae", Code.EVEX_VCVTTSD2SI_R32_XMMM64_SAE); + map.put("EVEX_Vcvttsd2si_r64_xmmm64_sae", Code.EVEX_VCVTTSD2SI_R64_XMMM64_SAE); + map.put("Cvtps2pi_mm_xmmm64", Code.CVTPS2PI_MM_XMMM64); + map.put("Cvtpd2pi_mm_xmmm128", Code.CVTPD2PI_MM_XMMM128); + map.put("Cvtss2si_r32_xmmm32", Code.CVTSS2SI_R32_XMMM32); + map.put("Cvtss2si_r64_xmmm32", Code.CVTSS2SI_R64_XMMM32); + map.put("VEX_Vcvtss2si_r32_xmmm32", Code.VEX_VCVTSS2SI_R32_XMMM32); + map.put("VEX_Vcvtss2si_r64_xmmm32", Code.VEX_VCVTSS2SI_R64_XMMM32); + map.put("EVEX_Vcvtss2si_r32_xmmm32_er", Code.EVEX_VCVTSS2SI_R32_XMMM32_ER); + map.put("EVEX_Vcvtss2si_r64_xmmm32_er", Code.EVEX_VCVTSS2SI_R64_XMMM32_ER); + map.put("Cvtsd2si_r32_xmmm64", Code.CVTSD2SI_R32_XMMM64); + map.put("Cvtsd2si_r64_xmmm64", Code.CVTSD2SI_R64_XMMM64); + map.put("VEX_Vcvtsd2si_r32_xmmm64", Code.VEX_VCVTSD2SI_R32_XMMM64); + map.put("VEX_Vcvtsd2si_r64_xmmm64", Code.VEX_VCVTSD2SI_R64_XMMM64); + map.put("EVEX_Vcvtsd2si_r32_xmmm64_er", Code.EVEX_VCVTSD2SI_R32_XMMM64_ER); + map.put("EVEX_Vcvtsd2si_r64_xmmm64_er", Code.EVEX_VCVTSD2SI_R64_XMMM64_ER); + map.put("Ucomiss_xmm_xmmm32", Code.UCOMISS_XMM_XMMM32); + map.put("VEX_Vucomiss_xmm_xmmm32", Code.VEX_VUCOMISS_XMM_XMMM32); + map.put("EVEX_Vucomiss_xmm_xmmm32_sae", Code.EVEX_VUCOMISS_XMM_XMMM32_SAE); + map.put("Ucomisd_xmm_xmmm64", Code.UCOMISD_XMM_XMMM64); + map.put("VEX_Vucomisd_xmm_xmmm64", Code.VEX_VUCOMISD_XMM_XMMM64); + map.put("EVEX_Vucomisd_xmm_xmmm64_sae", Code.EVEX_VUCOMISD_XMM_XMMM64_SAE); + map.put("Comiss_xmm_xmmm32", Code.COMISS_XMM_XMMM32); + map.put("Comisd_xmm_xmmm64", Code.COMISD_XMM_XMMM64); + map.put("VEX_Vcomiss_xmm_xmmm32", Code.VEX_VCOMISS_XMM_XMMM32); + map.put("VEX_Vcomisd_xmm_xmmm64", Code.VEX_VCOMISD_XMM_XMMM64); + map.put("EVEX_Vcomiss_xmm_xmmm32_sae", Code.EVEX_VCOMISS_XMM_XMMM32_SAE); + map.put("EVEX_Vcomisd_xmm_xmmm64_sae", Code.EVEX_VCOMISD_XMM_XMMM64_SAE); + map.put("Wrmsr", Code.WRMSR); + map.put("Rdtsc", Code.RDTSC); + map.put("Rdmsr", Code.RDMSR); + map.put("Rdpmc", Code.RDPMC); + map.put("Sysenter", Code.SYSENTER); + map.put("Sysexitd", Code.SYSEXITD); + map.put("Sysexitq", Code.SYSEXITQ); + map.put("Getsecd", Code.GETSECD); + map.put("Cmovo_r16_rm16", Code.CMOVO_R16_RM16); + map.put("Cmovo_r32_rm32", Code.CMOVO_R32_RM32); + map.put("Cmovo_r64_rm64", Code.CMOVO_R64_RM64); + map.put("Cmovno_r16_rm16", Code.CMOVNO_R16_RM16); + map.put("Cmovno_r32_rm32", Code.CMOVNO_R32_RM32); + map.put("Cmovno_r64_rm64", Code.CMOVNO_R64_RM64); + map.put("Cmovb_r16_rm16", Code.CMOVB_R16_RM16); + map.put("Cmovb_r32_rm32", Code.CMOVB_R32_RM32); + map.put("Cmovb_r64_rm64", Code.CMOVB_R64_RM64); + map.put("Cmovae_r16_rm16", Code.CMOVAE_R16_RM16); + map.put("Cmovae_r32_rm32", Code.CMOVAE_R32_RM32); + map.put("Cmovae_r64_rm64", Code.CMOVAE_R64_RM64); + map.put("Cmove_r16_rm16", Code.CMOVE_R16_RM16); + map.put("Cmove_r32_rm32", Code.CMOVE_R32_RM32); + map.put("Cmove_r64_rm64", Code.CMOVE_R64_RM64); + map.put("Cmovne_r16_rm16", Code.CMOVNE_R16_RM16); + map.put("Cmovne_r32_rm32", Code.CMOVNE_R32_RM32); + map.put("Cmovne_r64_rm64", Code.CMOVNE_R64_RM64); + map.put("Cmovbe_r16_rm16", Code.CMOVBE_R16_RM16); + map.put("Cmovbe_r32_rm32", Code.CMOVBE_R32_RM32); + map.put("Cmovbe_r64_rm64", Code.CMOVBE_R64_RM64); + map.put("Cmova_r16_rm16", Code.CMOVA_R16_RM16); + map.put("Cmova_r32_rm32", Code.CMOVA_R32_RM32); + map.put("Cmova_r64_rm64", Code.CMOVA_R64_RM64); + map.put("Cmovs_r16_rm16", Code.CMOVS_R16_RM16); + map.put("Cmovs_r32_rm32", Code.CMOVS_R32_RM32); + map.put("Cmovs_r64_rm64", Code.CMOVS_R64_RM64); + map.put("Cmovns_r16_rm16", Code.CMOVNS_R16_RM16); + map.put("Cmovns_r32_rm32", Code.CMOVNS_R32_RM32); + map.put("Cmovns_r64_rm64", Code.CMOVNS_R64_RM64); + map.put("Cmovp_r16_rm16", Code.CMOVP_R16_RM16); + map.put("Cmovp_r32_rm32", Code.CMOVP_R32_RM32); + map.put("Cmovp_r64_rm64", Code.CMOVP_R64_RM64); + map.put("Cmovnp_r16_rm16", Code.CMOVNP_R16_RM16); + map.put("Cmovnp_r32_rm32", Code.CMOVNP_R32_RM32); + map.put("Cmovnp_r64_rm64", Code.CMOVNP_R64_RM64); + map.put("Cmovl_r16_rm16", Code.CMOVL_R16_RM16); + map.put("Cmovl_r32_rm32", Code.CMOVL_R32_RM32); + map.put("Cmovl_r64_rm64", Code.CMOVL_R64_RM64); + map.put("Cmovge_r16_rm16", Code.CMOVGE_R16_RM16); + map.put("Cmovge_r32_rm32", Code.CMOVGE_R32_RM32); + map.put("Cmovge_r64_rm64", Code.CMOVGE_R64_RM64); + map.put("Cmovle_r16_rm16", Code.CMOVLE_R16_RM16); + map.put("Cmovle_r32_rm32", Code.CMOVLE_R32_RM32); + map.put("Cmovle_r64_rm64", Code.CMOVLE_R64_RM64); + map.put("Cmovg_r16_rm16", Code.CMOVG_R16_RM16); + map.put("Cmovg_r32_rm32", Code.CMOVG_R32_RM32); + map.put("Cmovg_r64_rm64", Code.CMOVG_R64_RM64); + map.put("VEX_Kandw_kr_kr_kr", Code.VEX_KANDW_KR_KR_KR); + map.put("VEX_Kandq_kr_kr_kr", Code.VEX_KANDQ_KR_KR_KR); + map.put("VEX_Kandb_kr_kr_kr", Code.VEX_KANDB_KR_KR_KR); + map.put("VEX_Kandd_kr_kr_kr", Code.VEX_KANDD_KR_KR_KR); + map.put("VEX_Kandnw_kr_kr_kr", Code.VEX_KANDNW_KR_KR_KR); + map.put("VEX_Kandnq_kr_kr_kr", Code.VEX_KANDNQ_KR_KR_KR); + map.put("VEX_Kandnb_kr_kr_kr", Code.VEX_KANDNB_KR_KR_KR); + map.put("VEX_Kandnd_kr_kr_kr", Code.VEX_KANDND_KR_KR_KR); + map.put("VEX_Knotw_kr_kr", Code.VEX_KNOTW_KR_KR); + map.put("VEX_Knotq_kr_kr", Code.VEX_KNOTQ_KR_KR); + map.put("VEX_Knotb_kr_kr", Code.VEX_KNOTB_KR_KR); + map.put("VEX_Knotd_kr_kr", Code.VEX_KNOTD_KR_KR); + map.put("VEX_Korw_kr_kr_kr", Code.VEX_KORW_KR_KR_KR); + map.put("VEX_Korq_kr_kr_kr", Code.VEX_KORQ_KR_KR_KR); + map.put("VEX_Korb_kr_kr_kr", Code.VEX_KORB_KR_KR_KR); + map.put("VEX_Kord_kr_kr_kr", Code.VEX_KORD_KR_KR_KR); + map.put("VEX_Kxnorw_kr_kr_kr", Code.VEX_KXNORW_KR_KR_KR); + map.put("VEX_Kxnorq_kr_kr_kr", Code.VEX_KXNORQ_KR_KR_KR); + map.put("VEX_Kxnorb_kr_kr_kr", Code.VEX_KXNORB_KR_KR_KR); + map.put("VEX_Kxnord_kr_kr_kr", Code.VEX_KXNORD_KR_KR_KR); + map.put("VEX_Kxorw_kr_kr_kr", Code.VEX_KXORW_KR_KR_KR); + map.put("VEX_Kxorq_kr_kr_kr", Code.VEX_KXORQ_KR_KR_KR); + map.put("VEX_Kxorb_kr_kr_kr", Code.VEX_KXORB_KR_KR_KR); + map.put("VEX_Kxord_kr_kr_kr", Code.VEX_KXORD_KR_KR_KR); + map.put("VEX_Kaddw_kr_kr_kr", Code.VEX_KADDW_KR_KR_KR); + map.put("VEX_Kaddq_kr_kr_kr", Code.VEX_KADDQ_KR_KR_KR); + map.put("VEX_Kaddb_kr_kr_kr", Code.VEX_KADDB_KR_KR_KR); + map.put("VEX_Kaddd_kr_kr_kr", Code.VEX_KADDD_KR_KR_KR); + map.put("VEX_Kunpckwd_kr_kr_kr", Code.VEX_KUNPCKWD_KR_KR_KR); + map.put("VEX_Kunpckdq_kr_kr_kr", Code.VEX_KUNPCKDQ_KR_KR_KR); + map.put("VEX_Kunpckbw_kr_kr_kr", Code.VEX_KUNPCKBW_KR_KR_KR); + map.put("Movmskps_r32_xmm", Code.MOVMSKPS_R32_XMM); + map.put("Movmskps_r64_xmm", Code.MOVMSKPS_R64_XMM); + map.put("VEX_Vmovmskps_r32_xmm", Code.VEX_VMOVMSKPS_R32_XMM); + map.put("VEX_Vmovmskps_r64_xmm", Code.VEX_VMOVMSKPS_R64_XMM); + map.put("VEX_Vmovmskps_r32_ymm", Code.VEX_VMOVMSKPS_R32_YMM); + map.put("VEX_Vmovmskps_r64_ymm", Code.VEX_VMOVMSKPS_R64_YMM); + map.put("Movmskpd_r32_xmm", Code.MOVMSKPD_R32_XMM); + map.put("Movmskpd_r64_xmm", Code.MOVMSKPD_R64_XMM); + map.put("VEX_Vmovmskpd_r32_xmm", Code.VEX_VMOVMSKPD_R32_XMM); + map.put("VEX_Vmovmskpd_r64_xmm", Code.VEX_VMOVMSKPD_R64_XMM); + map.put("VEX_Vmovmskpd_r32_ymm", Code.VEX_VMOVMSKPD_R32_YMM); + map.put("VEX_Vmovmskpd_r64_ymm", Code.VEX_VMOVMSKPD_R64_YMM); + map.put("Sqrtps_xmm_xmmm128", Code.SQRTPS_XMM_XMMM128); + map.put("VEX_Vsqrtps_xmm_xmmm128", Code.VEX_VSQRTPS_XMM_XMMM128); + map.put("VEX_Vsqrtps_ymm_ymmm256", Code.VEX_VSQRTPS_YMM_YMMM256); + map.put("EVEX_Vsqrtps_xmm_k1z_xmmm128b32", Code.EVEX_VSQRTPS_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vsqrtps_ymm_k1z_ymmm256b32", Code.EVEX_VSQRTPS_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vsqrtps_zmm_k1z_zmmm512b32_er", Code.EVEX_VSQRTPS_ZMM_K1Z_ZMMM512B32_ER); + map.put("Sqrtpd_xmm_xmmm128", Code.SQRTPD_XMM_XMMM128); + map.put("VEX_Vsqrtpd_xmm_xmmm128", Code.VEX_VSQRTPD_XMM_XMMM128); + map.put("VEX_Vsqrtpd_ymm_ymmm256", Code.VEX_VSQRTPD_YMM_YMMM256); + map.put("EVEX_Vsqrtpd_xmm_k1z_xmmm128b64", Code.EVEX_VSQRTPD_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vsqrtpd_ymm_k1z_ymmm256b64", Code.EVEX_VSQRTPD_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vsqrtpd_zmm_k1z_zmmm512b64_er", Code.EVEX_VSQRTPD_ZMM_K1Z_ZMMM512B64_ER); + map.put("Sqrtss_xmm_xmmm32", Code.SQRTSS_XMM_XMMM32); + map.put("VEX_Vsqrtss_xmm_xmm_xmmm32", Code.VEX_VSQRTSS_XMM_XMM_XMMM32); + map.put("EVEX_Vsqrtss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VSQRTSS_XMM_K1Z_XMM_XMMM32_ER); + map.put("Sqrtsd_xmm_xmmm64", Code.SQRTSD_XMM_XMMM64); + map.put("VEX_Vsqrtsd_xmm_xmm_xmmm64", Code.VEX_VSQRTSD_XMM_XMM_XMMM64); + map.put("EVEX_Vsqrtsd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VSQRTSD_XMM_K1Z_XMM_XMMM64_ER); + map.put("Rsqrtps_xmm_xmmm128", Code.RSQRTPS_XMM_XMMM128); + map.put("VEX_Vrsqrtps_xmm_xmmm128", Code.VEX_VRSQRTPS_XMM_XMMM128); + map.put("VEX_Vrsqrtps_ymm_ymmm256", Code.VEX_VRSQRTPS_YMM_YMMM256); + map.put("Rsqrtss_xmm_xmmm32", Code.RSQRTSS_XMM_XMMM32); + map.put("VEX_Vrsqrtss_xmm_xmm_xmmm32", Code.VEX_VRSQRTSS_XMM_XMM_XMMM32); + map.put("Rcpps_xmm_xmmm128", Code.RCPPS_XMM_XMMM128); + map.put("VEX_Vrcpps_xmm_xmmm128", Code.VEX_VRCPPS_XMM_XMMM128); + map.put("VEX_Vrcpps_ymm_ymmm256", Code.VEX_VRCPPS_YMM_YMMM256); + map.put("Rcpss_xmm_xmmm32", Code.RCPSS_XMM_XMMM32); + map.put("VEX_Vrcpss_xmm_xmm_xmmm32", Code.VEX_VRCPSS_XMM_XMM_XMMM32); + map.put("Andps_xmm_xmmm128", Code.ANDPS_XMM_XMMM128); + map.put("VEX_Vandps_xmm_xmm_xmmm128", Code.VEX_VANDPS_XMM_XMM_XMMM128); + map.put("VEX_Vandps_ymm_ymm_ymmm256", Code.VEX_VANDPS_YMM_YMM_YMMM256); + map.put("EVEX_Vandps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VANDPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vandps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VANDPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vandps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VANDPS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Andpd_xmm_xmmm128", Code.ANDPD_XMM_XMMM128); + map.put("VEX_Vandpd_xmm_xmm_xmmm128", Code.VEX_VANDPD_XMM_XMM_XMMM128); + map.put("VEX_Vandpd_ymm_ymm_ymmm256", Code.VEX_VANDPD_YMM_YMM_YMMM256); + map.put("EVEX_Vandpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VANDPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vandpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VANDPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vandpd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VANDPD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Andnps_xmm_xmmm128", Code.ANDNPS_XMM_XMMM128); + map.put("VEX_Vandnps_xmm_xmm_xmmm128", Code.VEX_VANDNPS_XMM_XMM_XMMM128); + map.put("VEX_Vandnps_ymm_ymm_ymmm256", Code.VEX_VANDNPS_YMM_YMM_YMMM256); + map.put("EVEX_Vandnps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VANDNPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vandnps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VANDNPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vandnps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VANDNPS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Andnpd_xmm_xmmm128", Code.ANDNPD_XMM_XMMM128); + map.put("VEX_Vandnpd_xmm_xmm_xmmm128", Code.VEX_VANDNPD_XMM_XMM_XMMM128); + map.put("VEX_Vandnpd_ymm_ymm_ymmm256", Code.VEX_VANDNPD_YMM_YMM_YMMM256); + map.put("EVEX_Vandnpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VANDNPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vandnpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VANDNPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vandnpd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VANDNPD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Orps_xmm_xmmm128", Code.ORPS_XMM_XMMM128); + map.put("VEX_Vorps_xmm_xmm_xmmm128", Code.VEX_VORPS_XMM_XMM_XMMM128); + map.put("VEX_Vorps_ymm_ymm_ymmm256", Code.VEX_VORPS_YMM_YMM_YMMM256); + map.put("EVEX_Vorps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VORPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vorps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VORPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vorps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VORPS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Orpd_xmm_xmmm128", Code.ORPD_XMM_XMMM128); + map.put("VEX_Vorpd_xmm_xmm_xmmm128", Code.VEX_VORPD_XMM_XMM_XMMM128); + map.put("VEX_Vorpd_ymm_ymm_ymmm256", Code.VEX_VORPD_YMM_YMM_YMMM256); + map.put("EVEX_Vorpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VORPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vorpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VORPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vorpd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VORPD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Xorps_xmm_xmmm128", Code.XORPS_XMM_XMMM128); + map.put("VEX_Vxorps_xmm_xmm_xmmm128", Code.VEX_VXORPS_XMM_XMM_XMMM128); + map.put("VEX_Vxorps_ymm_ymm_ymmm256", Code.VEX_VXORPS_YMM_YMM_YMMM256); + map.put("EVEX_Vxorps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VXORPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vxorps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VXORPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vxorps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VXORPS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Xorpd_xmm_xmmm128", Code.XORPD_XMM_XMMM128); + map.put("VEX_Vxorpd_xmm_xmm_xmmm128", Code.VEX_VXORPD_XMM_XMM_XMMM128); + map.put("VEX_Vxorpd_ymm_ymm_ymmm256", Code.VEX_VXORPD_YMM_YMM_YMMM256); + map.put("EVEX_Vxorpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VXORPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vxorpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VXORPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vxorpd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VXORPD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Addps_xmm_xmmm128", Code.ADDPS_XMM_XMMM128); + map.put("VEX_Vaddps_xmm_xmm_xmmm128", Code.VEX_VADDPS_XMM_XMM_XMMM128); + map.put("VEX_Vaddps_ymm_ymm_ymmm256", Code.VEX_VADDPS_YMM_YMM_YMMM256); + map.put("EVEX_Vaddps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VADDPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vaddps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VADDPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vaddps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VADDPS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("Addpd_xmm_xmmm128", Code.ADDPD_XMM_XMMM128); + map.put("VEX_Vaddpd_xmm_xmm_xmmm128", Code.VEX_VADDPD_XMM_XMM_XMMM128); + map.put("VEX_Vaddpd_ymm_ymm_ymmm256", Code.VEX_VADDPD_YMM_YMM_YMMM256); + map.put("EVEX_Vaddpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VADDPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vaddpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VADDPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vaddpd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VADDPD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("Addss_xmm_xmmm32", Code.ADDSS_XMM_XMMM32); + map.put("VEX_Vaddss_xmm_xmm_xmmm32", Code.VEX_VADDSS_XMM_XMM_XMMM32); + map.put("EVEX_Vaddss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VADDSS_XMM_K1Z_XMM_XMMM32_ER); + map.put("Addsd_xmm_xmmm64", Code.ADDSD_XMM_XMMM64); + map.put("VEX_Vaddsd_xmm_xmm_xmmm64", Code.VEX_VADDSD_XMM_XMM_XMMM64); + map.put("EVEX_Vaddsd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VADDSD_XMM_K1Z_XMM_XMMM64_ER); + map.put("Mulps_xmm_xmmm128", Code.MULPS_XMM_XMMM128); + map.put("VEX_Vmulps_xmm_xmm_xmmm128", Code.VEX_VMULPS_XMM_XMM_XMMM128); + map.put("VEX_Vmulps_ymm_ymm_ymmm256", Code.VEX_VMULPS_YMM_YMM_YMMM256); + map.put("EVEX_Vmulps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VMULPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vmulps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VMULPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vmulps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VMULPS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("Mulpd_xmm_xmmm128", Code.MULPD_XMM_XMMM128); + map.put("VEX_Vmulpd_xmm_xmm_xmmm128", Code.VEX_VMULPD_XMM_XMM_XMMM128); + map.put("VEX_Vmulpd_ymm_ymm_ymmm256", Code.VEX_VMULPD_YMM_YMM_YMMM256); + map.put("EVEX_Vmulpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VMULPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vmulpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VMULPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vmulpd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VMULPD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("Mulss_xmm_xmmm32", Code.MULSS_XMM_XMMM32); + map.put("VEX_Vmulss_xmm_xmm_xmmm32", Code.VEX_VMULSS_XMM_XMM_XMMM32); + map.put("EVEX_Vmulss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VMULSS_XMM_K1Z_XMM_XMMM32_ER); + map.put("Mulsd_xmm_xmmm64", Code.MULSD_XMM_XMMM64); + map.put("VEX_Vmulsd_xmm_xmm_xmmm64", Code.VEX_VMULSD_XMM_XMM_XMMM64); + map.put("EVEX_Vmulsd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VMULSD_XMM_K1Z_XMM_XMMM64_ER); + map.put("Cvtps2pd_xmm_xmmm64", Code.CVTPS2PD_XMM_XMMM64); + map.put("VEX_Vcvtps2pd_xmm_xmmm64", Code.VEX_VCVTPS2PD_XMM_XMMM64); + map.put("VEX_Vcvtps2pd_ymm_xmmm128", Code.VEX_VCVTPS2PD_YMM_XMMM128); + map.put("EVEX_Vcvtps2pd_xmm_k1z_xmmm64b32", Code.EVEX_VCVTPS2PD_XMM_K1Z_XMMM64B32); + map.put("EVEX_Vcvtps2pd_ymm_k1z_xmmm128b32", Code.EVEX_VCVTPS2PD_YMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtps2pd_zmm_k1z_ymmm256b32_sae", Code.EVEX_VCVTPS2PD_ZMM_K1Z_YMMM256B32_SAE); + map.put("Cvtpd2ps_xmm_xmmm128", Code.CVTPD2PS_XMM_XMMM128); + map.put("VEX_Vcvtpd2ps_xmm_xmmm128", Code.VEX_VCVTPD2PS_XMM_XMMM128); + map.put("VEX_Vcvtpd2ps_xmm_ymmm256", Code.VEX_VCVTPD2PS_XMM_YMMM256); + map.put("EVEX_Vcvtpd2ps_xmm_k1z_xmmm128b64", Code.EVEX_VCVTPD2PS_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtpd2ps_xmm_k1z_ymmm256b64", Code.EVEX_VCVTPD2PS_XMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtpd2ps_ymm_k1z_zmmm512b64_er", Code.EVEX_VCVTPD2PS_YMM_K1Z_ZMMM512B64_ER); + map.put("Cvtss2sd_xmm_xmmm32", Code.CVTSS2SD_XMM_XMMM32); + map.put("VEX_Vcvtss2sd_xmm_xmm_xmmm32", Code.VEX_VCVTSS2SD_XMM_XMM_XMMM32); + map.put("EVEX_Vcvtss2sd_xmm_k1z_xmm_xmmm32_sae", Code.EVEX_VCVTSS2SD_XMM_K1Z_XMM_XMMM32_SAE); + map.put("Cvtsd2ss_xmm_xmmm64", Code.CVTSD2SS_XMM_XMMM64); + map.put("VEX_Vcvtsd2ss_xmm_xmm_xmmm64", Code.VEX_VCVTSD2SS_XMM_XMM_XMMM64); + map.put("EVEX_Vcvtsd2ss_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VCVTSD2SS_XMM_K1Z_XMM_XMMM64_ER); + map.put("Cvtdq2ps_xmm_xmmm128", Code.CVTDQ2PS_XMM_XMMM128); + map.put("VEX_Vcvtdq2ps_xmm_xmmm128", Code.VEX_VCVTDQ2PS_XMM_XMMM128); + map.put("VEX_Vcvtdq2ps_ymm_ymmm256", Code.VEX_VCVTDQ2PS_YMM_YMMM256); + map.put("EVEX_Vcvtdq2ps_xmm_k1z_xmmm128b32", Code.EVEX_VCVTDQ2PS_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtdq2ps_ymm_k1z_ymmm256b32", Code.EVEX_VCVTDQ2PS_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vcvtdq2ps_zmm_k1z_zmmm512b32_er", Code.EVEX_VCVTDQ2PS_ZMM_K1Z_ZMMM512B32_ER); + map.put("EVEX_Vcvtqq2ps_xmm_k1z_xmmm128b64", Code.EVEX_VCVTQQ2PS_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtqq2ps_xmm_k1z_ymmm256b64", Code.EVEX_VCVTQQ2PS_XMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtqq2ps_ymm_k1z_zmmm512b64_er", Code.EVEX_VCVTQQ2PS_YMM_K1Z_ZMMM512B64_ER); + map.put("Cvtps2dq_xmm_xmmm128", Code.CVTPS2DQ_XMM_XMMM128); + map.put("VEX_Vcvtps2dq_xmm_xmmm128", Code.VEX_VCVTPS2DQ_XMM_XMMM128); + map.put("VEX_Vcvtps2dq_ymm_ymmm256", Code.VEX_VCVTPS2DQ_YMM_YMMM256); + map.put("EVEX_Vcvtps2dq_xmm_k1z_xmmm128b32", Code.EVEX_VCVTPS2DQ_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtps2dq_ymm_k1z_ymmm256b32", Code.EVEX_VCVTPS2DQ_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vcvtps2dq_zmm_k1z_zmmm512b32_er", Code.EVEX_VCVTPS2DQ_ZMM_K1Z_ZMMM512B32_ER); + map.put("Cvttps2dq_xmm_xmmm128", Code.CVTTPS2DQ_XMM_XMMM128); + map.put("VEX_Vcvttps2dq_xmm_xmmm128", Code.VEX_VCVTTPS2DQ_XMM_XMMM128); + map.put("VEX_Vcvttps2dq_ymm_ymmm256", Code.VEX_VCVTTPS2DQ_YMM_YMMM256); + map.put("EVEX_Vcvttps2dq_xmm_k1z_xmmm128b32", Code.EVEX_VCVTTPS2DQ_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvttps2dq_ymm_k1z_ymmm256b32", Code.EVEX_VCVTTPS2DQ_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vcvttps2dq_zmm_k1z_zmmm512b32_sae", Code.EVEX_VCVTTPS2DQ_ZMM_K1Z_ZMMM512B32_SAE); + map.put("Subps_xmm_xmmm128", Code.SUBPS_XMM_XMMM128); + map.put("VEX_Vsubps_xmm_xmm_xmmm128", Code.VEX_VSUBPS_XMM_XMM_XMMM128); + map.put("VEX_Vsubps_ymm_ymm_ymmm256", Code.VEX_VSUBPS_YMM_YMM_YMMM256); + map.put("EVEX_Vsubps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VSUBPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vsubps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VSUBPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vsubps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VSUBPS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("Subpd_xmm_xmmm128", Code.SUBPD_XMM_XMMM128); + map.put("VEX_Vsubpd_xmm_xmm_xmmm128", Code.VEX_VSUBPD_XMM_XMM_XMMM128); + map.put("VEX_Vsubpd_ymm_ymm_ymmm256", Code.VEX_VSUBPD_YMM_YMM_YMMM256); + map.put("EVEX_Vsubpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VSUBPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vsubpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VSUBPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vsubpd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VSUBPD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("Subss_xmm_xmmm32", Code.SUBSS_XMM_XMMM32); + map.put("VEX_Vsubss_xmm_xmm_xmmm32", Code.VEX_VSUBSS_XMM_XMM_XMMM32); + map.put("EVEX_Vsubss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VSUBSS_XMM_K1Z_XMM_XMMM32_ER); + map.put("Subsd_xmm_xmmm64", Code.SUBSD_XMM_XMMM64); + map.put("VEX_Vsubsd_xmm_xmm_xmmm64", Code.VEX_VSUBSD_XMM_XMM_XMMM64); + map.put("EVEX_Vsubsd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VSUBSD_XMM_K1Z_XMM_XMMM64_ER); + map.put("Minps_xmm_xmmm128", Code.MINPS_XMM_XMMM128); + map.put("VEX_Vminps_xmm_xmm_xmmm128", Code.VEX_VMINPS_XMM_XMM_XMMM128); + map.put("VEX_Vminps_ymm_ymm_ymmm256", Code.VEX_VMINPS_YMM_YMM_YMMM256); + map.put("EVEX_Vminps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VMINPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vminps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VMINPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vminps_zmm_k1z_zmm_zmmm512b32_sae", Code.EVEX_VMINPS_ZMM_K1Z_ZMM_ZMMM512B32_SAE); + map.put("Minpd_xmm_xmmm128", Code.MINPD_XMM_XMMM128); + map.put("VEX_Vminpd_xmm_xmm_xmmm128", Code.VEX_VMINPD_XMM_XMM_XMMM128); + map.put("VEX_Vminpd_ymm_ymm_ymmm256", Code.VEX_VMINPD_YMM_YMM_YMMM256); + map.put("EVEX_Vminpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VMINPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vminpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VMINPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vminpd_zmm_k1z_zmm_zmmm512b64_sae", Code.EVEX_VMINPD_ZMM_K1Z_ZMM_ZMMM512B64_SAE); + map.put("Minss_xmm_xmmm32", Code.MINSS_XMM_XMMM32); + map.put("VEX_Vminss_xmm_xmm_xmmm32", Code.VEX_VMINSS_XMM_XMM_XMMM32); + map.put("EVEX_Vminss_xmm_k1z_xmm_xmmm32_sae", Code.EVEX_VMINSS_XMM_K1Z_XMM_XMMM32_SAE); + map.put("Minsd_xmm_xmmm64", Code.MINSD_XMM_XMMM64); + map.put("VEX_Vminsd_xmm_xmm_xmmm64", Code.VEX_VMINSD_XMM_XMM_XMMM64); + map.put("EVEX_Vminsd_xmm_k1z_xmm_xmmm64_sae", Code.EVEX_VMINSD_XMM_K1Z_XMM_XMMM64_SAE); + map.put("Divps_xmm_xmmm128", Code.DIVPS_XMM_XMMM128); + map.put("VEX_Vdivps_xmm_xmm_xmmm128", Code.VEX_VDIVPS_XMM_XMM_XMMM128); + map.put("VEX_Vdivps_ymm_ymm_ymmm256", Code.VEX_VDIVPS_YMM_YMM_YMMM256); + map.put("EVEX_Vdivps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VDIVPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vdivps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VDIVPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vdivps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VDIVPS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("Divpd_xmm_xmmm128", Code.DIVPD_XMM_XMMM128); + map.put("VEX_Vdivpd_xmm_xmm_xmmm128", Code.VEX_VDIVPD_XMM_XMM_XMMM128); + map.put("VEX_Vdivpd_ymm_ymm_ymmm256", Code.VEX_VDIVPD_YMM_YMM_YMMM256); + map.put("EVEX_Vdivpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VDIVPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vdivpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VDIVPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vdivpd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VDIVPD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("Divss_xmm_xmmm32", Code.DIVSS_XMM_XMMM32); + map.put("VEX_Vdivss_xmm_xmm_xmmm32", Code.VEX_VDIVSS_XMM_XMM_XMMM32); + map.put("EVEX_Vdivss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VDIVSS_XMM_K1Z_XMM_XMMM32_ER); + map.put("Divsd_xmm_xmmm64", Code.DIVSD_XMM_XMMM64); + map.put("VEX_Vdivsd_xmm_xmm_xmmm64", Code.VEX_VDIVSD_XMM_XMM_XMMM64); + map.put("EVEX_Vdivsd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VDIVSD_XMM_K1Z_XMM_XMMM64_ER); + map.put("Maxps_xmm_xmmm128", Code.MAXPS_XMM_XMMM128); + map.put("VEX_Vmaxps_xmm_xmm_xmmm128", Code.VEX_VMAXPS_XMM_XMM_XMMM128); + map.put("VEX_Vmaxps_ymm_ymm_ymmm256", Code.VEX_VMAXPS_YMM_YMM_YMMM256); + map.put("EVEX_Vmaxps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VMAXPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vmaxps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VMAXPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vmaxps_zmm_k1z_zmm_zmmm512b32_sae", Code.EVEX_VMAXPS_ZMM_K1Z_ZMM_ZMMM512B32_SAE); + map.put("Maxpd_xmm_xmmm128", Code.MAXPD_XMM_XMMM128); + map.put("VEX_Vmaxpd_xmm_xmm_xmmm128", Code.VEX_VMAXPD_XMM_XMM_XMMM128); + map.put("VEX_Vmaxpd_ymm_ymm_ymmm256", Code.VEX_VMAXPD_YMM_YMM_YMMM256); + map.put("EVEX_Vmaxpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VMAXPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vmaxpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VMAXPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vmaxpd_zmm_k1z_zmm_zmmm512b64_sae", Code.EVEX_VMAXPD_ZMM_K1Z_ZMM_ZMMM512B64_SAE); + map.put("Maxss_xmm_xmmm32", Code.MAXSS_XMM_XMMM32); + map.put("VEX_Vmaxss_xmm_xmm_xmmm32", Code.VEX_VMAXSS_XMM_XMM_XMMM32); + map.put("EVEX_Vmaxss_xmm_k1z_xmm_xmmm32_sae", Code.EVEX_VMAXSS_XMM_K1Z_XMM_XMMM32_SAE); + map.put("Maxsd_xmm_xmmm64", Code.MAXSD_XMM_XMMM64); + map.put("VEX_Vmaxsd_xmm_xmm_xmmm64", Code.VEX_VMAXSD_XMM_XMM_XMMM64); + map.put("EVEX_Vmaxsd_xmm_k1z_xmm_xmmm64_sae", Code.EVEX_VMAXSD_XMM_K1Z_XMM_XMMM64_SAE); + map.put("Punpcklbw_mm_mmm32", Code.PUNPCKLBW_MM_MMM32); + map.put("Punpcklbw_xmm_xmmm128", Code.PUNPCKLBW_XMM_XMMM128); + map.put("VEX_Vpunpcklbw_xmm_xmm_xmmm128", Code.VEX_VPUNPCKLBW_XMM_XMM_XMMM128); + map.put("VEX_Vpunpcklbw_ymm_ymm_ymmm256", Code.VEX_VPUNPCKLBW_YMM_YMM_YMMM256); + map.put("EVEX_Vpunpcklbw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPUNPCKLBW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpunpcklbw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPUNPCKLBW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpunpcklbw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPUNPCKLBW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Punpcklwd_mm_mmm32", Code.PUNPCKLWD_MM_MMM32); + map.put("Punpcklwd_xmm_xmmm128", Code.PUNPCKLWD_XMM_XMMM128); + map.put("VEX_Vpunpcklwd_xmm_xmm_xmmm128", Code.VEX_VPUNPCKLWD_XMM_XMM_XMMM128); + map.put("VEX_Vpunpcklwd_ymm_ymm_ymmm256", Code.VEX_VPUNPCKLWD_YMM_YMM_YMMM256); + map.put("EVEX_Vpunpcklwd_xmm_k1z_xmm_xmmm128", Code.EVEX_VPUNPCKLWD_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpunpcklwd_ymm_k1z_ymm_ymmm256", Code.EVEX_VPUNPCKLWD_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpunpcklwd_zmm_k1z_zmm_zmmm512", Code.EVEX_VPUNPCKLWD_ZMM_K1Z_ZMM_ZMMM512); + map.put("Punpckldq_mm_mmm32", Code.PUNPCKLDQ_MM_MMM32); + map.put("Punpckldq_xmm_xmmm128", Code.PUNPCKLDQ_XMM_XMMM128); + map.put("VEX_Vpunpckldq_xmm_xmm_xmmm128", Code.VEX_VPUNPCKLDQ_XMM_XMM_XMMM128); + } + + private static void initMap3(HashMap map) { + map.put("VEX_Vpunpckldq_ymm_ymm_ymmm256", Code.VEX_VPUNPCKLDQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpunpckldq_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPUNPCKLDQ_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpunpckldq_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPUNPCKLDQ_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpunpckldq_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPUNPCKLDQ_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Packsswb_mm_mmm64", Code.PACKSSWB_MM_MMM64); + map.put("Packsswb_xmm_xmmm128", Code.PACKSSWB_XMM_XMMM128); + map.put("VEX_Vpacksswb_xmm_xmm_xmmm128", Code.VEX_VPACKSSWB_XMM_XMM_XMMM128); + map.put("VEX_Vpacksswb_ymm_ymm_ymmm256", Code.VEX_VPACKSSWB_YMM_YMM_YMMM256); + map.put("EVEX_Vpacksswb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPACKSSWB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpacksswb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPACKSSWB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpacksswb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPACKSSWB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pcmpgtb_mm_mmm64", Code.PCMPGTB_MM_MMM64); + map.put("Pcmpgtb_xmm_xmmm128", Code.PCMPGTB_XMM_XMMM128); + map.put("VEX_Vpcmpgtb_xmm_xmm_xmmm128", Code.VEX_VPCMPGTB_XMM_XMM_XMMM128); + map.put("VEX_Vpcmpgtb_ymm_ymm_ymmm256", Code.VEX_VPCMPGTB_YMM_YMM_YMMM256); + map.put("EVEX_Vpcmpgtb_kr_k1_xmm_xmmm128", Code.EVEX_VPCMPGTB_KR_K1_XMM_XMMM128); + map.put("EVEX_Vpcmpgtb_kr_k1_ymm_ymmm256", Code.EVEX_VPCMPGTB_KR_K1_YMM_YMMM256); + map.put("EVEX_Vpcmpgtb_kr_k1_zmm_zmmm512", Code.EVEX_VPCMPGTB_KR_K1_ZMM_ZMMM512); + map.put("Pcmpgtw_mm_mmm64", Code.PCMPGTW_MM_MMM64); + map.put("Pcmpgtw_xmm_xmmm128", Code.PCMPGTW_XMM_XMMM128); + map.put("VEX_Vpcmpgtw_xmm_xmm_xmmm128", Code.VEX_VPCMPGTW_XMM_XMM_XMMM128); + map.put("VEX_Vpcmpgtw_ymm_ymm_ymmm256", Code.VEX_VPCMPGTW_YMM_YMM_YMMM256); + map.put("EVEX_Vpcmpgtw_kr_k1_xmm_xmmm128", Code.EVEX_VPCMPGTW_KR_K1_XMM_XMMM128); + map.put("EVEX_Vpcmpgtw_kr_k1_ymm_ymmm256", Code.EVEX_VPCMPGTW_KR_K1_YMM_YMMM256); + map.put("EVEX_Vpcmpgtw_kr_k1_zmm_zmmm512", Code.EVEX_VPCMPGTW_KR_K1_ZMM_ZMMM512); + map.put("Pcmpgtd_mm_mmm64", Code.PCMPGTD_MM_MMM64); + map.put("Pcmpgtd_xmm_xmmm128", Code.PCMPGTD_XMM_XMMM128); + map.put("VEX_Vpcmpgtd_xmm_xmm_xmmm128", Code.VEX_VPCMPGTD_XMM_XMM_XMMM128); + map.put("VEX_Vpcmpgtd_ymm_ymm_ymmm256", Code.VEX_VPCMPGTD_YMM_YMM_YMMM256); + map.put("EVEX_Vpcmpgtd_kr_k1_xmm_xmmm128b32", Code.EVEX_VPCMPGTD_KR_K1_XMM_XMMM128B32); + map.put("EVEX_Vpcmpgtd_kr_k1_ymm_ymmm256b32", Code.EVEX_VPCMPGTD_KR_K1_YMM_YMMM256B32); + map.put("EVEX_Vpcmpgtd_kr_k1_zmm_zmmm512b32", Code.EVEX_VPCMPGTD_KR_K1_ZMM_ZMMM512B32); + map.put("Packuswb_mm_mmm64", Code.PACKUSWB_MM_MMM64); + map.put("Packuswb_xmm_xmmm128", Code.PACKUSWB_XMM_XMMM128); + map.put("VEX_Vpackuswb_xmm_xmm_xmmm128", Code.VEX_VPACKUSWB_XMM_XMM_XMMM128); + map.put("VEX_Vpackuswb_ymm_ymm_ymmm256", Code.VEX_VPACKUSWB_YMM_YMM_YMMM256); + map.put("EVEX_Vpackuswb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPACKUSWB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpackuswb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPACKUSWB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpackuswb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPACKUSWB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Punpckhbw_mm_mmm64", Code.PUNPCKHBW_MM_MMM64); + map.put("Punpckhbw_xmm_xmmm128", Code.PUNPCKHBW_XMM_XMMM128); + map.put("VEX_Vpunpckhbw_xmm_xmm_xmmm128", Code.VEX_VPUNPCKHBW_XMM_XMM_XMMM128); + map.put("VEX_Vpunpckhbw_ymm_ymm_ymmm256", Code.VEX_VPUNPCKHBW_YMM_YMM_YMMM256); + map.put("EVEX_Vpunpckhbw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPUNPCKHBW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpunpckhbw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPUNPCKHBW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpunpckhbw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPUNPCKHBW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Punpckhwd_mm_mmm64", Code.PUNPCKHWD_MM_MMM64); + map.put("Punpckhwd_xmm_xmmm128", Code.PUNPCKHWD_XMM_XMMM128); + map.put("VEX_Vpunpckhwd_xmm_xmm_xmmm128", Code.VEX_VPUNPCKHWD_XMM_XMM_XMMM128); + map.put("VEX_Vpunpckhwd_ymm_ymm_ymmm256", Code.VEX_VPUNPCKHWD_YMM_YMM_YMMM256); + map.put("EVEX_Vpunpckhwd_xmm_k1z_xmm_xmmm128", Code.EVEX_VPUNPCKHWD_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpunpckhwd_ymm_k1z_ymm_ymmm256", Code.EVEX_VPUNPCKHWD_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpunpckhwd_zmm_k1z_zmm_zmmm512", Code.EVEX_VPUNPCKHWD_ZMM_K1Z_ZMM_ZMMM512); + map.put("Punpckhdq_mm_mmm64", Code.PUNPCKHDQ_MM_MMM64); + map.put("Punpckhdq_xmm_xmmm128", Code.PUNPCKHDQ_XMM_XMMM128); + map.put("VEX_Vpunpckhdq_xmm_xmm_xmmm128", Code.VEX_VPUNPCKHDQ_XMM_XMM_XMMM128); + map.put("VEX_Vpunpckhdq_ymm_ymm_ymmm256", Code.VEX_VPUNPCKHDQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpunpckhdq_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPUNPCKHDQ_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpunpckhdq_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPUNPCKHDQ_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpunpckhdq_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPUNPCKHDQ_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Packssdw_mm_mmm64", Code.PACKSSDW_MM_MMM64); + map.put("Packssdw_xmm_xmmm128", Code.PACKSSDW_XMM_XMMM128); + map.put("VEX_Vpackssdw_xmm_xmm_xmmm128", Code.VEX_VPACKSSDW_XMM_XMM_XMMM128); + map.put("VEX_Vpackssdw_ymm_ymm_ymmm256", Code.VEX_VPACKSSDW_YMM_YMM_YMMM256); + map.put("EVEX_Vpackssdw_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPACKSSDW_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpackssdw_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPACKSSDW_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpackssdw_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPACKSSDW_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Punpcklqdq_xmm_xmmm128", Code.PUNPCKLQDQ_XMM_XMMM128); + map.put("VEX_Vpunpcklqdq_xmm_xmm_xmmm128", Code.VEX_VPUNPCKLQDQ_XMM_XMM_XMMM128); + map.put("VEX_Vpunpcklqdq_ymm_ymm_ymmm256", Code.VEX_VPUNPCKLQDQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpunpcklqdq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPUNPCKLQDQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpunpcklqdq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPUNPCKLQDQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpunpcklqdq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPUNPCKLQDQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Punpckhqdq_xmm_xmmm128", Code.PUNPCKHQDQ_XMM_XMMM128); + map.put("VEX_Vpunpckhqdq_xmm_xmm_xmmm128", Code.VEX_VPUNPCKHQDQ_XMM_XMM_XMMM128); + map.put("VEX_Vpunpckhqdq_ymm_ymm_ymmm256", Code.VEX_VPUNPCKHQDQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpunpckhqdq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPUNPCKHQDQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpunpckhqdq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPUNPCKHQDQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpunpckhqdq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPUNPCKHQDQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Movd_mm_rm32", Code.MOVD_MM_RM32); + map.put("Movq_mm_rm64", Code.MOVQ_MM_RM64); + map.put("Movd_xmm_rm32", Code.MOVD_XMM_RM32); + map.put("Movq_xmm_rm64", Code.MOVQ_XMM_RM64); + map.put("VEX_Vmovd_xmm_rm32", Code.VEX_VMOVD_XMM_RM32); + map.put("VEX_Vmovq_xmm_rm64", Code.VEX_VMOVQ_XMM_RM64); + map.put("EVEX_Vmovd_xmm_rm32", Code.EVEX_VMOVD_XMM_RM32); + map.put("EVEX_Vmovq_xmm_rm64", Code.EVEX_VMOVQ_XMM_RM64); + map.put("Movq_mm_mmm64", Code.MOVQ_MM_MMM64); + map.put("Movdqa_xmm_xmmm128", Code.MOVDQA_XMM_XMMM128); + map.put("VEX_Vmovdqa_xmm_xmmm128", Code.VEX_VMOVDQA_XMM_XMMM128); + map.put("VEX_Vmovdqa_ymm_ymmm256", Code.VEX_VMOVDQA_YMM_YMMM256); + map.put("EVEX_Vmovdqa32_xmm_k1z_xmmm128", Code.EVEX_VMOVDQA32_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovdqa32_ymm_k1z_ymmm256", Code.EVEX_VMOVDQA32_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovdqa32_zmm_k1z_zmmm512", Code.EVEX_VMOVDQA32_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vmovdqa64_xmm_k1z_xmmm128", Code.EVEX_VMOVDQA64_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovdqa64_ymm_k1z_ymmm256", Code.EVEX_VMOVDQA64_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovdqa64_zmm_k1z_zmmm512", Code.EVEX_VMOVDQA64_ZMM_K1Z_ZMMM512); + map.put("Movdqu_xmm_xmmm128", Code.MOVDQU_XMM_XMMM128); + map.put("VEX_Vmovdqu_xmm_xmmm128", Code.VEX_VMOVDQU_XMM_XMMM128); + map.put("VEX_Vmovdqu_ymm_ymmm256", Code.VEX_VMOVDQU_YMM_YMMM256); + map.put("EVEX_Vmovdqu32_xmm_k1z_xmmm128", Code.EVEX_VMOVDQU32_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovdqu32_ymm_k1z_ymmm256", Code.EVEX_VMOVDQU32_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovdqu32_zmm_k1z_zmmm512", Code.EVEX_VMOVDQU32_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vmovdqu64_xmm_k1z_xmmm128", Code.EVEX_VMOVDQU64_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovdqu64_ymm_k1z_ymmm256", Code.EVEX_VMOVDQU64_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovdqu64_zmm_k1z_zmmm512", Code.EVEX_VMOVDQU64_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vmovdqu8_xmm_k1z_xmmm128", Code.EVEX_VMOVDQU8_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovdqu8_ymm_k1z_ymmm256", Code.EVEX_VMOVDQU8_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovdqu8_zmm_k1z_zmmm512", Code.EVEX_VMOVDQU8_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vmovdqu16_xmm_k1z_xmmm128", Code.EVEX_VMOVDQU16_XMM_K1Z_XMMM128); + map.put("EVEX_Vmovdqu16_ymm_k1z_ymmm256", Code.EVEX_VMOVDQU16_YMM_K1Z_YMMM256); + map.put("EVEX_Vmovdqu16_zmm_k1z_zmmm512", Code.EVEX_VMOVDQU16_ZMM_K1Z_ZMMM512); + map.put("Pshufw_mm_mmm64_imm8", Code.PSHUFW_MM_MMM64_IMM8); + map.put("Pshufd_xmm_xmmm128_imm8", Code.PSHUFD_XMM_XMMM128_IMM8); + map.put("VEX_Vpshufd_xmm_xmmm128_imm8", Code.VEX_VPSHUFD_XMM_XMMM128_IMM8); + map.put("VEX_Vpshufd_ymm_ymmm256_imm8", Code.VEX_VPSHUFD_YMM_YMMM256_IMM8); + map.put("EVEX_Vpshufd_xmm_k1z_xmmm128b32_imm8", Code.EVEX_VPSHUFD_XMM_K1Z_XMMM128B32_IMM8); + map.put("EVEX_Vpshufd_ymm_k1z_ymmm256b32_imm8", Code.EVEX_VPSHUFD_YMM_K1Z_YMMM256B32_IMM8); + map.put("EVEX_Vpshufd_zmm_k1z_zmmm512b32_imm8", Code.EVEX_VPSHUFD_ZMM_K1Z_ZMMM512B32_IMM8); + map.put("Pshufhw_xmm_xmmm128_imm8", Code.PSHUFHW_XMM_XMMM128_IMM8); + map.put("VEX_Vpshufhw_xmm_xmmm128_imm8", Code.VEX_VPSHUFHW_XMM_XMMM128_IMM8); + map.put("VEX_Vpshufhw_ymm_ymmm256_imm8", Code.VEX_VPSHUFHW_YMM_YMMM256_IMM8); + map.put("EVEX_Vpshufhw_xmm_k1z_xmmm128_imm8", Code.EVEX_VPSHUFHW_XMM_K1Z_XMMM128_IMM8); + map.put("EVEX_Vpshufhw_ymm_k1z_ymmm256_imm8", Code.EVEX_VPSHUFHW_YMM_K1Z_YMMM256_IMM8); + map.put("EVEX_Vpshufhw_zmm_k1z_zmmm512_imm8", Code.EVEX_VPSHUFHW_ZMM_K1Z_ZMMM512_IMM8); + map.put("Pshuflw_xmm_xmmm128_imm8", Code.PSHUFLW_XMM_XMMM128_IMM8); + map.put("VEX_Vpshuflw_xmm_xmmm128_imm8", Code.VEX_VPSHUFLW_XMM_XMMM128_IMM8); + map.put("VEX_Vpshuflw_ymm_ymmm256_imm8", Code.VEX_VPSHUFLW_YMM_YMMM256_IMM8); + map.put("EVEX_Vpshuflw_xmm_k1z_xmmm128_imm8", Code.EVEX_VPSHUFLW_XMM_K1Z_XMMM128_IMM8); + map.put("EVEX_Vpshuflw_ymm_k1z_ymmm256_imm8", Code.EVEX_VPSHUFLW_YMM_K1Z_YMMM256_IMM8); + map.put("EVEX_Vpshuflw_zmm_k1z_zmmm512_imm8", Code.EVEX_VPSHUFLW_ZMM_K1Z_ZMMM512_IMM8); + map.put("Psrlw_mm_imm8", Code.PSRLW_MM_IMM8); + map.put("Psrlw_xmm_imm8", Code.PSRLW_XMM_IMM8); + map.put("VEX_Vpsrlw_xmm_xmm_imm8", Code.VEX_VPSRLW_XMM_XMM_IMM8); + map.put("VEX_Vpsrlw_ymm_ymm_imm8", Code.VEX_VPSRLW_YMM_YMM_IMM8); + map.put("EVEX_Vpsrlw_xmm_k1z_xmmm128_imm8", Code.EVEX_VPSRLW_XMM_K1Z_XMMM128_IMM8); + map.put("EVEX_Vpsrlw_ymm_k1z_ymmm256_imm8", Code.EVEX_VPSRLW_YMM_K1Z_YMMM256_IMM8); + map.put("EVEX_Vpsrlw_zmm_k1z_zmmm512_imm8", Code.EVEX_VPSRLW_ZMM_K1Z_ZMMM512_IMM8); + map.put("Psraw_mm_imm8", Code.PSRAW_MM_IMM8); + map.put("Psraw_xmm_imm8", Code.PSRAW_XMM_IMM8); + map.put("VEX_Vpsraw_xmm_xmm_imm8", Code.VEX_VPSRAW_XMM_XMM_IMM8); + map.put("VEX_Vpsraw_ymm_ymm_imm8", Code.VEX_VPSRAW_YMM_YMM_IMM8); + map.put("EVEX_Vpsraw_xmm_k1z_xmmm128_imm8", Code.EVEX_VPSRAW_XMM_K1Z_XMMM128_IMM8); + map.put("EVEX_Vpsraw_ymm_k1z_ymmm256_imm8", Code.EVEX_VPSRAW_YMM_K1Z_YMMM256_IMM8); + map.put("EVEX_Vpsraw_zmm_k1z_zmmm512_imm8", Code.EVEX_VPSRAW_ZMM_K1Z_ZMMM512_IMM8); + map.put("Psllw_mm_imm8", Code.PSLLW_MM_IMM8); + map.put("Psllw_xmm_imm8", Code.PSLLW_XMM_IMM8); + map.put("VEX_Vpsllw_xmm_xmm_imm8", Code.VEX_VPSLLW_XMM_XMM_IMM8); + map.put("VEX_Vpsllw_ymm_ymm_imm8", Code.VEX_VPSLLW_YMM_YMM_IMM8); + map.put("EVEX_Vpsllw_xmm_k1z_xmmm128_imm8", Code.EVEX_VPSLLW_XMM_K1Z_XMMM128_IMM8); + map.put("EVEX_Vpsllw_ymm_k1z_ymmm256_imm8", Code.EVEX_VPSLLW_YMM_K1Z_YMMM256_IMM8); + map.put("EVEX_Vpsllw_zmm_k1z_zmmm512_imm8", Code.EVEX_VPSLLW_ZMM_K1Z_ZMMM512_IMM8); + map.put("EVEX_Vprord_xmm_k1z_xmmm128b32_imm8", Code.EVEX_VPRORD_XMM_K1Z_XMMM128B32_IMM8); + map.put("EVEX_Vprord_ymm_k1z_ymmm256b32_imm8", Code.EVEX_VPRORD_YMM_K1Z_YMMM256B32_IMM8); + map.put("EVEX_Vprord_zmm_k1z_zmmm512b32_imm8", Code.EVEX_VPRORD_ZMM_K1Z_ZMMM512B32_IMM8); + map.put("EVEX_Vprorq_xmm_k1z_xmmm128b64_imm8", Code.EVEX_VPRORQ_XMM_K1Z_XMMM128B64_IMM8); + map.put("EVEX_Vprorq_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VPRORQ_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vprorq_zmm_k1z_zmmm512b64_imm8", Code.EVEX_VPRORQ_ZMM_K1Z_ZMMM512B64_IMM8); + map.put("EVEX_Vprold_xmm_k1z_xmmm128b32_imm8", Code.EVEX_VPROLD_XMM_K1Z_XMMM128B32_IMM8); + map.put("EVEX_Vprold_ymm_k1z_ymmm256b32_imm8", Code.EVEX_VPROLD_YMM_K1Z_YMMM256B32_IMM8); + map.put("EVEX_Vprold_zmm_k1z_zmmm512b32_imm8", Code.EVEX_VPROLD_ZMM_K1Z_ZMMM512B32_IMM8); + map.put("EVEX_Vprolq_xmm_k1z_xmmm128b64_imm8", Code.EVEX_VPROLQ_XMM_K1Z_XMMM128B64_IMM8); + map.put("EVEX_Vprolq_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VPROLQ_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vprolq_zmm_k1z_zmmm512b64_imm8", Code.EVEX_VPROLQ_ZMM_K1Z_ZMMM512B64_IMM8); + map.put("Psrld_mm_imm8", Code.PSRLD_MM_IMM8); + map.put("Psrld_xmm_imm8", Code.PSRLD_XMM_IMM8); + map.put("VEX_Vpsrld_xmm_xmm_imm8", Code.VEX_VPSRLD_XMM_XMM_IMM8); + map.put("VEX_Vpsrld_ymm_ymm_imm8", Code.VEX_VPSRLD_YMM_YMM_IMM8); + map.put("EVEX_Vpsrld_xmm_k1z_xmmm128b32_imm8", Code.EVEX_VPSRLD_XMM_K1Z_XMMM128B32_IMM8); + map.put("EVEX_Vpsrld_ymm_k1z_ymmm256b32_imm8", Code.EVEX_VPSRLD_YMM_K1Z_YMMM256B32_IMM8); + map.put("EVEX_Vpsrld_zmm_k1z_zmmm512b32_imm8", Code.EVEX_VPSRLD_ZMM_K1Z_ZMMM512B32_IMM8); + map.put("Psrad_mm_imm8", Code.PSRAD_MM_IMM8); + map.put("Psrad_xmm_imm8", Code.PSRAD_XMM_IMM8); + map.put("VEX_Vpsrad_xmm_xmm_imm8", Code.VEX_VPSRAD_XMM_XMM_IMM8); + map.put("VEX_Vpsrad_ymm_ymm_imm8", Code.VEX_VPSRAD_YMM_YMM_IMM8); + map.put("EVEX_Vpsrad_xmm_k1z_xmmm128b32_imm8", Code.EVEX_VPSRAD_XMM_K1Z_XMMM128B32_IMM8); + map.put("EVEX_Vpsrad_ymm_k1z_ymmm256b32_imm8", Code.EVEX_VPSRAD_YMM_K1Z_YMMM256B32_IMM8); + map.put("EVEX_Vpsrad_zmm_k1z_zmmm512b32_imm8", Code.EVEX_VPSRAD_ZMM_K1Z_ZMMM512B32_IMM8); + map.put("EVEX_Vpsraq_xmm_k1z_xmmm128b64_imm8", Code.EVEX_VPSRAQ_XMM_K1Z_XMMM128B64_IMM8); + map.put("EVEX_Vpsraq_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VPSRAQ_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vpsraq_zmm_k1z_zmmm512b64_imm8", Code.EVEX_VPSRAQ_ZMM_K1Z_ZMMM512B64_IMM8); + map.put("Pslld_mm_imm8", Code.PSLLD_MM_IMM8); + map.put("Pslld_xmm_imm8", Code.PSLLD_XMM_IMM8); + map.put("VEX_Vpslld_xmm_xmm_imm8", Code.VEX_VPSLLD_XMM_XMM_IMM8); + map.put("VEX_Vpslld_ymm_ymm_imm8", Code.VEX_VPSLLD_YMM_YMM_IMM8); + map.put("EVEX_Vpslld_xmm_k1z_xmmm128b32_imm8", Code.EVEX_VPSLLD_XMM_K1Z_XMMM128B32_IMM8); + map.put("EVEX_Vpslld_ymm_k1z_ymmm256b32_imm8", Code.EVEX_VPSLLD_YMM_K1Z_YMMM256B32_IMM8); + map.put("EVEX_Vpslld_zmm_k1z_zmmm512b32_imm8", Code.EVEX_VPSLLD_ZMM_K1Z_ZMMM512B32_IMM8); + map.put("Psrlq_mm_imm8", Code.PSRLQ_MM_IMM8); + map.put("Psrlq_xmm_imm8", Code.PSRLQ_XMM_IMM8); + map.put("VEX_Vpsrlq_xmm_xmm_imm8", Code.VEX_VPSRLQ_XMM_XMM_IMM8); + map.put("VEX_Vpsrlq_ymm_ymm_imm8", Code.VEX_VPSRLQ_YMM_YMM_IMM8); + map.put("EVEX_Vpsrlq_xmm_k1z_xmmm128b64_imm8", Code.EVEX_VPSRLQ_XMM_K1Z_XMMM128B64_IMM8); + map.put("EVEX_Vpsrlq_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VPSRLQ_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vpsrlq_zmm_k1z_zmmm512b64_imm8", Code.EVEX_VPSRLQ_ZMM_K1Z_ZMMM512B64_IMM8); + map.put("Psrldq_xmm_imm8", Code.PSRLDQ_XMM_IMM8); + map.put("VEX_Vpsrldq_xmm_xmm_imm8", Code.VEX_VPSRLDQ_XMM_XMM_IMM8); + map.put("VEX_Vpsrldq_ymm_ymm_imm8", Code.VEX_VPSRLDQ_YMM_YMM_IMM8); + map.put("EVEX_Vpsrldq_xmm_xmmm128_imm8", Code.EVEX_VPSRLDQ_XMM_XMMM128_IMM8); + map.put("EVEX_Vpsrldq_ymm_ymmm256_imm8", Code.EVEX_VPSRLDQ_YMM_YMMM256_IMM8); + map.put("EVEX_Vpsrldq_zmm_zmmm512_imm8", Code.EVEX_VPSRLDQ_ZMM_ZMMM512_IMM8); + map.put("Psllq_mm_imm8", Code.PSLLQ_MM_IMM8); + map.put("Psllq_xmm_imm8", Code.PSLLQ_XMM_IMM8); + map.put("VEX_Vpsllq_xmm_xmm_imm8", Code.VEX_VPSLLQ_XMM_XMM_IMM8); + map.put("VEX_Vpsllq_ymm_ymm_imm8", Code.VEX_VPSLLQ_YMM_YMM_IMM8); + map.put("EVEX_Vpsllq_xmm_k1z_xmmm128b64_imm8", Code.EVEX_VPSLLQ_XMM_K1Z_XMMM128B64_IMM8); + map.put("EVEX_Vpsllq_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VPSLLQ_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vpsllq_zmm_k1z_zmmm512b64_imm8", Code.EVEX_VPSLLQ_ZMM_K1Z_ZMMM512B64_IMM8); + map.put("Pslldq_xmm_imm8", Code.PSLLDQ_XMM_IMM8); + map.put("VEX_Vpslldq_xmm_xmm_imm8", Code.VEX_VPSLLDQ_XMM_XMM_IMM8); + map.put("VEX_Vpslldq_ymm_ymm_imm8", Code.VEX_VPSLLDQ_YMM_YMM_IMM8); + map.put("EVEX_Vpslldq_xmm_xmmm128_imm8", Code.EVEX_VPSLLDQ_XMM_XMMM128_IMM8); + map.put("EVEX_Vpslldq_ymm_ymmm256_imm8", Code.EVEX_VPSLLDQ_YMM_YMMM256_IMM8); + map.put("EVEX_Vpslldq_zmm_zmmm512_imm8", Code.EVEX_VPSLLDQ_ZMM_ZMMM512_IMM8); + map.put("Pcmpeqb_mm_mmm64", Code.PCMPEQB_MM_MMM64); + map.put("Pcmpeqb_xmm_xmmm128", Code.PCMPEQB_XMM_XMMM128); + map.put("VEX_Vpcmpeqb_xmm_xmm_xmmm128", Code.VEX_VPCMPEQB_XMM_XMM_XMMM128); + map.put("VEX_Vpcmpeqb_ymm_ymm_ymmm256", Code.VEX_VPCMPEQB_YMM_YMM_YMMM256); + map.put("EVEX_Vpcmpeqb_kr_k1_xmm_xmmm128", Code.EVEX_VPCMPEQB_KR_K1_XMM_XMMM128); + map.put("EVEX_Vpcmpeqb_kr_k1_ymm_ymmm256", Code.EVEX_VPCMPEQB_KR_K1_YMM_YMMM256); + map.put("EVEX_Vpcmpeqb_kr_k1_zmm_zmmm512", Code.EVEX_VPCMPEQB_KR_K1_ZMM_ZMMM512); + map.put("Pcmpeqw_mm_mmm64", Code.PCMPEQW_MM_MMM64); + map.put("Pcmpeqw_xmm_xmmm128", Code.PCMPEQW_XMM_XMMM128); + map.put("VEX_Vpcmpeqw_xmm_xmm_xmmm128", Code.VEX_VPCMPEQW_XMM_XMM_XMMM128); + map.put("VEX_Vpcmpeqw_ymm_ymm_ymmm256", Code.VEX_VPCMPEQW_YMM_YMM_YMMM256); + map.put("EVEX_Vpcmpeqw_kr_k1_xmm_xmmm128", Code.EVEX_VPCMPEQW_KR_K1_XMM_XMMM128); + map.put("EVEX_Vpcmpeqw_kr_k1_ymm_ymmm256", Code.EVEX_VPCMPEQW_KR_K1_YMM_YMMM256); + map.put("EVEX_Vpcmpeqw_kr_k1_zmm_zmmm512", Code.EVEX_VPCMPEQW_KR_K1_ZMM_ZMMM512); + map.put("Pcmpeqd_mm_mmm64", Code.PCMPEQD_MM_MMM64); + map.put("Pcmpeqd_xmm_xmmm128", Code.PCMPEQD_XMM_XMMM128); + map.put("VEX_Vpcmpeqd_xmm_xmm_xmmm128", Code.VEX_VPCMPEQD_XMM_XMM_XMMM128); + map.put("VEX_Vpcmpeqd_ymm_ymm_ymmm256", Code.VEX_VPCMPEQD_YMM_YMM_YMMM256); + map.put("EVEX_Vpcmpeqd_kr_k1_xmm_xmmm128b32", Code.EVEX_VPCMPEQD_KR_K1_XMM_XMMM128B32); + map.put("EVEX_Vpcmpeqd_kr_k1_ymm_ymmm256b32", Code.EVEX_VPCMPEQD_KR_K1_YMM_YMMM256B32); + map.put("EVEX_Vpcmpeqd_kr_k1_zmm_zmmm512b32", Code.EVEX_VPCMPEQD_KR_K1_ZMM_ZMMM512B32); + map.put("Emms", Code.EMMS); + map.put("VEX_Vzeroupper", Code.VEX_VZEROUPPER); + map.put("VEX_Vzeroall", Code.VEX_VZEROALL); + map.put("Vmread_rm32_r32", Code.VMREAD_RM32_R32); + map.put("Vmread_rm64_r64", Code.VMREAD_RM64_R64); + map.put("EVEX_Vcvttps2udq_xmm_k1z_xmmm128b32", Code.EVEX_VCVTTPS2UDQ_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvttps2udq_ymm_k1z_ymmm256b32", Code.EVEX_VCVTTPS2UDQ_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vcvttps2udq_zmm_k1z_zmmm512b32_sae", Code.EVEX_VCVTTPS2UDQ_ZMM_K1Z_ZMMM512B32_SAE); + map.put("EVEX_Vcvttpd2udq_xmm_k1z_xmmm128b64", Code.EVEX_VCVTTPD2UDQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvttpd2udq_xmm_k1z_ymmm256b64", Code.EVEX_VCVTTPD2UDQ_XMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvttpd2udq_ymm_k1z_zmmm512b64_sae", Code.EVEX_VCVTTPD2UDQ_YMM_K1Z_ZMMM512B64_SAE); + map.put("Extrq_xmm_imm8_imm8", Code.EXTRQ_XMM_IMM8_IMM8); + map.put("EVEX_Vcvttps2uqq_xmm_k1z_xmmm64b32", Code.EVEX_VCVTTPS2UQQ_XMM_K1Z_XMMM64B32); + map.put("EVEX_Vcvttps2uqq_ymm_k1z_xmmm128b32", Code.EVEX_VCVTTPS2UQQ_YMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvttps2uqq_zmm_k1z_ymmm256b32_sae", Code.EVEX_VCVTTPS2UQQ_ZMM_K1Z_YMMM256B32_SAE); + map.put("EVEX_Vcvttpd2uqq_xmm_k1z_xmmm128b64", Code.EVEX_VCVTTPD2UQQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvttpd2uqq_ymm_k1z_ymmm256b64", Code.EVEX_VCVTTPD2UQQ_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvttpd2uqq_zmm_k1z_zmmm512b64_sae", Code.EVEX_VCVTTPD2UQQ_ZMM_K1Z_ZMMM512B64_SAE); + map.put("EVEX_Vcvttss2usi_r32_xmmm32_sae", Code.EVEX_VCVTTSS2USI_R32_XMMM32_SAE); + map.put("EVEX_Vcvttss2usi_r64_xmmm32_sae", Code.EVEX_VCVTTSS2USI_R64_XMMM32_SAE); + map.put("Insertq_xmm_xmm_imm8_imm8", Code.INSERTQ_XMM_XMM_IMM8_IMM8); + map.put("EVEX_Vcvttsd2usi_r32_xmmm64_sae", Code.EVEX_VCVTTSD2USI_R32_XMMM64_SAE); + map.put("EVEX_Vcvttsd2usi_r64_xmmm64_sae", Code.EVEX_VCVTTSD2USI_R64_XMMM64_SAE); + map.put("Vmwrite_r32_rm32", Code.VMWRITE_R32_RM32); + map.put("Vmwrite_r64_rm64", Code.VMWRITE_R64_RM64); + map.put("EVEX_Vcvtps2udq_xmm_k1z_xmmm128b32", Code.EVEX_VCVTPS2UDQ_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtps2udq_ymm_k1z_ymmm256b32", Code.EVEX_VCVTPS2UDQ_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vcvtps2udq_zmm_k1z_zmmm512b32_er", Code.EVEX_VCVTPS2UDQ_ZMM_K1Z_ZMMM512B32_ER); + map.put("EVEX_Vcvtpd2udq_xmm_k1z_xmmm128b64", Code.EVEX_VCVTPD2UDQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtpd2udq_xmm_k1z_ymmm256b64", Code.EVEX_VCVTPD2UDQ_XMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtpd2udq_ymm_k1z_zmmm512b64_er", Code.EVEX_VCVTPD2UDQ_YMM_K1Z_ZMMM512B64_ER); + map.put("Extrq_xmm_xmm", Code.EXTRQ_XMM_XMM); + map.put("EVEX_Vcvtps2uqq_xmm_k1z_xmmm64b32", Code.EVEX_VCVTPS2UQQ_XMM_K1Z_XMMM64B32); + map.put("EVEX_Vcvtps2uqq_ymm_k1z_xmmm128b32", Code.EVEX_VCVTPS2UQQ_YMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtps2uqq_zmm_k1z_ymmm256b32_er", Code.EVEX_VCVTPS2UQQ_ZMM_K1Z_YMMM256B32_ER); + map.put("EVEX_Vcvtpd2uqq_xmm_k1z_xmmm128b64", Code.EVEX_VCVTPD2UQQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtpd2uqq_ymm_k1z_ymmm256b64", Code.EVEX_VCVTPD2UQQ_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtpd2uqq_zmm_k1z_zmmm512b64_er", Code.EVEX_VCVTPD2UQQ_ZMM_K1Z_ZMMM512B64_ER); + map.put("EVEX_Vcvtss2usi_r32_xmmm32_er", Code.EVEX_VCVTSS2USI_R32_XMMM32_ER); + map.put("EVEX_Vcvtss2usi_r64_xmmm32_er", Code.EVEX_VCVTSS2USI_R64_XMMM32_ER); + map.put("Insertq_xmm_xmm", Code.INSERTQ_XMM_XMM); + map.put("EVEX_Vcvtsd2usi_r32_xmmm64_er", Code.EVEX_VCVTSD2USI_R32_XMMM64_ER); + map.put("EVEX_Vcvtsd2usi_r64_xmmm64_er", Code.EVEX_VCVTSD2USI_R64_XMMM64_ER); + map.put("EVEX_Vcvttps2qq_xmm_k1z_xmmm64b32", Code.EVEX_VCVTTPS2QQ_XMM_K1Z_XMMM64B32); + map.put("EVEX_Vcvttps2qq_ymm_k1z_xmmm128b32", Code.EVEX_VCVTTPS2QQ_YMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvttps2qq_zmm_k1z_ymmm256b32_sae", Code.EVEX_VCVTTPS2QQ_ZMM_K1Z_YMMM256B32_SAE); + map.put("EVEX_Vcvttpd2qq_xmm_k1z_xmmm128b64", Code.EVEX_VCVTTPD2QQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvttpd2qq_ymm_k1z_ymmm256b64", Code.EVEX_VCVTTPD2QQ_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvttpd2qq_zmm_k1z_zmmm512b64_sae", Code.EVEX_VCVTTPD2QQ_ZMM_K1Z_ZMMM512B64_SAE); + map.put("EVEX_Vcvtudq2pd_xmm_k1z_xmmm64b32", Code.EVEX_VCVTUDQ2PD_XMM_K1Z_XMMM64B32); + map.put("EVEX_Vcvtudq2pd_ymm_k1z_xmmm128b32", Code.EVEX_VCVTUDQ2PD_YMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtudq2pd_zmm_k1z_ymmm256b32_er", Code.EVEX_VCVTUDQ2PD_ZMM_K1Z_YMMM256B32_ER); + map.put("EVEX_Vcvtuqq2pd_xmm_k1z_xmmm128b64", Code.EVEX_VCVTUQQ2PD_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtuqq2pd_ymm_k1z_ymmm256b64", Code.EVEX_VCVTUQQ2PD_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtuqq2pd_zmm_k1z_zmmm512b64_er", Code.EVEX_VCVTUQQ2PD_ZMM_K1Z_ZMMM512B64_ER); + map.put("EVEX_Vcvtudq2ps_xmm_k1z_xmmm128b32", Code.EVEX_VCVTUDQ2PS_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtudq2ps_ymm_k1z_ymmm256b32", Code.EVEX_VCVTUDQ2PS_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vcvtudq2ps_zmm_k1z_zmmm512b32_er", Code.EVEX_VCVTUDQ2PS_ZMM_K1Z_ZMMM512B32_ER); + map.put("EVEX_Vcvtuqq2ps_xmm_k1z_xmmm128b64", Code.EVEX_VCVTUQQ2PS_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtuqq2ps_xmm_k1z_ymmm256b64", Code.EVEX_VCVTUQQ2PS_XMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtuqq2ps_ymm_k1z_zmmm512b64_er", Code.EVEX_VCVTUQQ2PS_YMM_K1Z_ZMMM512B64_ER); + map.put("EVEX_Vcvtps2qq_xmm_k1z_xmmm64b32", Code.EVEX_VCVTPS2QQ_XMM_K1Z_XMMM64B32); + map.put("EVEX_Vcvtps2qq_ymm_k1z_xmmm128b32", Code.EVEX_VCVTPS2QQ_YMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtps2qq_zmm_k1z_ymmm256b32_er", Code.EVEX_VCVTPS2QQ_ZMM_K1Z_YMMM256B32_ER); + map.put("EVEX_Vcvtpd2qq_xmm_k1z_xmmm128b64", Code.EVEX_VCVTPD2QQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtpd2qq_ymm_k1z_ymmm256b64", Code.EVEX_VCVTPD2QQ_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtpd2qq_zmm_k1z_zmmm512b64_er", Code.EVEX_VCVTPD2QQ_ZMM_K1Z_ZMMM512B64_ER); + map.put("EVEX_Vcvtusi2ss_xmm_xmm_rm32_er", Code.EVEX_VCVTUSI2SS_XMM_XMM_RM32_ER); + map.put("EVEX_Vcvtusi2ss_xmm_xmm_rm64_er", Code.EVEX_VCVTUSI2SS_XMM_XMM_RM64_ER); + map.put("EVEX_Vcvtusi2sd_xmm_xmm_rm32_er", Code.EVEX_VCVTUSI2SD_XMM_XMM_RM32_ER); + map.put("EVEX_Vcvtusi2sd_xmm_xmm_rm64_er", Code.EVEX_VCVTUSI2SD_XMM_XMM_RM64_ER); + map.put("Haddpd_xmm_xmmm128", Code.HADDPD_XMM_XMMM128); + map.put("VEX_Vhaddpd_xmm_xmm_xmmm128", Code.VEX_VHADDPD_XMM_XMM_XMMM128); + map.put("VEX_Vhaddpd_ymm_ymm_ymmm256", Code.VEX_VHADDPD_YMM_YMM_YMMM256); + map.put("Haddps_xmm_xmmm128", Code.HADDPS_XMM_XMMM128); + map.put("VEX_Vhaddps_xmm_xmm_xmmm128", Code.VEX_VHADDPS_XMM_XMM_XMMM128); + map.put("VEX_Vhaddps_ymm_ymm_ymmm256", Code.VEX_VHADDPS_YMM_YMM_YMMM256); + map.put("Hsubpd_xmm_xmmm128", Code.HSUBPD_XMM_XMMM128); + map.put("VEX_Vhsubpd_xmm_xmm_xmmm128", Code.VEX_VHSUBPD_XMM_XMM_XMMM128); + map.put("VEX_Vhsubpd_ymm_ymm_ymmm256", Code.VEX_VHSUBPD_YMM_YMM_YMMM256); + map.put("Hsubps_xmm_xmmm128", Code.HSUBPS_XMM_XMMM128); + map.put("VEX_Vhsubps_xmm_xmm_xmmm128", Code.VEX_VHSUBPS_XMM_XMM_XMMM128); + map.put("VEX_Vhsubps_ymm_ymm_ymmm256", Code.VEX_VHSUBPS_YMM_YMM_YMMM256); + map.put("Movd_rm32_mm", Code.MOVD_RM32_MM); + map.put("Movq_rm64_mm", Code.MOVQ_RM64_MM); + map.put("Movd_rm32_xmm", Code.MOVD_RM32_XMM); + map.put("Movq_rm64_xmm", Code.MOVQ_RM64_XMM); + map.put("VEX_Vmovd_rm32_xmm", Code.VEX_VMOVD_RM32_XMM); + map.put("VEX_Vmovq_rm64_xmm", Code.VEX_VMOVQ_RM64_XMM); + map.put("EVEX_Vmovd_rm32_xmm", Code.EVEX_VMOVD_RM32_XMM); + map.put("EVEX_Vmovq_rm64_xmm", Code.EVEX_VMOVQ_RM64_XMM); + map.put("Movq_xmm_xmmm64", Code.MOVQ_XMM_XMMM64); + map.put("VEX_Vmovq_xmm_xmmm64", Code.VEX_VMOVQ_XMM_XMMM64); + map.put("EVEX_Vmovq_xmm_xmmm64", Code.EVEX_VMOVQ_XMM_XMMM64); + map.put("Movq_mmm64_mm", Code.MOVQ_MMM64_MM); + map.put("Movdqa_xmmm128_xmm", Code.MOVDQA_XMMM128_XMM); + map.put("VEX_Vmovdqa_xmmm128_xmm", Code.VEX_VMOVDQA_XMMM128_XMM); + map.put("VEX_Vmovdqa_ymmm256_ymm", Code.VEX_VMOVDQA_YMMM256_YMM); + map.put("EVEX_Vmovdqa32_xmmm128_k1z_xmm", Code.EVEX_VMOVDQA32_XMMM128_K1Z_XMM); + map.put("EVEX_Vmovdqa32_ymmm256_k1z_ymm", Code.EVEX_VMOVDQA32_YMMM256_K1Z_YMM); + map.put("EVEX_Vmovdqa32_zmmm512_k1z_zmm", Code.EVEX_VMOVDQA32_ZMMM512_K1Z_ZMM); + map.put("EVEX_Vmovdqa64_xmmm128_k1z_xmm", Code.EVEX_VMOVDQA64_XMMM128_K1Z_XMM); + map.put("EVEX_Vmovdqa64_ymmm256_k1z_ymm", Code.EVEX_VMOVDQA64_YMMM256_K1Z_YMM); + map.put("EVEX_Vmovdqa64_zmmm512_k1z_zmm", Code.EVEX_VMOVDQA64_ZMMM512_K1Z_ZMM); + map.put("Movdqu_xmmm128_xmm", Code.MOVDQU_XMMM128_XMM); + map.put("VEX_Vmovdqu_xmmm128_xmm", Code.VEX_VMOVDQU_XMMM128_XMM); + map.put("VEX_Vmovdqu_ymmm256_ymm", Code.VEX_VMOVDQU_YMMM256_YMM); + map.put("EVEX_Vmovdqu32_xmmm128_k1z_xmm", Code.EVEX_VMOVDQU32_XMMM128_K1Z_XMM); + map.put("EVEX_Vmovdqu32_ymmm256_k1z_ymm", Code.EVEX_VMOVDQU32_YMMM256_K1Z_YMM); + map.put("EVEX_Vmovdqu32_zmmm512_k1z_zmm", Code.EVEX_VMOVDQU32_ZMMM512_K1Z_ZMM); + map.put("EVEX_Vmovdqu64_xmmm128_k1z_xmm", Code.EVEX_VMOVDQU64_XMMM128_K1Z_XMM); + map.put("EVEX_Vmovdqu64_ymmm256_k1z_ymm", Code.EVEX_VMOVDQU64_YMMM256_K1Z_YMM); + map.put("EVEX_Vmovdqu64_zmmm512_k1z_zmm", Code.EVEX_VMOVDQU64_ZMMM512_K1Z_ZMM); + map.put("EVEX_Vmovdqu8_xmmm128_k1z_xmm", Code.EVEX_VMOVDQU8_XMMM128_K1Z_XMM); + map.put("EVEX_Vmovdqu8_ymmm256_k1z_ymm", Code.EVEX_VMOVDQU8_YMMM256_K1Z_YMM); + map.put("EVEX_Vmovdqu8_zmmm512_k1z_zmm", Code.EVEX_VMOVDQU8_ZMMM512_K1Z_ZMM); + map.put("EVEX_Vmovdqu16_xmmm128_k1z_xmm", Code.EVEX_VMOVDQU16_XMMM128_K1Z_XMM); + map.put("EVEX_Vmovdqu16_ymmm256_k1z_ymm", Code.EVEX_VMOVDQU16_YMMM256_K1Z_YMM); + map.put("EVEX_Vmovdqu16_zmmm512_k1z_zmm", Code.EVEX_VMOVDQU16_ZMMM512_K1Z_ZMM); + map.put("Jo_rel16", Code.JO_REL16); + map.put("Jo_rel32_32", Code.JO_REL32_32); + map.put("Jo_rel32_64", Code.JO_REL32_64); + map.put("Jno_rel16", Code.JNO_REL16); + map.put("Jno_rel32_32", Code.JNO_REL32_32); + map.put("Jno_rel32_64", Code.JNO_REL32_64); + map.put("Jb_rel16", Code.JB_REL16); + map.put("Jb_rel32_32", Code.JB_REL32_32); + map.put("Jb_rel32_64", Code.JB_REL32_64); + map.put("Jae_rel16", Code.JAE_REL16); + map.put("Jae_rel32_32", Code.JAE_REL32_32); + map.put("Jae_rel32_64", Code.JAE_REL32_64); + map.put("Je_rel16", Code.JE_REL16); + map.put("Je_rel32_32", Code.JE_REL32_32); + map.put("Je_rel32_64", Code.JE_REL32_64); + map.put("Jne_rel16", Code.JNE_REL16); + map.put("Jne_rel32_32", Code.JNE_REL32_32); + map.put("Jne_rel32_64", Code.JNE_REL32_64); + map.put("Jbe_rel16", Code.JBE_REL16); + map.put("Jbe_rel32_32", Code.JBE_REL32_32); + map.put("Jbe_rel32_64", Code.JBE_REL32_64); + map.put("Ja_rel16", Code.JA_REL16); + map.put("Ja_rel32_32", Code.JA_REL32_32); + map.put("Ja_rel32_64", Code.JA_REL32_64); + map.put("Js_rel16", Code.JS_REL16); + map.put("Js_rel32_32", Code.JS_REL32_32); + map.put("Js_rel32_64", Code.JS_REL32_64); + map.put("Jns_rel16", Code.JNS_REL16); + map.put("Jns_rel32_32", Code.JNS_REL32_32); + map.put("Jns_rel32_64", Code.JNS_REL32_64); + map.put("Jp_rel16", Code.JP_REL16); + map.put("Jp_rel32_32", Code.JP_REL32_32); + map.put("Jp_rel32_64", Code.JP_REL32_64); + map.put("Jnp_rel16", Code.JNP_REL16); + map.put("Jnp_rel32_32", Code.JNP_REL32_32); + map.put("Jnp_rel32_64", Code.JNP_REL32_64); + map.put("Jl_rel16", Code.JL_REL16); + map.put("Jl_rel32_32", Code.JL_REL32_32); + map.put("Jl_rel32_64", Code.JL_REL32_64); + map.put("Jge_rel16", Code.JGE_REL16); + map.put("Jge_rel32_32", Code.JGE_REL32_32); + map.put("Jge_rel32_64", Code.JGE_REL32_64); + map.put("Jle_rel16", Code.JLE_REL16); + map.put("Jle_rel32_32", Code.JLE_REL32_32); + map.put("Jle_rel32_64", Code.JLE_REL32_64); + map.put("Jg_rel16", Code.JG_REL16); + map.put("Jg_rel32_32", Code.JG_REL32_32); + map.put("Jg_rel32_64", Code.JG_REL32_64); + map.put("Seto_rm8", Code.SETO_RM8); + map.put("Setno_rm8", Code.SETNO_RM8); + map.put("Setb_rm8", Code.SETB_RM8); + map.put("Setae_rm8", Code.SETAE_RM8); + map.put("Sete_rm8", Code.SETE_RM8); + map.put("Setne_rm8", Code.SETNE_RM8); + map.put("Setbe_rm8", Code.SETBE_RM8); + map.put("Seta_rm8", Code.SETA_RM8); + map.put("Sets_rm8", Code.SETS_RM8); + map.put("Setns_rm8", Code.SETNS_RM8); + map.put("Setp_rm8", Code.SETP_RM8); + map.put("Setnp_rm8", Code.SETNP_RM8); + map.put("Setl_rm8", Code.SETL_RM8); + map.put("Setge_rm8", Code.SETGE_RM8); + map.put("Setle_rm8", Code.SETLE_RM8); + map.put("Setg_rm8", Code.SETG_RM8); + map.put("VEX_Kmovw_kr_km16", Code.VEX_KMOVW_KR_KM16); + map.put("VEX_Kmovq_kr_km64", Code.VEX_KMOVQ_KR_KM64); + map.put("VEX_Kmovb_kr_km8", Code.VEX_KMOVB_KR_KM8); + map.put("VEX_Kmovd_kr_km32", Code.VEX_KMOVD_KR_KM32); + map.put("VEX_Kmovw_m16_kr", Code.VEX_KMOVW_M16_KR); + map.put("VEX_Kmovq_m64_kr", Code.VEX_KMOVQ_M64_KR); + map.put("VEX_Kmovb_m8_kr", Code.VEX_KMOVB_M8_KR); + map.put("VEX_Kmovd_m32_kr", Code.VEX_KMOVD_M32_KR); + map.put("VEX_Kmovw_kr_r32", Code.VEX_KMOVW_KR_R32); + map.put("VEX_Kmovb_kr_r32", Code.VEX_KMOVB_KR_R32); + map.put("VEX_Kmovd_kr_r32", Code.VEX_KMOVD_KR_R32); + map.put("VEX_Kmovq_kr_r64", Code.VEX_KMOVQ_KR_R64); + map.put("VEX_Kmovw_r32_kr", Code.VEX_KMOVW_R32_KR); + map.put("VEX_Kmovb_r32_kr", Code.VEX_KMOVB_R32_KR); + map.put("VEX_Kmovd_r32_kr", Code.VEX_KMOVD_R32_KR); + map.put("VEX_Kmovq_r64_kr", Code.VEX_KMOVQ_R64_KR); + map.put("VEX_Kortestw_kr_kr", Code.VEX_KORTESTW_KR_KR); + map.put("VEX_Kortestq_kr_kr", Code.VEX_KORTESTQ_KR_KR); + map.put("VEX_Kortestb_kr_kr", Code.VEX_KORTESTB_KR_KR); + map.put("VEX_Kortestd_kr_kr", Code.VEX_KORTESTD_KR_KR); + map.put("VEX_Ktestw_kr_kr", Code.VEX_KTESTW_KR_KR); + map.put("VEX_Ktestq_kr_kr", Code.VEX_KTESTQ_KR_KR); + map.put("VEX_Ktestb_kr_kr", Code.VEX_KTESTB_KR_KR); + map.put("VEX_Ktestd_kr_kr", Code.VEX_KTESTD_KR_KR); + map.put("Pushw_FS", Code.PUSHW_FS); + map.put("Pushd_FS", Code.PUSHD_FS); + map.put("Pushq_FS", Code.PUSHQ_FS); + map.put("Popw_FS", Code.POPW_FS); + map.put("Popd_FS", Code.POPD_FS); + map.put("Popq_FS", Code.POPQ_FS); + map.put("Cpuid", Code.CPUID); + map.put("Bt_rm16_r16", Code.BT_RM16_R16); + map.put("Bt_rm32_r32", Code.BT_RM32_R32); + map.put("Bt_rm64_r64", Code.BT_RM64_R64); + map.put("Shld_rm16_r16_imm8", Code.SHLD_RM16_R16_IMM8); + map.put("Shld_rm32_r32_imm8", Code.SHLD_RM32_R32_IMM8); + map.put("Shld_rm64_r64_imm8", Code.SHLD_RM64_R64_IMM8); + map.put("Shld_rm16_r16_CL", Code.SHLD_RM16_R16_CL); + map.put("Shld_rm32_r32_CL", Code.SHLD_RM32_R32_CL); + map.put("Shld_rm64_r64_CL", Code.SHLD_RM64_R64_CL); + map.put("Montmul_16", Code.MONTMUL_16); + map.put("Montmul_32", Code.MONTMUL_32); + map.put("Montmul_64", Code.MONTMUL_64); + map.put("Xsha1_16", Code.XSHA1_16); + map.put("Xsha1_32", Code.XSHA1_32); + map.put("Xsha1_64", Code.XSHA1_64); + map.put("Xsha256_16", Code.XSHA256_16); + map.put("Xsha256_32", Code.XSHA256_32); + map.put("Xsha256_64", Code.XSHA256_64); + map.put("Xbts_r16_rm16", Code.XBTS_R16_RM16); + map.put("Xbts_r32_rm32", Code.XBTS_R32_RM32); + map.put("Xstore_16", Code.XSTORE_16); + map.put("Xstore_32", Code.XSTORE_32); + map.put("Xstore_64", Code.XSTORE_64); + map.put("Xcryptecb_16", Code.XCRYPTECB_16); + map.put("Xcryptecb_32", Code.XCRYPTECB_32); + map.put("Xcryptecb_64", Code.XCRYPTECB_64); + map.put("Xcryptcbc_16", Code.XCRYPTCBC_16); + map.put("Xcryptcbc_32", Code.XCRYPTCBC_32); + map.put("Xcryptcbc_64", Code.XCRYPTCBC_64); + map.put("Xcryptctr_16", Code.XCRYPTCTR_16); + map.put("Xcryptctr_32", Code.XCRYPTCTR_32); + map.put("Xcryptctr_64", Code.XCRYPTCTR_64); + map.put("Xcryptcfb_16", Code.XCRYPTCFB_16); + map.put("Xcryptcfb_32", Code.XCRYPTCFB_32); + map.put("Xcryptcfb_64", Code.XCRYPTCFB_64); + map.put("Xcryptofb_16", Code.XCRYPTOFB_16); + map.put("Xcryptofb_32", Code.XCRYPTOFB_32); + map.put("Xcryptofb_64", Code.XCRYPTOFB_64); + map.put("Ibts_rm16_r16", Code.IBTS_RM16_R16); + map.put("Ibts_rm32_r32", Code.IBTS_RM32_R32); + map.put("Cmpxchg486_rm8_r8", Code.CMPXCHG486_RM8_R8); + map.put("Cmpxchg486_rm16_r16", Code.CMPXCHG486_RM16_R16); + map.put("Cmpxchg486_rm32_r32", Code.CMPXCHG486_RM32_R32); + map.put("Pushw_GS", Code.PUSHW_GS); + map.put("Pushd_GS", Code.PUSHD_GS); + map.put("Pushq_GS", Code.PUSHQ_GS); + map.put("Popw_GS", Code.POPW_GS); + map.put("Popd_GS", Code.POPD_GS); + map.put("Popq_GS", Code.POPQ_GS); + map.put("Rsm", Code.RSM); + map.put("Bts_rm16_r16", Code.BTS_RM16_R16); + } + + private static void initMap4(HashMap map) { + map.put("Bts_rm32_r32", Code.BTS_RM32_R32); + map.put("Bts_rm64_r64", Code.BTS_RM64_R64); + map.put("Shrd_rm16_r16_imm8", Code.SHRD_RM16_R16_IMM8); + map.put("Shrd_rm32_r32_imm8", Code.SHRD_RM32_R32_IMM8); + map.put("Shrd_rm64_r64_imm8", Code.SHRD_RM64_R64_IMM8); + map.put("Shrd_rm16_r16_CL", Code.SHRD_RM16_R16_CL); + map.put("Shrd_rm32_r32_CL", Code.SHRD_RM32_R32_CL); + map.put("Shrd_rm64_r64_CL", Code.SHRD_RM64_R64_CL); + map.put("Fxsave_m512byte", Code.FXSAVE_M512BYTE); + map.put("Fxsave64_m512byte", Code.FXSAVE64_M512BYTE); + map.put("Rdfsbase_r32", Code.RDFSBASE_R32); + map.put("Rdfsbase_r64", Code.RDFSBASE_R64); + map.put("Fxrstor_m512byte", Code.FXRSTOR_M512BYTE); + map.put("Fxrstor64_m512byte", Code.FXRSTOR64_M512BYTE); + map.put("Rdgsbase_r32", Code.RDGSBASE_R32); + map.put("Rdgsbase_r64", Code.RDGSBASE_R64); + map.put("Ldmxcsr_m32", Code.LDMXCSR_M32); + map.put("Wrfsbase_r32", Code.WRFSBASE_R32); + map.put("Wrfsbase_r64", Code.WRFSBASE_R64); + map.put("VEX_Vldmxcsr_m32", Code.VEX_VLDMXCSR_M32); + map.put("Stmxcsr_m32", Code.STMXCSR_M32); + map.put("Wrgsbase_r32", Code.WRGSBASE_R32); + map.put("Wrgsbase_r64", Code.WRGSBASE_R64); + map.put("VEX_Vstmxcsr_m32", Code.VEX_VSTMXCSR_M32); + map.put("Xsave_mem", Code.XSAVE_MEM); + map.put("Xsave64_mem", Code.XSAVE64_MEM); + map.put("Ptwrite_rm32", Code.PTWRITE_RM32); + map.put("Ptwrite_rm64", Code.PTWRITE_RM64); + map.put("Xrstor_mem", Code.XRSTOR_MEM); + map.put("Xrstor64_mem", Code.XRSTOR64_MEM); + map.put("Incsspd_r32", Code.INCSSPD_R32); + map.put("Incsspq_r64", Code.INCSSPQ_R64); + map.put("Xsaveopt_mem", Code.XSAVEOPT_MEM); + map.put("Xsaveopt64_mem", Code.XSAVEOPT64_MEM); + map.put("Clwb_m8", Code.CLWB_M8); + map.put("Tpause_r32", Code.TPAUSE_R32); + map.put("Tpause_r64", Code.TPAUSE_R64); + map.put("Clrssbsy_m64", Code.CLRSSBSY_M64); + map.put("Umonitor_r16", Code.UMONITOR_R16); + map.put("Umonitor_r32", Code.UMONITOR_R32); + map.put("Umonitor_r64", Code.UMONITOR_R64); + map.put("Umwait_r32", Code.UMWAIT_R32); + map.put("Umwait_r64", Code.UMWAIT_R64); + map.put("Clflush_m8", Code.CLFLUSH_M8); + map.put("Clflushopt_m8", Code.CLFLUSHOPT_M8); + map.put("Lfence", Code.LFENCE); + map.put("Lfence_E9", Code.LFENCE_E9); + map.put("Lfence_EA", Code.LFENCE_EA); + map.put("Lfence_EB", Code.LFENCE_EB); + map.put("Lfence_EC", Code.LFENCE_EC); + map.put("Lfence_ED", Code.LFENCE_ED); + map.put("Lfence_EE", Code.LFENCE_EE); + map.put("Lfence_EF", Code.LFENCE_EF); + map.put("Mfence", Code.MFENCE); + map.put("Mfence_F1", Code.MFENCE_F1); + map.put("Mfence_F2", Code.MFENCE_F2); + map.put("Mfence_F3", Code.MFENCE_F3); + map.put("Mfence_F4", Code.MFENCE_F4); + map.put("Mfence_F5", Code.MFENCE_F5); + map.put("Mfence_F6", Code.MFENCE_F6); + map.put("Mfence_F7", Code.MFENCE_F7); + map.put("Sfence", Code.SFENCE); + map.put("Sfence_F9", Code.SFENCE_F9); + map.put("Sfence_FA", Code.SFENCE_FA); + map.put("Sfence_FB", Code.SFENCE_FB); + map.put("Sfence_FC", Code.SFENCE_FC); + map.put("Sfence_FD", Code.SFENCE_FD); + map.put("Sfence_FE", Code.SFENCE_FE); + map.put("Sfence_FF", Code.SFENCE_FF); + map.put("Pcommit", Code.PCOMMIT); + map.put("Imul_r16_rm16", Code.IMUL_R16_RM16); + map.put("Imul_r32_rm32", Code.IMUL_R32_RM32); + map.put("Imul_r64_rm64", Code.IMUL_R64_RM64); + map.put("Cmpxchg_rm8_r8", Code.CMPXCHG_RM8_R8); + map.put("Cmpxchg_rm16_r16", Code.CMPXCHG_RM16_R16); + map.put("Cmpxchg_rm32_r32", Code.CMPXCHG_RM32_R32); + map.put("Cmpxchg_rm64_r64", Code.CMPXCHG_RM64_R64); + map.put("Lss_r16_m1616", Code.LSS_R16_M1616); + map.put("Lss_r32_m1632", Code.LSS_R32_M1632); + map.put("Lss_r64_m1664", Code.LSS_R64_M1664); + map.put("Btr_rm16_r16", Code.BTR_RM16_R16); + map.put("Btr_rm32_r32", Code.BTR_RM32_R32); + map.put("Btr_rm64_r64", Code.BTR_RM64_R64); + map.put("Lfs_r16_m1616", Code.LFS_R16_M1616); + map.put("Lfs_r32_m1632", Code.LFS_R32_M1632); + map.put("Lfs_r64_m1664", Code.LFS_R64_M1664); + map.put("Lgs_r16_m1616", Code.LGS_R16_M1616); + map.put("Lgs_r32_m1632", Code.LGS_R32_M1632); + map.put("Lgs_r64_m1664", Code.LGS_R64_M1664); + map.put("Movzx_r16_rm8", Code.MOVZX_R16_RM8); + map.put("Movzx_r32_rm8", Code.MOVZX_R32_RM8); + map.put("Movzx_r64_rm8", Code.MOVZX_R64_RM8); + map.put("Movzx_r16_rm16", Code.MOVZX_R16_RM16); + map.put("Movzx_r32_rm16", Code.MOVZX_R32_RM16); + map.put("Movzx_r64_rm16", Code.MOVZX_R64_RM16); + map.put("Jmpe_disp16", Code.JMPE_DISP16); + map.put("Jmpe_disp32", Code.JMPE_DISP32); + map.put("Popcnt_r16_rm16", Code.POPCNT_R16_RM16); + map.put("Popcnt_r32_rm32", Code.POPCNT_R32_RM32); + map.put("Popcnt_r64_rm64", Code.POPCNT_R64_RM64); + map.put("Ud1_r16_rm16", Code.UD1_R16_RM16); + map.put("Ud1_r32_rm32", Code.UD1_R32_RM32); + map.put("Ud1_r64_rm64", Code.UD1_R64_RM64); + map.put("Bt_rm16_imm8", Code.BT_RM16_IMM8); + map.put("Bt_rm32_imm8", Code.BT_RM32_IMM8); + map.put("Bt_rm64_imm8", Code.BT_RM64_IMM8); + map.put("Bts_rm16_imm8", Code.BTS_RM16_IMM8); + map.put("Bts_rm32_imm8", Code.BTS_RM32_IMM8); + map.put("Bts_rm64_imm8", Code.BTS_RM64_IMM8); + map.put("Btr_rm16_imm8", Code.BTR_RM16_IMM8); + map.put("Btr_rm32_imm8", Code.BTR_RM32_IMM8); + map.put("Btr_rm64_imm8", Code.BTR_RM64_IMM8); + map.put("Btc_rm16_imm8", Code.BTC_RM16_IMM8); + map.put("Btc_rm32_imm8", Code.BTC_RM32_IMM8); + map.put("Btc_rm64_imm8", Code.BTC_RM64_IMM8); + map.put("Btc_rm16_r16", Code.BTC_RM16_R16); + map.put("Btc_rm32_r32", Code.BTC_RM32_R32); + map.put("Btc_rm64_r64", Code.BTC_RM64_R64); + map.put("Bsf_r16_rm16", Code.BSF_R16_RM16); + map.put("Bsf_r32_rm32", Code.BSF_R32_RM32); + map.put("Bsf_r64_rm64", Code.BSF_R64_RM64); + map.put("Tzcnt_r16_rm16", Code.TZCNT_R16_RM16); + map.put("Tzcnt_r32_rm32", Code.TZCNT_R32_RM32); + map.put("Tzcnt_r64_rm64", Code.TZCNT_R64_RM64); + map.put("Bsr_r16_rm16", Code.BSR_R16_RM16); + map.put("Bsr_r32_rm32", Code.BSR_R32_RM32); + map.put("Bsr_r64_rm64", Code.BSR_R64_RM64); + map.put("Lzcnt_r16_rm16", Code.LZCNT_R16_RM16); + map.put("Lzcnt_r32_rm32", Code.LZCNT_R32_RM32); + map.put("Lzcnt_r64_rm64", Code.LZCNT_R64_RM64); + map.put("Movsx_r16_rm8", Code.MOVSX_R16_RM8); + map.put("Movsx_r32_rm8", Code.MOVSX_R32_RM8); + map.put("Movsx_r64_rm8", Code.MOVSX_R64_RM8); + map.put("Movsx_r16_rm16", Code.MOVSX_R16_RM16); + map.put("Movsx_r32_rm16", Code.MOVSX_R32_RM16); + map.put("Movsx_r64_rm16", Code.MOVSX_R64_RM16); + map.put("Xadd_rm8_r8", Code.XADD_RM8_R8); + map.put("Xadd_rm16_r16", Code.XADD_RM16_R16); + map.put("Xadd_rm32_r32", Code.XADD_RM32_R32); + map.put("Xadd_rm64_r64", Code.XADD_RM64_R64); + map.put("Cmpps_xmm_xmmm128_imm8", Code.CMPPS_XMM_XMMM128_IMM8); + map.put("VEX_Vcmpps_xmm_xmm_xmmm128_imm8", Code.VEX_VCMPPS_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vcmpps_ymm_ymm_ymmm256_imm8", Code.VEX_VCMPPS_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Vcmpps_kr_k1_xmm_xmmm128b32_imm8", Code.EVEX_VCMPPS_KR_K1_XMM_XMMM128B32_IMM8); + map.put("EVEX_Vcmpps_kr_k1_ymm_ymmm256b32_imm8", Code.EVEX_VCMPPS_KR_K1_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vcmpps_kr_k1_zmm_zmmm512b32_imm8_sae", Code.EVEX_VCMPPS_KR_K1_ZMM_ZMMM512B32_IMM8_SAE); + map.put("Cmppd_xmm_xmmm128_imm8", Code.CMPPD_XMM_XMMM128_IMM8); + map.put("VEX_Vcmppd_xmm_xmm_xmmm128_imm8", Code.VEX_VCMPPD_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vcmppd_ymm_ymm_ymmm256_imm8", Code.VEX_VCMPPD_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Vcmppd_kr_k1_xmm_xmmm128b64_imm8", Code.EVEX_VCMPPD_KR_K1_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vcmppd_kr_k1_ymm_ymmm256b64_imm8", Code.EVEX_VCMPPD_KR_K1_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vcmppd_kr_k1_zmm_zmmm512b64_imm8_sae", Code.EVEX_VCMPPD_KR_K1_ZMM_ZMMM512B64_IMM8_SAE); + map.put("Cmpss_xmm_xmmm32_imm8", Code.CMPSS_XMM_XMMM32_IMM8); + map.put("VEX_Vcmpss_xmm_xmm_xmmm32_imm8", Code.VEX_VCMPSS_XMM_XMM_XMMM32_IMM8); + map.put("EVEX_Vcmpss_kr_k1_xmm_xmmm32_imm8_sae", Code.EVEX_VCMPSS_KR_K1_XMM_XMMM32_IMM8_SAE); + map.put("Cmpsd_xmm_xmmm64_imm8", Code.CMPSD_XMM_XMMM64_IMM8); + map.put("VEX_Vcmpsd_xmm_xmm_xmmm64_imm8", Code.VEX_VCMPSD_XMM_XMM_XMMM64_IMM8); + map.put("EVEX_Vcmpsd_kr_k1_xmm_xmmm64_imm8_sae", Code.EVEX_VCMPSD_KR_K1_XMM_XMMM64_IMM8_SAE); + map.put("Movnti_m32_r32", Code.MOVNTI_M32_R32); + map.put("Movnti_m64_r64", Code.MOVNTI_M64_R64); + map.put("Pinsrw_mm_r32m16_imm8", Code.PINSRW_MM_R32M16_IMM8); + map.put("Pinsrw_mm_r64m16_imm8", Code.PINSRW_MM_R64M16_IMM8); + map.put("Pinsrw_xmm_r32m16_imm8", Code.PINSRW_XMM_R32M16_IMM8); + map.put("Pinsrw_xmm_r64m16_imm8", Code.PINSRW_XMM_R64M16_IMM8); + map.put("VEX_Vpinsrw_xmm_xmm_r32m16_imm8", Code.VEX_VPINSRW_XMM_XMM_R32M16_IMM8); + map.put("VEX_Vpinsrw_xmm_xmm_r64m16_imm8", Code.VEX_VPINSRW_XMM_XMM_R64M16_IMM8); + map.put("EVEX_Vpinsrw_xmm_xmm_r32m16_imm8", Code.EVEX_VPINSRW_XMM_XMM_R32M16_IMM8); + map.put("EVEX_Vpinsrw_xmm_xmm_r64m16_imm8", Code.EVEX_VPINSRW_XMM_XMM_R64M16_IMM8); + map.put("Pextrw_r32_mm_imm8", Code.PEXTRW_R32_MM_IMM8); + map.put("Pextrw_r64_mm_imm8", Code.PEXTRW_R64_MM_IMM8); + map.put("Pextrw_r32_xmm_imm8", Code.PEXTRW_R32_XMM_IMM8); + map.put("Pextrw_r64_xmm_imm8", Code.PEXTRW_R64_XMM_IMM8); + map.put("VEX_Vpextrw_r32_xmm_imm8", Code.VEX_VPEXTRW_R32_XMM_IMM8); + map.put("VEX_Vpextrw_r64_xmm_imm8", Code.VEX_VPEXTRW_R64_XMM_IMM8); + map.put("EVEX_Vpextrw_r32_xmm_imm8", Code.EVEX_VPEXTRW_R32_XMM_IMM8); + map.put("EVEX_Vpextrw_r64_xmm_imm8", Code.EVEX_VPEXTRW_R64_XMM_IMM8); + map.put("Shufps_xmm_xmmm128_imm8", Code.SHUFPS_XMM_XMMM128_IMM8); + map.put("VEX_Vshufps_xmm_xmm_xmmm128_imm8", Code.VEX_VSHUFPS_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vshufps_ymm_ymm_ymmm256_imm8", Code.VEX_VSHUFPS_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Vshufps_xmm_k1z_xmm_xmmm128b32_imm8", Code.EVEX_VSHUFPS_XMM_K1Z_XMM_XMMM128B32_IMM8); + map.put("EVEX_Vshufps_ymm_k1z_ymm_ymmm256b32_imm8", Code.EVEX_VSHUFPS_YMM_K1Z_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vshufps_zmm_k1z_zmm_zmmm512b32_imm8", Code.EVEX_VSHUFPS_ZMM_K1Z_ZMM_ZMMM512B32_IMM8); + map.put("Shufpd_xmm_xmmm128_imm8", Code.SHUFPD_XMM_XMMM128_IMM8); + map.put("VEX_Vshufpd_xmm_xmm_xmmm128_imm8", Code.VEX_VSHUFPD_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vshufpd_ymm_ymm_ymmm256_imm8", Code.VEX_VSHUFPD_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Vshufpd_xmm_k1z_xmm_xmmm128b64_imm8", Code.EVEX_VSHUFPD_XMM_K1Z_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vshufpd_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VSHUFPD_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vshufpd_zmm_k1z_zmm_zmmm512b64_imm8", Code.EVEX_VSHUFPD_ZMM_K1Z_ZMM_ZMMM512B64_IMM8); + map.put("Cmpxchg8b_m64", Code.CMPXCHG8B_M64); + map.put("Cmpxchg16b_m128", Code.CMPXCHG16B_M128); + map.put("Xrstors_mem", Code.XRSTORS_MEM); + map.put("Xrstors64_mem", Code.XRSTORS64_MEM); + map.put("Xsavec_mem", Code.XSAVEC_MEM); + map.put("Xsavec64_mem", Code.XSAVEC64_MEM); + map.put("Xsaves_mem", Code.XSAVES_MEM); + map.put("Xsaves64_mem", Code.XSAVES64_MEM); + map.put("Vmptrld_m64", Code.VMPTRLD_M64); + map.put("Vmclear_m64", Code.VMCLEAR_M64); + map.put("Vmxon_m64", Code.VMXON_M64); + map.put("Rdrand_r16", Code.RDRAND_R16); + map.put("Rdrand_r32", Code.RDRAND_R32); + map.put("Rdrand_r64", Code.RDRAND_R64); + map.put("Vmptrst_m64", Code.VMPTRST_M64); + map.put("Rdseed_r16", Code.RDSEED_R16); + map.put("Rdseed_r32", Code.RDSEED_R32); + map.put("Rdseed_r64", Code.RDSEED_R64); + map.put("Rdpid_r32", Code.RDPID_R32); + map.put("Rdpid_r64", Code.RDPID_R64); + map.put("Bswap_r16", Code.BSWAP_R16); + map.put("Bswap_r32", Code.BSWAP_R32); + map.put("Bswap_r64", Code.BSWAP_R64); + map.put("Addsubpd_xmm_xmmm128", Code.ADDSUBPD_XMM_XMMM128); + map.put("VEX_Vaddsubpd_xmm_xmm_xmmm128", Code.VEX_VADDSUBPD_XMM_XMM_XMMM128); + map.put("VEX_Vaddsubpd_ymm_ymm_ymmm256", Code.VEX_VADDSUBPD_YMM_YMM_YMMM256); + map.put("Addsubps_xmm_xmmm128", Code.ADDSUBPS_XMM_XMMM128); + map.put("VEX_Vaddsubps_xmm_xmm_xmmm128", Code.VEX_VADDSUBPS_XMM_XMM_XMMM128); + map.put("VEX_Vaddsubps_ymm_ymm_ymmm256", Code.VEX_VADDSUBPS_YMM_YMM_YMMM256); + map.put("Psrlw_mm_mmm64", Code.PSRLW_MM_MMM64); + map.put("Psrlw_xmm_xmmm128", Code.PSRLW_XMM_XMMM128); + map.put("VEX_Vpsrlw_xmm_xmm_xmmm128", Code.VEX_VPSRLW_XMM_XMM_XMMM128); + map.put("VEX_Vpsrlw_ymm_ymm_xmmm128", Code.VEX_VPSRLW_YMM_YMM_XMMM128); + map.put("EVEX_Vpsrlw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSRLW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsrlw_ymm_k1z_ymm_xmmm128", Code.EVEX_VPSRLW_YMM_K1Z_YMM_XMMM128); + map.put("EVEX_Vpsrlw_zmm_k1z_zmm_xmmm128", Code.EVEX_VPSRLW_ZMM_K1Z_ZMM_XMMM128); + map.put("Psrld_mm_mmm64", Code.PSRLD_MM_MMM64); + map.put("Psrld_xmm_xmmm128", Code.PSRLD_XMM_XMMM128); + map.put("VEX_Vpsrld_xmm_xmm_xmmm128", Code.VEX_VPSRLD_XMM_XMM_XMMM128); + map.put("VEX_Vpsrld_ymm_ymm_xmmm128", Code.VEX_VPSRLD_YMM_YMM_XMMM128); + map.put("EVEX_Vpsrld_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSRLD_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsrld_ymm_k1z_ymm_xmmm128", Code.EVEX_VPSRLD_YMM_K1Z_YMM_XMMM128); + map.put("EVEX_Vpsrld_zmm_k1z_zmm_xmmm128", Code.EVEX_VPSRLD_ZMM_K1Z_ZMM_XMMM128); + map.put("Psrlq_mm_mmm64", Code.PSRLQ_MM_MMM64); + map.put("Psrlq_xmm_xmmm128", Code.PSRLQ_XMM_XMMM128); + map.put("VEX_Vpsrlq_xmm_xmm_xmmm128", Code.VEX_VPSRLQ_XMM_XMM_XMMM128); + map.put("VEX_Vpsrlq_ymm_ymm_xmmm128", Code.VEX_VPSRLQ_YMM_YMM_XMMM128); + map.put("EVEX_Vpsrlq_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSRLQ_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsrlq_ymm_k1z_ymm_xmmm128", Code.EVEX_VPSRLQ_YMM_K1Z_YMM_XMMM128); + map.put("EVEX_Vpsrlq_zmm_k1z_zmm_xmmm128", Code.EVEX_VPSRLQ_ZMM_K1Z_ZMM_XMMM128); + map.put("Paddq_mm_mmm64", Code.PADDQ_MM_MMM64); + map.put("Paddq_xmm_xmmm128", Code.PADDQ_XMM_XMMM128); + map.put("VEX_Vpaddq_xmm_xmm_xmmm128", Code.VEX_VPADDQ_XMM_XMM_XMMM128); + map.put("VEX_Vpaddq_ymm_ymm_ymmm256", Code.VEX_VPADDQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpaddq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPADDQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpaddq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPADDQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpaddq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPADDQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Pmullw_mm_mmm64", Code.PMULLW_MM_MMM64); + map.put("Pmullw_xmm_xmmm128", Code.PMULLW_XMM_XMMM128); + map.put("VEX_Vpmullw_xmm_xmm_xmmm128", Code.VEX_VPMULLW_XMM_XMM_XMMM128); + map.put("VEX_Vpmullw_ymm_ymm_ymmm256", Code.VEX_VPMULLW_YMM_YMM_YMMM256); + map.put("EVEX_Vpmullw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMULLW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpmullw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMULLW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpmullw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMULLW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Movq_xmmm64_xmm", Code.MOVQ_XMMM64_XMM); + map.put("VEX_Vmovq_xmmm64_xmm", Code.VEX_VMOVQ_XMMM64_XMM); + map.put("EVEX_Vmovq_xmmm64_xmm", Code.EVEX_VMOVQ_XMMM64_XMM); + map.put("Movq2dq_xmm_mm", Code.MOVQ2DQ_XMM_MM); + map.put("Movdq2q_mm_xmm", Code.MOVDQ2Q_MM_XMM); + map.put("Pmovmskb_r32_mm", Code.PMOVMSKB_R32_MM); + map.put("Pmovmskb_r64_mm", Code.PMOVMSKB_R64_MM); + map.put("Pmovmskb_r32_xmm", Code.PMOVMSKB_R32_XMM); + map.put("Pmovmskb_r64_xmm", Code.PMOVMSKB_R64_XMM); + map.put("VEX_Vpmovmskb_r32_xmm", Code.VEX_VPMOVMSKB_R32_XMM); + map.put("VEX_Vpmovmskb_r64_xmm", Code.VEX_VPMOVMSKB_R64_XMM); + map.put("VEX_Vpmovmskb_r32_ymm", Code.VEX_VPMOVMSKB_R32_YMM); + map.put("VEX_Vpmovmskb_r64_ymm", Code.VEX_VPMOVMSKB_R64_YMM); + map.put("Psubusb_mm_mmm64", Code.PSUBUSB_MM_MMM64); + map.put("Psubusb_xmm_xmmm128", Code.PSUBUSB_XMM_XMMM128); + map.put("VEX_Vpsubusb_xmm_xmm_xmmm128", Code.VEX_VPSUBUSB_XMM_XMM_XMMM128); + map.put("VEX_Vpsubusb_ymm_ymm_ymmm256", Code.VEX_VPSUBUSB_YMM_YMM_YMMM256); + map.put("EVEX_Vpsubusb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSUBUSB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsubusb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSUBUSB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpsubusb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSUBUSB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Psubusw_mm_mmm64", Code.PSUBUSW_MM_MMM64); + map.put("Psubusw_xmm_xmmm128", Code.PSUBUSW_XMM_XMMM128); + map.put("VEX_Vpsubusw_xmm_xmm_xmmm128", Code.VEX_VPSUBUSW_XMM_XMM_XMMM128); + map.put("VEX_Vpsubusw_ymm_ymm_ymmm256", Code.VEX_VPSUBUSW_YMM_YMM_YMMM256); + map.put("EVEX_Vpsubusw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSUBUSW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsubusw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSUBUSW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpsubusw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSUBUSW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pminub_mm_mmm64", Code.PMINUB_MM_MMM64); + map.put("Pminub_xmm_xmmm128", Code.PMINUB_XMM_XMMM128); + map.put("VEX_Vpminub_xmm_xmm_xmmm128", Code.VEX_VPMINUB_XMM_XMM_XMMM128); + map.put("VEX_Vpminub_ymm_ymm_ymmm256", Code.VEX_VPMINUB_YMM_YMM_YMMM256); + map.put("EVEX_Vpminub_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMINUB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpminub_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMINUB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpminub_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMINUB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pand_mm_mmm64", Code.PAND_MM_MMM64); + map.put("Pand_xmm_xmmm128", Code.PAND_XMM_XMMM128); + map.put("VEX_Vpand_xmm_xmm_xmmm128", Code.VEX_VPAND_XMM_XMM_XMMM128); + map.put("VEX_Vpand_ymm_ymm_ymmm256", Code.VEX_VPAND_YMM_YMM_YMMM256); + map.put("EVEX_Vpandd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPANDD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpandd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPANDD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpandd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPANDD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpandq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPANDQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpandq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPANDQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpandq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPANDQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Paddusb_mm_mmm64", Code.PADDUSB_MM_MMM64); + map.put("Paddusb_xmm_xmmm128", Code.PADDUSB_XMM_XMMM128); + map.put("VEX_Vpaddusb_xmm_xmm_xmmm128", Code.VEX_VPADDUSB_XMM_XMM_XMMM128); + map.put("VEX_Vpaddusb_ymm_ymm_ymmm256", Code.VEX_VPADDUSB_YMM_YMM_YMMM256); + map.put("EVEX_Vpaddusb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPADDUSB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpaddusb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPADDUSB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpaddusb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPADDUSB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Paddusw_mm_mmm64", Code.PADDUSW_MM_MMM64); + map.put("Paddusw_xmm_xmmm128", Code.PADDUSW_XMM_XMMM128); + map.put("VEX_Vpaddusw_xmm_xmm_xmmm128", Code.VEX_VPADDUSW_XMM_XMM_XMMM128); + map.put("VEX_Vpaddusw_ymm_ymm_ymmm256", Code.VEX_VPADDUSW_YMM_YMM_YMMM256); + map.put("EVEX_Vpaddusw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPADDUSW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpaddusw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPADDUSW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpaddusw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPADDUSW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pmaxub_mm_mmm64", Code.PMAXUB_MM_MMM64); + map.put("Pmaxub_xmm_xmmm128", Code.PMAXUB_XMM_XMMM128); + map.put("VEX_Vpmaxub_xmm_xmm_xmmm128", Code.VEX_VPMAXUB_XMM_XMM_XMMM128); + map.put("VEX_Vpmaxub_ymm_ymm_ymmm256", Code.VEX_VPMAXUB_YMM_YMM_YMMM256); + map.put("EVEX_Vpmaxub_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMAXUB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpmaxub_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMAXUB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpmaxub_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMAXUB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pandn_mm_mmm64", Code.PANDN_MM_MMM64); + map.put("Pandn_xmm_xmmm128", Code.PANDN_XMM_XMMM128); + map.put("VEX_Vpandn_xmm_xmm_xmmm128", Code.VEX_VPANDN_XMM_XMM_XMMM128); + map.put("VEX_Vpandn_ymm_ymm_ymmm256", Code.VEX_VPANDN_YMM_YMM_YMMM256); + map.put("EVEX_Vpandnd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPANDND_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpandnd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPANDND_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpandnd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPANDND_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpandnq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPANDNQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpandnq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPANDNQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpandnq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPANDNQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Pavgb_mm_mmm64", Code.PAVGB_MM_MMM64); + map.put("Pavgb_xmm_xmmm128", Code.PAVGB_XMM_XMMM128); + map.put("VEX_Vpavgb_xmm_xmm_xmmm128", Code.VEX_VPAVGB_XMM_XMM_XMMM128); + map.put("VEX_Vpavgb_ymm_ymm_ymmm256", Code.VEX_VPAVGB_YMM_YMM_YMMM256); + map.put("EVEX_Vpavgb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPAVGB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpavgb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPAVGB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpavgb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPAVGB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Psraw_mm_mmm64", Code.PSRAW_MM_MMM64); + map.put("Psraw_xmm_xmmm128", Code.PSRAW_XMM_XMMM128); + map.put("VEX_Vpsraw_xmm_xmm_xmmm128", Code.VEX_VPSRAW_XMM_XMM_XMMM128); + map.put("VEX_Vpsraw_ymm_ymm_xmmm128", Code.VEX_VPSRAW_YMM_YMM_XMMM128); + map.put("EVEX_Vpsraw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSRAW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsraw_ymm_k1z_ymm_xmmm128", Code.EVEX_VPSRAW_YMM_K1Z_YMM_XMMM128); + map.put("EVEX_Vpsraw_zmm_k1z_zmm_xmmm128", Code.EVEX_VPSRAW_ZMM_K1Z_ZMM_XMMM128); + map.put("Psrad_mm_mmm64", Code.PSRAD_MM_MMM64); + map.put("Psrad_xmm_xmmm128", Code.PSRAD_XMM_XMMM128); + map.put("VEX_Vpsrad_xmm_xmm_xmmm128", Code.VEX_VPSRAD_XMM_XMM_XMMM128); + map.put("VEX_Vpsrad_ymm_ymm_xmmm128", Code.VEX_VPSRAD_YMM_YMM_XMMM128); + map.put("EVEX_Vpsrad_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSRAD_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsrad_ymm_k1z_ymm_xmmm128", Code.EVEX_VPSRAD_YMM_K1Z_YMM_XMMM128); + map.put("EVEX_Vpsrad_zmm_k1z_zmm_xmmm128", Code.EVEX_VPSRAD_ZMM_K1Z_ZMM_XMMM128); + map.put("EVEX_Vpsraq_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSRAQ_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsraq_ymm_k1z_ymm_xmmm128", Code.EVEX_VPSRAQ_YMM_K1Z_YMM_XMMM128); + map.put("EVEX_Vpsraq_zmm_k1z_zmm_xmmm128", Code.EVEX_VPSRAQ_ZMM_K1Z_ZMM_XMMM128); + map.put("Pavgw_mm_mmm64", Code.PAVGW_MM_MMM64); + map.put("Pavgw_xmm_xmmm128", Code.PAVGW_XMM_XMMM128); + map.put("VEX_Vpavgw_xmm_xmm_xmmm128", Code.VEX_VPAVGW_XMM_XMM_XMMM128); + map.put("VEX_Vpavgw_ymm_ymm_ymmm256", Code.VEX_VPAVGW_YMM_YMM_YMMM256); + map.put("EVEX_Vpavgw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPAVGW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpavgw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPAVGW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpavgw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPAVGW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pmulhuw_mm_mmm64", Code.PMULHUW_MM_MMM64); + map.put("Pmulhuw_xmm_xmmm128", Code.PMULHUW_XMM_XMMM128); + map.put("VEX_Vpmulhuw_xmm_xmm_xmmm128", Code.VEX_VPMULHUW_XMM_XMM_XMMM128); + map.put("VEX_Vpmulhuw_ymm_ymm_ymmm256", Code.VEX_VPMULHUW_YMM_YMM_YMMM256); + map.put("EVEX_Vpmulhuw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMULHUW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpmulhuw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMULHUW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpmulhuw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMULHUW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pmulhw_mm_mmm64", Code.PMULHW_MM_MMM64); + map.put("Pmulhw_xmm_xmmm128", Code.PMULHW_XMM_XMMM128); + map.put("VEX_Vpmulhw_xmm_xmm_xmmm128", Code.VEX_VPMULHW_XMM_XMM_XMMM128); + map.put("VEX_Vpmulhw_ymm_ymm_ymmm256", Code.VEX_VPMULHW_YMM_YMM_YMMM256); + map.put("EVEX_Vpmulhw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMULHW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpmulhw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMULHW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpmulhw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMULHW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Cvttpd2dq_xmm_xmmm128", Code.CVTTPD2DQ_XMM_XMMM128); + map.put("VEX_Vcvttpd2dq_xmm_xmmm128", Code.VEX_VCVTTPD2DQ_XMM_XMMM128); + map.put("VEX_Vcvttpd2dq_xmm_ymmm256", Code.VEX_VCVTTPD2DQ_XMM_YMMM256); + map.put("EVEX_Vcvttpd2dq_xmm_k1z_xmmm128b64", Code.EVEX_VCVTTPD2DQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvttpd2dq_xmm_k1z_ymmm256b64", Code.EVEX_VCVTTPD2DQ_XMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvttpd2dq_ymm_k1z_zmmm512b64_sae", Code.EVEX_VCVTTPD2DQ_YMM_K1Z_ZMMM512B64_SAE); + map.put("Cvtdq2pd_xmm_xmmm64", Code.CVTDQ2PD_XMM_XMMM64); + map.put("VEX_Vcvtdq2pd_xmm_xmmm64", Code.VEX_VCVTDQ2PD_XMM_XMMM64); + map.put("VEX_Vcvtdq2pd_ymm_xmmm128", Code.VEX_VCVTDQ2PD_YMM_XMMM128); + map.put("EVEX_Vcvtdq2pd_xmm_k1z_xmmm64b32", Code.EVEX_VCVTDQ2PD_XMM_K1Z_XMMM64B32); + map.put("EVEX_Vcvtdq2pd_ymm_k1z_xmmm128b32", Code.EVEX_VCVTDQ2PD_YMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtdq2pd_zmm_k1z_ymmm256b32_er", Code.EVEX_VCVTDQ2PD_ZMM_K1Z_YMMM256B32_ER); + map.put("EVEX_Vcvtqq2pd_xmm_k1z_xmmm128b64", Code.EVEX_VCVTQQ2PD_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtqq2pd_ymm_k1z_ymmm256b64", Code.EVEX_VCVTQQ2PD_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtqq2pd_zmm_k1z_zmmm512b64_er", Code.EVEX_VCVTQQ2PD_ZMM_K1Z_ZMMM512B64_ER); + map.put("Cvtpd2dq_xmm_xmmm128", Code.CVTPD2DQ_XMM_XMMM128); + map.put("VEX_Vcvtpd2dq_xmm_xmmm128", Code.VEX_VCVTPD2DQ_XMM_XMMM128); + map.put("VEX_Vcvtpd2dq_xmm_ymmm256", Code.VEX_VCVTPD2DQ_XMM_YMMM256); + map.put("EVEX_Vcvtpd2dq_xmm_k1z_xmmm128b64", Code.EVEX_VCVTPD2DQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtpd2dq_xmm_k1z_ymmm256b64", Code.EVEX_VCVTPD2DQ_XMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtpd2dq_ymm_k1z_zmmm512b64_er", Code.EVEX_VCVTPD2DQ_YMM_K1Z_ZMMM512B64_ER); + map.put("Movntq_m64_mm", Code.MOVNTQ_M64_MM); + map.put("Movntdq_m128_xmm", Code.MOVNTDQ_M128_XMM); + map.put("VEX_Vmovntdq_m128_xmm", Code.VEX_VMOVNTDQ_M128_XMM); + map.put("VEX_Vmovntdq_m256_ymm", Code.VEX_VMOVNTDQ_M256_YMM); + map.put("EVEX_Vmovntdq_m128_xmm", Code.EVEX_VMOVNTDQ_M128_XMM); + map.put("EVEX_Vmovntdq_m256_ymm", Code.EVEX_VMOVNTDQ_M256_YMM); + map.put("EVEX_Vmovntdq_m512_zmm", Code.EVEX_VMOVNTDQ_M512_ZMM); + map.put("Psubsb_mm_mmm64", Code.PSUBSB_MM_MMM64); + map.put("Psubsb_xmm_xmmm128", Code.PSUBSB_XMM_XMMM128); + map.put("VEX_Vpsubsb_xmm_xmm_xmmm128", Code.VEX_VPSUBSB_XMM_XMM_XMMM128); + map.put("VEX_Vpsubsb_ymm_ymm_ymmm256", Code.VEX_VPSUBSB_YMM_YMM_YMMM256); + map.put("EVEX_Vpsubsb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSUBSB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsubsb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSUBSB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpsubsb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSUBSB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Psubsw_mm_mmm64", Code.PSUBSW_MM_MMM64); + map.put("Psubsw_xmm_xmmm128", Code.PSUBSW_XMM_XMMM128); + map.put("VEX_Vpsubsw_xmm_xmm_xmmm128", Code.VEX_VPSUBSW_XMM_XMM_XMMM128); + map.put("VEX_Vpsubsw_ymm_ymm_ymmm256", Code.VEX_VPSUBSW_YMM_YMM_YMMM256); + map.put("EVEX_Vpsubsw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSUBSW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsubsw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSUBSW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpsubsw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSUBSW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pminsw_mm_mmm64", Code.PMINSW_MM_MMM64); + map.put("Pminsw_xmm_xmmm128", Code.PMINSW_XMM_XMMM128); + map.put("VEX_Vpminsw_xmm_xmm_xmmm128", Code.VEX_VPMINSW_XMM_XMM_XMMM128); + map.put("VEX_Vpminsw_ymm_ymm_ymmm256", Code.VEX_VPMINSW_YMM_YMM_YMMM256); + map.put("EVEX_Vpminsw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMINSW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpminsw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMINSW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpminsw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMINSW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Por_mm_mmm64", Code.POR_MM_MMM64); + map.put("Por_xmm_xmmm128", Code.POR_XMM_XMMM128); + map.put("VEX_Vpor_xmm_xmm_xmmm128", Code.VEX_VPOR_XMM_XMM_XMMM128); + map.put("VEX_Vpor_ymm_ymm_ymmm256", Code.VEX_VPOR_YMM_YMM_YMMM256); + map.put("EVEX_Vpord_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPORD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpord_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPORD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpord_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPORD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vporq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPORQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vporq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPORQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vporq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPORQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Paddsb_mm_mmm64", Code.PADDSB_MM_MMM64); + map.put("Paddsb_xmm_xmmm128", Code.PADDSB_XMM_XMMM128); + map.put("VEX_Vpaddsb_xmm_xmm_xmmm128", Code.VEX_VPADDSB_XMM_XMM_XMMM128); + map.put("VEX_Vpaddsb_ymm_ymm_ymmm256", Code.VEX_VPADDSB_YMM_YMM_YMMM256); + map.put("EVEX_Vpaddsb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPADDSB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpaddsb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPADDSB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpaddsb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPADDSB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Paddsw_mm_mmm64", Code.PADDSW_MM_MMM64); + map.put("Paddsw_xmm_xmmm128", Code.PADDSW_XMM_XMMM128); + map.put("VEX_Vpaddsw_xmm_xmm_xmmm128", Code.VEX_VPADDSW_XMM_XMM_XMMM128); + map.put("VEX_Vpaddsw_ymm_ymm_ymmm256", Code.VEX_VPADDSW_YMM_YMM_YMMM256); + map.put("EVEX_Vpaddsw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPADDSW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpaddsw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPADDSW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpaddsw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPADDSW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pmaxsw_mm_mmm64", Code.PMAXSW_MM_MMM64); + map.put("Pmaxsw_xmm_xmmm128", Code.PMAXSW_XMM_XMMM128); + map.put("VEX_Vpmaxsw_xmm_xmm_xmmm128", Code.VEX_VPMAXSW_XMM_XMM_XMMM128); + map.put("VEX_Vpmaxsw_ymm_ymm_ymmm256", Code.VEX_VPMAXSW_YMM_YMM_YMMM256); + map.put("EVEX_Vpmaxsw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMAXSW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpmaxsw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMAXSW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpmaxsw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMAXSW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pxor_mm_mmm64", Code.PXOR_MM_MMM64); + map.put("Pxor_xmm_xmmm128", Code.PXOR_XMM_XMMM128); + map.put("VEX_Vpxor_xmm_xmm_xmmm128", Code.VEX_VPXOR_XMM_XMM_XMMM128); + map.put("VEX_Vpxor_ymm_ymm_ymmm256", Code.VEX_VPXOR_YMM_YMM_YMMM256); + map.put("EVEX_Vpxord_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPXORD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpxord_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPXORD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpxord_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPXORD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpxorq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPXORQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpxorq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPXORQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpxorq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPXORQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Lddqu_xmm_m128", Code.LDDQU_XMM_M128); + map.put("VEX_Vlddqu_xmm_m128", Code.VEX_VLDDQU_XMM_M128); + map.put("VEX_Vlddqu_ymm_m256", Code.VEX_VLDDQU_YMM_M256); + map.put("Psllw_mm_mmm64", Code.PSLLW_MM_MMM64); + map.put("Psllw_xmm_xmmm128", Code.PSLLW_XMM_XMMM128); + map.put("VEX_Vpsllw_xmm_xmm_xmmm128", Code.VEX_VPSLLW_XMM_XMM_XMMM128); + map.put("VEX_Vpsllw_ymm_ymm_xmmm128", Code.VEX_VPSLLW_YMM_YMM_XMMM128); + map.put("EVEX_Vpsllw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSLLW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsllw_ymm_k1z_ymm_xmmm128", Code.EVEX_VPSLLW_YMM_K1Z_YMM_XMMM128); + map.put("EVEX_Vpsllw_zmm_k1z_zmm_xmmm128", Code.EVEX_VPSLLW_ZMM_K1Z_ZMM_XMMM128); + map.put("Pslld_mm_mmm64", Code.PSLLD_MM_MMM64); + map.put("Pslld_xmm_xmmm128", Code.PSLLD_XMM_XMMM128); + map.put("VEX_Vpslld_xmm_xmm_xmmm128", Code.VEX_VPSLLD_XMM_XMM_XMMM128); + map.put("VEX_Vpslld_ymm_ymm_xmmm128", Code.VEX_VPSLLD_YMM_YMM_XMMM128); + map.put("EVEX_Vpslld_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSLLD_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpslld_ymm_k1z_ymm_xmmm128", Code.EVEX_VPSLLD_YMM_K1Z_YMM_XMMM128); + map.put("EVEX_Vpslld_zmm_k1z_zmm_xmmm128", Code.EVEX_VPSLLD_ZMM_K1Z_ZMM_XMMM128); + map.put("Psllq_mm_mmm64", Code.PSLLQ_MM_MMM64); + map.put("Psllq_xmm_xmmm128", Code.PSLLQ_XMM_XMMM128); + map.put("VEX_Vpsllq_xmm_xmm_xmmm128", Code.VEX_VPSLLQ_XMM_XMM_XMMM128); + map.put("VEX_Vpsllq_ymm_ymm_xmmm128", Code.VEX_VPSLLQ_YMM_YMM_XMMM128); + map.put("EVEX_Vpsllq_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSLLQ_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsllq_ymm_k1z_ymm_xmmm128", Code.EVEX_VPSLLQ_YMM_K1Z_YMM_XMMM128); + map.put("EVEX_Vpsllq_zmm_k1z_zmm_xmmm128", Code.EVEX_VPSLLQ_ZMM_K1Z_ZMM_XMMM128); + map.put("Pmuludq_mm_mmm64", Code.PMULUDQ_MM_MMM64); + map.put("Pmuludq_xmm_xmmm128", Code.PMULUDQ_XMM_XMMM128); + map.put("VEX_Vpmuludq_xmm_xmm_xmmm128", Code.VEX_VPMULUDQ_XMM_XMM_XMMM128); + map.put("VEX_Vpmuludq_ymm_ymm_ymmm256", Code.VEX_VPMULUDQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpmuludq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPMULUDQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpmuludq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPMULUDQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpmuludq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPMULUDQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Pmaddwd_mm_mmm64", Code.PMADDWD_MM_MMM64); + map.put("Pmaddwd_xmm_xmmm128", Code.PMADDWD_XMM_XMMM128); + map.put("VEX_Vpmaddwd_xmm_xmm_xmmm128", Code.VEX_VPMADDWD_XMM_XMM_XMMM128); + map.put("VEX_Vpmaddwd_ymm_ymm_ymmm256", Code.VEX_VPMADDWD_YMM_YMM_YMMM256); + map.put("EVEX_Vpmaddwd_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMADDWD_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpmaddwd_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMADDWD_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpmaddwd_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMADDWD_ZMM_K1Z_ZMM_ZMMM512); + } + + private static void initMap5(HashMap map) { + map.put("Psadbw_mm_mmm64", Code.PSADBW_MM_MMM64); + map.put("Psadbw_xmm_xmmm128", Code.PSADBW_XMM_XMMM128); + map.put("VEX_Vpsadbw_xmm_xmm_xmmm128", Code.VEX_VPSADBW_XMM_XMM_XMMM128); + map.put("VEX_Vpsadbw_ymm_ymm_ymmm256", Code.VEX_VPSADBW_YMM_YMM_YMMM256); + map.put("EVEX_Vpsadbw_xmm_xmm_xmmm128", Code.EVEX_VPSADBW_XMM_XMM_XMMM128); + map.put("EVEX_Vpsadbw_ymm_ymm_ymmm256", Code.EVEX_VPSADBW_YMM_YMM_YMMM256); + map.put("EVEX_Vpsadbw_zmm_zmm_zmmm512", Code.EVEX_VPSADBW_ZMM_ZMM_ZMMM512); + map.put("Maskmovq_rDI_mm_mm", Code.MASKMOVQ_RDI_MM_MM); + map.put("Maskmovdqu_rDI_xmm_xmm", Code.MASKMOVDQU_RDI_XMM_XMM); + map.put("VEX_Vmaskmovdqu_rDI_xmm_xmm", Code.VEX_VMASKMOVDQU_RDI_XMM_XMM); + map.put("Psubb_mm_mmm64", Code.PSUBB_MM_MMM64); + map.put("Psubb_xmm_xmmm128", Code.PSUBB_XMM_XMMM128); + map.put("VEX_Vpsubb_xmm_xmm_xmmm128", Code.VEX_VPSUBB_XMM_XMM_XMMM128); + map.put("VEX_Vpsubb_ymm_ymm_ymmm256", Code.VEX_VPSUBB_YMM_YMM_YMMM256); + map.put("EVEX_Vpsubb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSUBB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsubb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSUBB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpsubb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSUBB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Psubw_mm_mmm64", Code.PSUBW_MM_MMM64); + map.put("Psubw_xmm_xmmm128", Code.PSUBW_XMM_XMMM128); + map.put("VEX_Vpsubw_xmm_xmm_xmmm128", Code.VEX_VPSUBW_XMM_XMM_XMMM128); + map.put("VEX_Vpsubw_ymm_ymm_ymmm256", Code.VEX_VPSUBW_YMM_YMM_YMMM256); + map.put("EVEX_Vpsubw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSUBW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsubw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSUBW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpsubw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSUBW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Psubd_mm_mmm64", Code.PSUBD_MM_MMM64); + map.put("Psubd_xmm_xmmm128", Code.PSUBD_XMM_XMMM128); + map.put("VEX_Vpsubd_xmm_xmm_xmmm128", Code.VEX_VPSUBD_XMM_XMM_XMMM128); + map.put("VEX_Vpsubd_ymm_ymm_ymmm256", Code.VEX_VPSUBD_YMM_YMM_YMMM256); + map.put("EVEX_Vpsubd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPSUBD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpsubd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPSUBD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpsubd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPSUBD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Psubq_mm_mmm64", Code.PSUBQ_MM_MMM64); + map.put("Psubq_xmm_xmmm128", Code.PSUBQ_XMM_XMMM128); + map.put("VEX_Vpsubq_xmm_xmm_xmmm128", Code.VEX_VPSUBQ_XMM_XMM_XMMM128); + map.put("VEX_Vpsubq_ymm_ymm_ymmm256", Code.VEX_VPSUBQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpsubq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPSUBQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpsubq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPSUBQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpsubq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPSUBQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Paddb_mm_mmm64", Code.PADDB_MM_MMM64); + map.put("Paddb_xmm_xmmm128", Code.PADDB_XMM_XMMM128); + map.put("VEX_Vpaddb_xmm_xmm_xmmm128", Code.VEX_VPADDB_XMM_XMM_XMMM128); + map.put("VEX_Vpaddb_ymm_ymm_ymmm256", Code.VEX_VPADDB_YMM_YMM_YMMM256); + map.put("EVEX_Vpaddb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPADDB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpaddb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPADDB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpaddb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPADDB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Paddw_mm_mmm64", Code.PADDW_MM_MMM64); + map.put("Paddw_xmm_xmmm128", Code.PADDW_XMM_XMMM128); + map.put("VEX_Vpaddw_xmm_xmm_xmmm128", Code.VEX_VPADDW_XMM_XMM_XMMM128); + map.put("VEX_Vpaddw_ymm_ymm_ymmm256", Code.VEX_VPADDW_YMM_YMM_YMMM256); + map.put("EVEX_Vpaddw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPADDW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpaddw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPADDW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpaddw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPADDW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Paddd_mm_mmm64", Code.PADDD_MM_MMM64); + map.put("Paddd_xmm_xmmm128", Code.PADDD_XMM_XMMM128); + map.put("VEX_Vpaddd_xmm_xmm_xmmm128", Code.VEX_VPADDD_XMM_XMM_XMMM128); + map.put("VEX_Vpaddd_ymm_ymm_ymmm256", Code.VEX_VPADDD_YMM_YMM_YMMM256); + map.put("EVEX_Vpaddd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPADDD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpaddd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPADDD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpaddd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPADDD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("Ud0_r16_rm16", Code.UD0_R16_RM16); + map.put("Ud0_r32_rm32", Code.UD0_R32_RM32); + map.put("Ud0_r64_rm64", Code.UD0_R64_RM64); + map.put("Pshufb_mm_mmm64", Code.PSHUFB_MM_MMM64); + map.put("Pshufb_xmm_xmmm128", Code.PSHUFB_XMM_XMMM128); + map.put("VEX_Vpshufb_xmm_xmm_xmmm128", Code.VEX_VPSHUFB_XMM_XMM_XMMM128); + map.put("VEX_Vpshufb_ymm_ymm_ymmm256", Code.VEX_VPSHUFB_YMM_YMM_YMMM256); + map.put("EVEX_Vpshufb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSHUFB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpshufb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSHUFB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpshufb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSHUFB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Phaddw_mm_mmm64", Code.PHADDW_MM_MMM64); + map.put("Phaddw_xmm_xmmm128", Code.PHADDW_XMM_XMMM128); + map.put("VEX_Vphaddw_xmm_xmm_xmmm128", Code.VEX_VPHADDW_XMM_XMM_XMMM128); + map.put("VEX_Vphaddw_ymm_ymm_ymmm256", Code.VEX_VPHADDW_YMM_YMM_YMMM256); + map.put("Phaddd_mm_mmm64", Code.PHADDD_MM_MMM64); + map.put("Phaddd_xmm_xmmm128", Code.PHADDD_XMM_XMMM128); + map.put("VEX_Vphaddd_xmm_xmm_xmmm128", Code.VEX_VPHADDD_XMM_XMM_XMMM128); + map.put("VEX_Vphaddd_ymm_ymm_ymmm256", Code.VEX_VPHADDD_YMM_YMM_YMMM256); + map.put("Phaddsw_mm_mmm64", Code.PHADDSW_MM_MMM64); + map.put("Phaddsw_xmm_xmmm128", Code.PHADDSW_XMM_XMMM128); + map.put("VEX_Vphaddsw_xmm_xmm_xmmm128", Code.VEX_VPHADDSW_XMM_XMM_XMMM128); + map.put("VEX_Vphaddsw_ymm_ymm_ymmm256", Code.VEX_VPHADDSW_YMM_YMM_YMMM256); + map.put("Pmaddubsw_mm_mmm64", Code.PMADDUBSW_MM_MMM64); + map.put("Pmaddubsw_xmm_xmmm128", Code.PMADDUBSW_XMM_XMMM128); + map.put("VEX_Vpmaddubsw_xmm_xmm_xmmm128", Code.VEX_VPMADDUBSW_XMM_XMM_XMMM128); + map.put("VEX_Vpmaddubsw_ymm_ymm_ymmm256", Code.VEX_VPMADDUBSW_YMM_YMM_YMMM256); + map.put("EVEX_Vpmaddubsw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMADDUBSW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpmaddubsw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMADDUBSW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpmaddubsw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMADDUBSW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Phsubw_mm_mmm64", Code.PHSUBW_MM_MMM64); + map.put("Phsubw_xmm_xmmm128", Code.PHSUBW_XMM_XMMM128); + map.put("VEX_Vphsubw_xmm_xmm_xmmm128", Code.VEX_VPHSUBW_XMM_XMM_XMMM128); + map.put("VEX_Vphsubw_ymm_ymm_ymmm256", Code.VEX_VPHSUBW_YMM_YMM_YMMM256); + map.put("Phsubd_mm_mmm64", Code.PHSUBD_MM_MMM64); + map.put("Phsubd_xmm_xmmm128", Code.PHSUBD_XMM_XMMM128); + map.put("VEX_Vphsubd_xmm_xmm_xmmm128", Code.VEX_VPHSUBD_XMM_XMM_XMMM128); + map.put("VEX_Vphsubd_ymm_ymm_ymmm256", Code.VEX_VPHSUBD_YMM_YMM_YMMM256); + map.put("Phsubsw_mm_mmm64", Code.PHSUBSW_MM_MMM64); + map.put("Phsubsw_xmm_xmmm128", Code.PHSUBSW_XMM_XMMM128); + map.put("VEX_Vphsubsw_xmm_xmm_xmmm128", Code.VEX_VPHSUBSW_XMM_XMM_XMMM128); + map.put("VEX_Vphsubsw_ymm_ymm_ymmm256", Code.VEX_VPHSUBSW_YMM_YMM_YMMM256); + map.put("Psignb_mm_mmm64", Code.PSIGNB_MM_MMM64); + map.put("Psignb_xmm_xmmm128", Code.PSIGNB_XMM_XMMM128); + map.put("VEX_Vpsignb_xmm_xmm_xmmm128", Code.VEX_VPSIGNB_XMM_XMM_XMMM128); + map.put("VEX_Vpsignb_ymm_ymm_ymmm256", Code.VEX_VPSIGNB_YMM_YMM_YMMM256); + map.put("Psignw_mm_mmm64", Code.PSIGNW_MM_MMM64); + map.put("Psignw_xmm_xmmm128", Code.PSIGNW_XMM_XMMM128); + map.put("VEX_Vpsignw_xmm_xmm_xmmm128", Code.VEX_VPSIGNW_XMM_XMM_XMMM128); + map.put("VEX_Vpsignw_ymm_ymm_ymmm256", Code.VEX_VPSIGNW_YMM_YMM_YMMM256); + map.put("Psignd_mm_mmm64", Code.PSIGND_MM_MMM64); + map.put("Psignd_xmm_xmmm128", Code.PSIGND_XMM_XMMM128); + map.put("VEX_Vpsignd_xmm_xmm_xmmm128", Code.VEX_VPSIGND_XMM_XMM_XMMM128); + map.put("VEX_Vpsignd_ymm_ymm_ymmm256", Code.VEX_VPSIGND_YMM_YMM_YMMM256); + map.put("Pmulhrsw_mm_mmm64", Code.PMULHRSW_MM_MMM64); + map.put("Pmulhrsw_xmm_xmmm128", Code.PMULHRSW_XMM_XMMM128); + map.put("VEX_Vpmulhrsw_xmm_xmm_xmmm128", Code.VEX_VPMULHRSW_XMM_XMM_XMMM128); + map.put("VEX_Vpmulhrsw_ymm_ymm_ymmm256", Code.VEX_VPMULHRSW_YMM_YMM_YMMM256); + map.put("EVEX_Vpmulhrsw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMULHRSW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpmulhrsw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMULHRSW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpmulhrsw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMULHRSW_ZMM_K1Z_ZMM_ZMMM512); + map.put("VEX_Vpermilps_xmm_xmm_xmmm128", Code.VEX_VPERMILPS_XMM_XMM_XMMM128); + map.put("VEX_Vpermilps_ymm_ymm_ymmm256", Code.VEX_VPERMILPS_YMM_YMM_YMMM256); + map.put("EVEX_Vpermilps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPERMILPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpermilps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPERMILPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpermilps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPERMILPS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("VEX_Vpermilpd_xmm_xmm_xmmm128", Code.VEX_VPERMILPD_XMM_XMM_XMMM128); + map.put("VEX_Vpermilpd_ymm_ymm_ymmm256", Code.VEX_VPERMILPD_YMM_YMM_YMMM256); + map.put("EVEX_Vpermilpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPERMILPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpermilpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPERMILPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpermilpd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPERMILPD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("VEX_Vtestps_xmm_xmmm128", Code.VEX_VTESTPS_XMM_XMMM128); + map.put("VEX_Vtestps_ymm_ymmm256", Code.VEX_VTESTPS_YMM_YMMM256); + map.put("VEX_Vtestpd_xmm_xmmm128", Code.VEX_VTESTPD_XMM_XMMM128); + map.put("VEX_Vtestpd_ymm_ymmm256", Code.VEX_VTESTPD_YMM_YMMM256); + map.put("Pblendvb_xmm_xmmm128", Code.PBLENDVB_XMM_XMMM128); + map.put("EVEX_Vpsrlvw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSRLVW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsrlvw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSRLVW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpsrlvw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSRLVW_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpmovuswb_xmmm64_k1z_xmm", Code.EVEX_VPMOVUSWB_XMMM64_K1Z_XMM); + map.put("EVEX_Vpmovuswb_xmmm128_k1z_ymm", Code.EVEX_VPMOVUSWB_XMMM128_K1Z_YMM); + map.put("EVEX_Vpmovuswb_ymmm256_k1z_zmm", Code.EVEX_VPMOVUSWB_YMMM256_K1Z_ZMM); + map.put("EVEX_Vpsravw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSRAVW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsravw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSRAVW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpsravw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSRAVW_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpmovusdb_xmmm32_k1z_xmm", Code.EVEX_VPMOVUSDB_XMMM32_K1Z_XMM); + map.put("EVEX_Vpmovusdb_xmmm64_k1z_ymm", Code.EVEX_VPMOVUSDB_XMMM64_K1Z_YMM); + map.put("EVEX_Vpmovusdb_xmmm128_k1z_zmm", Code.EVEX_VPMOVUSDB_XMMM128_K1Z_ZMM); + map.put("EVEX_Vpsllvw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSLLVW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpsllvw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSLLVW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpsllvw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSLLVW_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpmovusqb_xmmm16_k1z_xmm", Code.EVEX_VPMOVUSQB_XMMM16_K1Z_XMM); + map.put("EVEX_Vpmovusqb_xmmm32_k1z_ymm", Code.EVEX_VPMOVUSQB_XMMM32_K1Z_YMM); + map.put("EVEX_Vpmovusqb_xmmm64_k1z_zmm", Code.EVEX_VPMOVUSQB_XMMM64_K1Z_ZMM); + map.put("VEX_Vcvtph2ps_xmm_xmmm64", Code.VEX_VCVTPH2PS_XMM_XMMM64); + map.put("VEX_Vcvtph2ps_ymm_xmmm128", Code.VEX_VCVTPH2PS_YMM_XMMM128); + map.put("EVEX_Vcvtph2ps_xmm_k1z_xmmm64", Code.EVEX_VCVTPH2PS_XMM_K1Z_XMMM64); + map.put("EVEX_Vcvtph2ps_ymm_k1z_xmmm128", Code.EVEX_VCVTPH2PS_YMM_K1Z_XMMM128); + map.put("EVEX_Vcvtph2ps_zmm_k1z_ymmm256_sae", Code.EVEX_VCVTPH2PS_ZMM_K1Z_YMMM256_SAE); + map.put("EVEX_Vpmovusdw_xmmm64_k1z_xmm", Code.EVEX_VPMOVUSDW_XMMM64_K1Z_XMM); + map.put("EVEX_Vpmovusdw_xmmm128_k1z_ymm", Code.EVEX_VPMOVUSDW_XMMM128_K1Z_YMM); + map.put("EVEX_Vpmovusdw_ymmm256_k1z_zmm", Code.EVEX_VPMOVUSDW_YMMM256_K1Z_ZMM); + map.put("Blendvps_xmm_xmmm128", Code.BLENDVPS_XMM_XMMM128); + map.put("EVEX_Vprorvd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPRORVD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vprorvd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPRORVD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vprorvd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPRORVD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vprorvq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPRORVQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vprorvq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPRORVQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vprorvq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPRORVQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vpmovusqw_xmmm32_k1z_xmm", Code.EVEX_VPMOVUSQW_XMMM32_K1Z_XMM); + map.put("EVEX_Vpmovusqw_xmmm64_k1z_ymm", Code.EVEX_VPMOVUSQW_XMMM64_K1Z_YMM); + map.put("EVEX_Vpmovusqw_xmmm128_k1z_zmm", Code.EVEX_VPMOVUSQW_XMMM128_K1Z_ZMM); + map.put("Blendvpd_xmm_xmmm128", Code.BLENDVPD_XMM_XMMM128); + map.put("EVEX_Vprolvd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPROLVD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vprolvd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPROLVD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vprolvd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPROLVD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vprolvq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPROLVQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vprolvq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPROLVQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vprolvq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPROLVQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vpmovusqd_xmmm64_k1z_xmm", Code.EVEX_VPMOVUSQD_XMMM64_K1Z_XMM); + map.put("EVEX_Vpmovusqd_xmmm128_k1z_ymm", Code.EVEX_VPMOVUSQD_XMMM128_K1Z_YMM); + map.put("EVEX_Vpmovusqd_ymmm256_k1z_zmm", Code.EVEX_VPMOVUSQD_YMMM256_K1Z_ZMM); + map.put("VEX_Vpermps_ymm_ymm_ymmm256", Code.VEX_VPERMPS_YMM_YMM_YMMM256); + map.put("EVEX_Vpermps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPERMPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpermps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPERMPS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpermpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPERMPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpermpd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPERMPD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Ptest_xmm_xmmm128", Code.PTEST_XMM_XMMM128); + map.put("VEX_Vptest_xmm_xmmm128", Code.VEX_VPTEST_XMM_XMMM128); + map.put("VEX_Vptest_ymm_ymmm256", Code.VEX_VPTEST_YMM_YMMM256); + map.put("VEX_Vbroadcastss_xmm_m32", Code.VEX_VBROADCASTSS_XMM_M32); + map.put("VEX_Vbroadcastss_ymm_m32", Code.VEX_VBROADCASTSS_YMM_M32); + map.put("EVEX_Vbroadcastss_xmm_k1z_xmmm32", Code.EVEX_VBROADCASTSS_XMM_K1Z_XMMM32); + map.put("EVEX_Vbroadcastss_ymm_k1z_xmmm32", Code.EVEX_VBROADCASTSS_YMM_K1Z_XMMM32); + map.put("EVEX_Vbroadcastss_zmm_k1z_xmmm32", Code.EVEX_VBROADCASTSS_ZMM_K1Z_XMMM32); + map.put("VEX_Vbroadcastsd_ymm_m64", Code.VEX_VBROADCASTSD_YMM_M64); + map.put("EVEX_Vbroadcastf32x2_ymm_k1z_xmmm64", Code.EVEX_VBROADCASTF32X2_YMM_K1Z_XMMM64); + map.put("EVEX_Vbroadcastf32x2_zmm_k1z_xmmm64", Code.EVEX_VBROADCASTF32X2_ZMM_K1Z_XMMM64); + map.put("EVEX_Vbroadcastsd_ymm_k1z_xmmm64", Code.EVEX_VBROADCASTSD_YMM_K1Z_XMMM64); + map.put("EVEX_Vbroadcastsd_zmm_k1z_xmmm64", Code.EVEX_VBROADCASTSD_ZMM_K1Z_XMMM64); + map.put("VEX_Vbroadcastf128_ymm_m128", Code.VEX_VBROADCASTF128_YMM_M128); + map.put("EVEX_Vbroadcastf32x4_ymm_k1z_m128", Code.EVEX_VBROADCASTF32X4_YMM_K1Z_M128); + map.put("EVEX_Vbroadcastf32x4_zmm_k1z_m128", Code.EVEX_VBROADCASTF32X4_ZMM_K1Z_M128); + map.put("EVEX_Vbroadcastf64x2_ymm_k1z_m128", Code.EVEX_VBROADCASTF64X2_YMM_K1Z_M128); + map.put("EVEX_Vbroadcastf64x2_zmm_k1z_m128", Code.EVEX_VBROADCASTF64X2_ZMM_K1Z_M128); + map.put("EVEX_Vbroadcastf32x8_zmm_k1z_m256", Code.EVEX_VBROADCASTF32X8_ZMM_K1Z_M256); + map.put("EVEX_Vbroadcastf64x4_zmm_k1z_m256", Code.EVEX_VBROADCASTF64X4_ZMM_K1Z_M256); + map.put("Pabsb_mm_mmm64", Code.PABSB_MM_MMM64); + map.put("Pabsb_xmm_xmmm128", Code.PABSB_XMM_XMMM128); + map.put("VEX_Vpabsb_xmm_xmmm128", Code.VEX_VPABSB_XMM_XMMM128); + map.put("VEX_Vpabsb_ymm_ymmm256", Code.VEX_VPABSB_YMM_YMMM256); + map.put("EVEX_Vpabsb_xmm_k1z_xmmm128", Code.EVEX_VPABSB_XMM_K1Z_XMMM128); + map.put("EVEX_Vpabsb_ymm_k1z_ymmm256", Code.EVEX_VPABSB_YMM_K1Z_YMMM256); + map.put("EVEX_Vpabsb_zmm_k1z_zmmm512", Code.EVEX_VPABSB_ZMM_K1Z_ZMMM512); + map.put("Pabsw_mm_mmm64", Code.PABSW_MM_MMM64); + map.put("Pabsw_xmm_xmmm128", Code.PABSW_XMM_XMMM128); + map.put("VEX_Vpabsw_xmm_xmmm128", Code.VEX_VPABSW_XMM_XMMM128); + map.put("VEX_Vpabsw_ymm_ymmm256", Code.VEX_VPABSW_YMM_YMMM256); + map.put("EVEX_Vpabsw_xmm_k1z_xmmm128", Code.EVEX_VPABSW_XMM_K1Z_XMMM128); + map.put("EVEX_Vpabsw_ymm_k1z_ymmm256", Code.EVEX_VPABSW_YMM_K1Z_YMMM256); + map.put("EVEX_Vpabsw_zmm_k1z_zmmm512", Code.EVEX_VPABSW_ZMM_K1Z_ZMMM512); + map.put("Pabsd_mm_mmm64", Code.PABSD_MM_MMM64); + map.put("Pabsd_xmm_xmmm128", Code.PABSD_XMM_XMMM128); + map.put("VEX_Vpabsd_xmm_xmmm128", Code.VEX_VPABSD_XMM_XMMM128); + map.put("VEX_Vpabsd_ymm_ymmm256", Code.VEX_VPABSD_YMM_YMMM256); + map.put("EVEX_Vpabsd_xmm_k1z_xmmm128b32", Code.EVEX_VPABSD_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vpabsd_ymm_k1z_ymmm256b32", Code.EVEX_VPABSD_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vpabsd_zmm_k1z_zmmm512b32", Code.EVEX_VPABSD_ZMM_K1Z_ZMMM512B32); + map.put("EVEX_Vpabsq_xmm_k1z_xmmm128b64", Code.EVEX_VPABSQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vpabsq_ymm_k1z_ymmm256b64", Code.EVEX_VPABSQ_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vpabsq_zmm_k1z_zmmm512b64", Code.EVEX_VPABSQ_ZMM_K1Z_ZMMM512B64); + map.put("Pmovsxbw_xmm_xmmm64", Code.PMOVSXBW_XMM_XMMM64); + map.put("VEX_Vpmovsxbw_xmm_xmmm64", Code.VEX_VPMOVSXBW_XMM_XMMM64); + map.put("VEX_Vpmovsxbw_ymm_xmmm128", Code.VEX_VPMOVSXBW_YMM_XMMM128); + map.put("EVEX_Vpmovsxbw_xmm_k1z_xmmm64", Code.EVEX_VPMOVSXBW_XMM_K1Z_XMMM64); + map.put("EVEX_Vpmovsxbw_ymm_k1z_xmmm128", Code.EVEX_VPMOVSXBW_YMM_K1Z_XMMM128); + map.put("EVEX_Vpmovsxbw_zmm_k1z_ymmm256", Code.EVEX_VPMOVSXBW_ZMM_K1Z_YMMM256); + map.put("EVEX_Vpmovswb_xmmm64_k1z_xmm", Code.EVEX_VPMOVSWB_XMMM64_K1Z_XMM); + map.put("EVEX_Vpmovswb_xmmm128_k1z_ymm", Code.EVEX_VPMOVSWB_XMMM128_K1Z_YMM); + map.put("EVEX_Vpmovswb_ymmm256_k1z_zmm", Code.EVEX_VPMOVSWB_YMMM256_K1Z_ZMM); + map.put("Pmovsxbd_xmm_xmmm32", Code.PMOVSXBD_XMM_XMMM32); + map.put("VEX_Vpmovsxbd_xmm_xmmm32", Code.VEX_VPMOVSXBD_XMM_XMMM32); + map.put("VEX_Vpmovsxbd_ymm_xmmm64", Code.VEX_VPMOVSXBD_YMM_XMMM64); + map.put("EVEX_Vpmovsxbd_xmm_k1z_xmmm32", Code.EVEX_VPMOVSXBD_XMM_K1Z_XMMM32); + map.put("EVEX_Vpmovsxbd_ymm_k1z_xmmm64", Code.EVEX_VPMOVSXBD_YMM_K1Z_XMMM64); + map.put("EVEX_Vpmovsxbd_zmm_k1z_xmmm128", Code.EVEX_VPMOVSXBD_ZMM_K1Z_XMMM128); + map.put("EVEX_Vpmovsdb_xmmm32_k1z_xmm", Code.EVEX_VPMOVSDB_XMMM32_K1Z_XMM); + map.put("EVEX_Vpmovsdb_xmmm64_k1z_ymm", Code.EVEX_VPMOVSDB_XMMM64_K1Z_YMM); + map.put("EVEX_Vpmovsdb_xmmm128_k1z_zmm", Code.EVEX_VPMOVSDB_XMMM128_K1Z_ZMM); + map.put("Pmovsxbq_xmm_xmmm16", Code.PMOVSXBQ_XMM_XMMM16); + map.put("VEX_Vpmovsxbq_xmm_xmmm16", Code.VEX_VPMOVSXBQ_XMM_XMMM16); + map.put("VEX_Vpmovsxbq_ymm_xmmm32", Code.VEX_VPMOVSXBQ_YMM_XMMM32); + map.put("EVEX_Vpmovsxbq_xmm_k1z_xmmm16", Code.EVEX_VPMOVSXBQ_XMM_K1Z_XMMM16); + map.put("EVEX_Vpmovsxbq_ymm_k1z_xmmm32", Code.EVEX_VPMOVSXBQ_YMM_K1Z_XMMM32); + map.put("EVEX_Vpmovsxbq_zmm_k1z_xmmm64", Code.EVEX_VPMOVSXBQ_ZMM_K1Z_XMMM64); + map.put("EVEX_Vpmovsqb_xmmm16_k1z_xmm", Code.EVEX_VPMOVSQB_XMMM16_K1Z_XMM); + map.put("EVEX_Vpmovsqb_xmmm32_k1z_ymm", Code.EVEX_VPMOVSQB_XMMM32_K1Z_YMM); + map.put("EVEX_Vpmovsqb_xmmm64_k1z_zmm", Code.EVEX_VPMOVSQB_XMMM64_K1Z_ZMM); + map.put("Pmovsxwd_xmm_xmmm64", Code.PMOVSXWD_XMM_XMMM64); + map.put("VEX_Vpmovsxwd_xmm_xmmm64", Code.VEX_VPMOVSXWD_XMM_XMMM64); + map.put("VEX_Vpmovsxwd_ymm_xmmm128", Code.VEX_VPMOVSXWD_YMM_XMMM128); + map.put("EVEX_Vpmovsxwd_xmm_k1z_xmmm64", Code.EVEX_VPMOVSXWD_XMM_K1Z_XMMM64); + map.put("EVEX_Vpmovsxwd_ymm_k1z_xmmm128", Code.EVEX_VPMOVSXWD_YMM_K1Z_XMMM128); + map.put("EVEX_Vpmovsxwd_zmm_k1z_ymmm256", Code.EVEX_VPMOVSXWD_ZMM_K1Z_YMMM256); + map.put("EVEX_Vpmovsdw_xmmm64_k1z_xmm", Code.EVEX_VPMOVSDW_XMMM64_K1Z_XMM); + map.put("EVEX_Vpmovsdw_xmmm128_k1z_ymm", Code.EVEX_VPMOVSDW_XMMM128_K1Z_YMM); + map.put("EVEX_Vpmovsdw_ymmm256_k1z_zmm", Code.EVEX_VPMOVSDW_YMMM256_K1Z_ZMM); + map.put("Pmovsxwq_xmm_xmmm32", Code.PMOVSXWQ_XMM_XMMM32); + map.put("VEX_Vpmovsxwq_xmm_xmmm32", Code.VEX_VPMOVSXWQ_XMM_XMMM32); + map.put("VEX_Vpmovsxwq_ymm_xmmm64", Code.VEX_VPMOVSXWQ_YMM_XMMM64); + map.put("EVEX_Vpmovsxwq_xmm_k1z_xmmm32", Code.EVEX_VPMOVSXWQ_XMM_K1Z_XMMM32); + map.put("EVEX_Vpmovsxwq_ymm_k1z_xmmm64", Code.EVEX_VPMOVSXWQ_YMM_K1Z_XMMM64); + map.put("EVEX_Vpmovsxwq_zmm_k1z_xmmm128", Code.EVEX_VPMOVSXWQ_ZMM_K1Z_XMMM128); + map.put("EVEX_Vpmovsqw_xmmm32_k1z_xmm", Code.EVEX_VPMOVSQW_XMMM32_K1Z_XMM); + map.put("EVEX_Vpmovsqw_xmmm64_k1z_ymm", Code.EVEX_VPMOVSQW_XMMM64_K1Z_YMM); + map.put("EVEX_Vpmovsqw_xmmm128_k1z_zmm", Code.EVEX_VPMOVSQW_XMMM128_K1Z_ZMM); + map.put("Pmovsxdq_xmm_xmmm64", Code.PMOVSXDQ_XMM_XMMM64); + map.put("VEX_Vpmovsxdq_xmm_xmmm64", Code.VEX_VPMOVSXDQ_XMM_XMMM64); + map.put("VEX_Vpmovsxdq_ymm_xmmm128", Code.VEX_VPMOVSXDQ_YMM_XMMM128); + map.put("EVEX_Vpmovsxdq_xmm_k1z_xmmm64", Code.EVEX_VPMOVSXDQ_XMM_K1Z_XMMM64); + map.put("EVEX_Vpmovsxdq_ymm_k1z_xmmm128", Code.EVEX_VPMOVSXDQ_YMM_K1Z_XMMM128); + map.put("EVEX_Vpmovsxdq_zmm_k1z_ymmm256", Code.EVEX_VPMOVSXDQ_ZMM_K1Z_YMMM256); + map.put("EVEX_Vpmovsqd_xmmm64_k1z_xmm", Code.EVEX_VPMOVSQD_XMMM64_K1Z_XMM); + map.put("EVEX_Vpmovsqd_xmmm128_k1z_ymm", Code.EVEX_VPMOVSQD_XMMM128_K1Z_YMM); + map.put("EVEX_Vpmovsqd_ymmm256_k1z_zmm", Code.EVEX_VPMOVSQD_YMMM256_K1Z_ZMM); + map.put("EVEX_Vptestmb_kr_k1_xmm_xmmm128", Code.EVEX_VPTESTMB_KR_K1_XMM_XMMM128); + map.put("EVEX_Vptestmb_kr_k1_ymm_ymmm256", Code.EVEX_VPTESTMB_KR_K1_YMM_YMMM256); + map.put("EVEX_Vptestmb_kr_k1_zmm_zmmm512", Code.EVEX_VPTESTMB_KR_K1_ZMM_ZMMM512); + map.put("EVEX_Vptestmw_kr_k1_xmm_xmmm128", Code.EVEX_VPTESTMW_KR_K1_XMM_XMMM128); + map.put("EVEX_Vptestmw_kr_k1_ymm_ymmm256", Code.EVEX_VPTESTMW_KR_K1_YMM_YMMM256); + map.put("EVEX_Vptestmw_kr_k1_zmm_zmmm512", Code.EVEX_VPTESTMW_KR_K1_ZMM_ZMMM512); + map.put("EVEX_Vptestnmb_kr_k1_xmm_xmmm128", Code.EVEX_VPTESTNMB_KR_K1_XMM_XMMM128); + map.put("EVEX_Vptestnmb_kr_k1_ymm_ymmm256", Code.EVEX_VPTESTNMB_KR_K1_YMM_YMMM256); + map.put("EVEX_Vptestnmb_kr_k1_zmm_zmmm512", Code.EVEX_VPTESTNMB_KR_K1_ZMM_ZMMM512); + map.put("EVEX_Vptestnmw_kr_k1_xmm_xmmm128", Code.EVEX_VPTESTNMW_KR_K1_XMM_XMMM128); + map.put("EVEX_Vptestnmw_kr_k1_ymm_ymmm256", Code.EVEX_VPTESTNMW_KR_K1_YMM_YMMM256); + map.put("EVEX_Vptestnmw_kr_k1_zmm_zmmm512", Code.EVEX_VPTESTNMW_KR_K1_ZMM_ZMMM512); + map.put("EVEX_Vptestmd_kr_k1_xmm_xmmm128b32", Code.EVEX_VPTESTMD_KR_K1_XMM_XMMM128B32); + map.put("EVEX_Vptestmd_kr_k1_ymm_ymmm256b32", Code.EVEX_VPTESTMD_KR_K1_YMM_YMMM256B32); + map.put("EVEX_Vptestmd_kr_k1_zmm_zmmm512b32", Code.EVEX_VPTESTMD_KR_K1_ZMM_ZMMM512B32); + map.put("EVEX_Vptestmq_kr_k1_xmm_xmmm128b64", Code.EVEX_VPTESTMQ_KR_K1_XMM_XMMM128B64); + map.put("EVEX_Vptestmq_kr_k1_ymm_ymmm256b64", Code.EVEX_VPTESTMQ_KR_K1_YMM_YMMM256B64); + map.put("EVEX_Vptestmq_kr_k1_zmm_zmmm512b64", Code.EVEX_VPTESTMQ_KR_K1_ZMM_ZMMM512B64); + map.put("EVEX_Vptestnmd_kr_k1_xmm_xmmm128b32", Code.EVEX_VPTESTNMD_KR_K1_XMM_XMMM128B32); + map.put("EVEX_Vptestnmd_kr_k1_ymm_ymmm256b32", Code.EVEX_VPTESTNMD_KR_K1_YMM_YMMM256B32); + map.put("EVEX_Vptestnmd_kr_k1_zmm_zmmm512b32", Code.EVEX_VPTESTNMD_KR_K1_ZMM_ZMMM512B32); + map.put("EVEX_Vptestnmq_kr_k1_xmm_xmmm128b64", Code.EVEX_VPTESTNMQ_KR_K1_XMM_XMMM128B64); + map.put("EVEX_Vptestnmq_kr_k1_ymm_ymmm256b64", Code.EVEX_VPTESTNMQ_KR_K1_YMM_YMMM256B64); + map.put("EVEX_Vptestnmq_kr_k1_zmm_zmmm512b64", Code.EVEX_VPTESTNMQ_KR_K1_ZMM_ZMMM512B64); + map.put("Pmuldq_xmm_xmmm128", Code.PMULDQ_XMM_XMMM128); + map.put("VEX_Vpmuldq_xmm_xmm_xmmm128", Code.VEX_VPMULDQ_XMM_XMM_XMMM128); + map.put("VEX_Vpmuldq_ymm_ymm_ymmm256", Code.VEX_VPMULDQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpmuldq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPMULDQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpmuldq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPMULDQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpmuldq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPMULDQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vpmovm2b_xmm_kr", Code.EVEX_VPMOVM2B_XMM_KR); + map.put("EVEX_Vpmovm2b_ymm_kr", Code.EVEX_VPMOVM2B_YMM_KR); + map.put("EVEX_Vpmovm2b_zmm_kr", Code.EVEX_VPMOVM2B_ZMM_KR); + map.put("EVEX_Vpmovm2w_xmm_kr", Code.EVEX_VPMOVM2W_XMM_KR); + map.put("EVEX_Vpmovm2w_ymm_kr", Code.EVEX_VPMOVM2W_YMM_KR); + map.put("EVEX_Vpmovm2w_zmm_kr", Code.EVEX_VPMOVM2W_ZMM_KR); + map.put("Pcmpeqq_xmm_xmmm128", Code.PCMPEQQ_XMM_XMMM128); + map.put("VEX_Vpcmpeqq_xmm_xmm_xmmm128", Code.VEX_VPCMPEQQ_XMM_XMM_XMMM128); + map.put("VEX_Vpcmpeqq_ymm_ymm_ymmm256", Code.VEX_VPCMPEQQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpcmpeqq_kr_k1_xmm_xmmm128b64", Code.EVEX_VPCMPEQQ_KR_K1_XMM_XMMM128B64); + map.put("EVEX_Vpcmpeqq_kr_k1_ymm_ymmm256b64", Code.EVEX_VPCMPEQQ_KR_K1_YMM_YMMM256B64); + map.put("EVEX_Vpcmpeqq_kr_k1_zmm_zmmm512b64", Code.EVEX_VPCMPEQQ_KR_K1_ZMM_ZMMM512B64); + map.put("EVEX_Vpmovb2m_kr_xmm", Code.EVEX_VPMOVB2M_KR_XMM); + map.put("EVEX_Vpmovb2m_kr_ymm", Code.EVEX_VPMOVB2M_KR_YMM); + map.put("EVEX_Vpmovb2m_kr_zmm", Code.EVEX_VPMOVB2M_KR_ZMM); + map.put("EVEX_Vpmovw2m_kr_xmm", Code.EVEX_VPMOVW2M_KR_XMM); + map.put("EVEX_Vpmovw2m_kr_ymm", Code.EVEX_VPMOVW2M_KR_YMM); + map.put("EVEX_Vpmovw2m_kr_zmm", Code.EVEX_VPMOVW2M_KR_ZMM); + map.put("Movntdqa_xmm_m128", Code.MOVNTDQA_XMM_M128); + map.put("VEX_Vmovntdqa_xmm_m128", Code.VEX_VMOVNTDQA_XMM_M128); + map.put("VEX_Vmovntdqa_ymm_m256", Code.VEX_VMOVNTDQA_YMM_M256); + map.put("EVEX_Vmovntdqa_xmm_m128", Code.EVEX_VMOVNTDQA_XMM_M128); + map.put("EVEX_Vmovntdqa_ymm_m256", Code.EVEX_VMOVNTDQA_YMM_M256); + map.put("EVEX_Vmovntdqa_zmm_m512", Code.EVEX_VMOVNTDQA_ZMM_M512); + map.put("EVEX_Vpbroadcastmb2q_xmm_kr", Code.EVEX_VPBROADCASTMB2Q_XMM_KR); + map.put("EVEX_Vpbroadcastmb2q_ymm_kr", Code.EVEX_VPBROADCASTMB2Q_YMM_KR); + map.put("EVEX_Vpbroadcastmb2q_zmm_kr", Code.EVEX_VPBROADCASTMB2Q_ZMM_KR); + map.put("Packusdw_xmm_xmmm128", Code.PACKUSDW_XMM_XMMM128); + map.put("VEX_Vpackusdw_xmm_xmm_xmmm128", Code.VEX_VPACKUSDW_XMM_XMM_XMMM128); + map.put("VEX_Vpackusdw_ymm_ymm_ymmm256", Code.VEX_VPACKUSDW_YMM_YMM_YMMM256); + map.put("EVEX_Vpackusdw_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPACKUSDW_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpackusdw_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPACKUSDW_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpackusdw_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPACKUSDW_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("VEX_Vmaskmovps_xmm_xmm_m128", Code.VEX_VMASKMOVPS_XMM_XMM_M128); + map.put("VEX_Vmaskmovps_ymm_ymm_m256", Code.VEX_VMASKMOVPS_YMM_YMM_M256); + map.put("EVEX_Vscalefps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VSCALEFPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vscalefps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VSCALEFPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vscalefps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VSCALEFPS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vscalefpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VSCALEFPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vscalefpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VSCALEFPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vscalefpd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VSCALEFPD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vmaskmovpd_xmm_xmm_m128", Code.VEX_VMASKMOVPD_XMM_XMM_M128); + map.put("VEX_Vmaskmovpd_ymm_ymm_m256", Code.VEX_VMASKMOVPD_YMM_YMM_M256); + map.put("EVEX_Vscalefss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VSCALEFSS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vscalefsd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VSCALEFSD_XMM_K1Z_XMM_XMMM64_ER); + map.put("VEX_Vmaskmovps_m128_xmm_xmm", Code.VEX_VMASKMOVPS_M128_XMM_XMM); + map.put("VEX_Vmaskmovps_m256_ymm_ymm", Code.VEX_VMASKMOVPS_M256_YMM_YMM); + map.put("VEX_Vmaskmovpd_m128_xmm_xmm", Code.VEX_VMASKMOVPD_M128_XMM_XMM); + map.put("VEX_Vmaskmovpd_m256_ymm_ymm", Code.VEX_VMASKMOVPD_M256_YMM_YMM); + map.put("Pmovzxbw_xmm_xmmm64", Code.PMOVZXBW_XMM_XMMM64); + map.put("VEX_Vpmovzxbw_xmm_xmmm64", Code.VEX_VPMOVZXBW_XMM_XMMM64); + map.put("VEX_Vpmovzxbw_ymm_xmmm128", Code.VEX_VPMOVZXBW_YMM_XMMM128); + map.put("EVEX_Vpmovzxbw_xmm_k1z_xmmm64", Code.EVEX_VPMOVZXBW_XMM_K1Z_XMMM64); + map.put("EVEX_Vpmovzxbw_ymm_k1z_xmmm128", Code.EVEX_VPMOVZXBW_YMM_K1Z_XMMM128); + map.put("EVEX_Vpmovzxbw_zmm_k1z_ymmm256", Code.EVEX_VPMOVZXBW_ZMM_K1Z_YMMM256); + map.put("EVEX_Vpmovwb_xmmm64_k1z_xmm", Code.EVEX_VPMOVWB_XMMM64_K1Z_XMM); + map.put("EVEX_Vpmovwb_xmmm128_k1z_ymm", Code.EVEX_VPMOVWB_XMMM128_K1Z_YMM); + map.put("EVEX_Vpmovwb_ymmm256_k1z_zmm", Code.EVEX_VPMOVWB_YMMM256_K1Z_ZMM); + map.put("Pmovzxbd_xmm_xmmm32", Code.PMOVZXBD_XMM_XMMM32); + map.put("VEX_Vpmovzxbd_xmm_xmmm32", Code.VEX_VPMOVZXBD_XMM_XMMM32); + map.put("VEX_Vpmovzxbd_ymm_xmmm64", Code.VEX_VPMOVZXBD_YMM_XMMM64); + map.put("EVEX_Vpmovzxbd_xmm_k1z_xmmm32", Code.EVEX_VPMOVZXBD_XMM_K1Z_XMMM32); + map.put("EVEX_Vpmovzxbd_ymm_k1z_xmmm64", Code.EVEX_VPMOVZXBD_YMM_K1Z_XMMM64); + map.put("EVEX_Vpmovzxbd_zmm_k1z_xmmm128", Code.EVEX_VPMOVZXBD_ZMM_K1Z_XMMM128); + map.put("EVEX_Vpmovdb_xmmm32_k1z_xmm", Code.EVEX_VPMOVDB_XMMM32_K1Z_XMM); + map.put("EVEX_Vpmovdb_xmmm64_k1z_ymm", Code.EVEX_VPMOVDB_XMMM64_K1Z_YMM); + map.put("EVEX_Vpmovdb_xmmm128_k1z_zmm", Code.EVEX_VPMOVDB_XMMM128_K1Z_ZMM); + map.put("Pmovzxbq_xmm_xmmm16", Code.PMOVZXBQ_XMM_XMMM16); + map.put("VEX_Vpmovzxbq_xmm_xmmm16", Code.VEX_VPMOVZXBQ_XMM_XMMM16); + map.put("VEX_Vpmovzxbq_ymm_xmmm32", Code.VEX_VPMOVZXBQ_YMM_XMMM32); + map.put("EVEX_Vpmovzxbq_xmm_k1z_xmmm16", Code.EVEX_VPMOVZXBQ_XMM_K1Z_XMMM16); + map.put("EVEX_Vpmovzxbq_ymm_k1z_xmmm32", Code.EVEX_VPMOVZXBQ_YMM_K1Z_XMMM32); + map.put("EVEX_Vpmovzxbq_zmm_k1z_xmmm64", Code.EVEX_VPMOVZXBQ_ZMM_K1Z_XMMM64); + map.put("EVEX_Vpmovqb_xmmm16_k1z_xmm", Code.EVEX_VPMOVQB_XMMM16_K1Z_XMM); + map.put("EVEX_Vpmovqb_xmmm32_k1z_ymm", Code.EVEX_VPMOVQB_XMMM32_K1Z_YMM); + map.put("EVEX_Vpmovqb_xmmm64_k1z_zmm", Code.EVEX_VPMOVQB_XMMM64_K1Z_ZMM); + map.put("Pmovzxwd_xmm_xmmm64", Code.PMOVZXWD_XMM_XMMM64); + map.put("VEX_Vpmovzxwd_xmm_xmmm64", Code.VEX_VPMOVZXWD_XMM_XMMM64); + map.put("VEX_Vpmovzxwd_ymm_xmmm128", Code.VEX_VPMOVZXWD_YMM_XMMM128); + map.put("EVEX_Vpmovzxwd_xmm_k1z_xmmm64", Code.EVEX_VPMOVZXWD_XMM_K1Z_XMMM64); + map.put("EVEX_Vpmovzxwd_ymm_k1z_xmmm128", Code.EVEX_VPMOVZXWD_YMM_K1Z_XMMM128); + map.put("EVEX_Vpmovzxwd_zmm_k1z_ymmm256", Code.EVEX_VPMOVZXWD_ZMM_K1Z_YMMM256); + map.put("EVEX_Vpmovdw_xmmm64_k1z_xmm", Code.EVEX_VPMOVDW_XMMM64_K1Z_XMM); + map.put("EVEX_Vpmovdw_xmmm128_k1z_ymm", Code.EVEX_VPMOVDW_XMMM128_K1Z_YMM); + map.put("EVEX_Vpmovdw_ymmm256_k1z_zmm", Code.EVEX_VPMOVDW_YMMM256_K1Z_ZMM); + map.put("Pmovzxwq_xmm_xmmm32", Code.PMOVZXWQ_XMM_XMMM32); + map.put("VEX_Vpmovzxwq_xmm_xmmm32", Code.VEX_VPMOVZXWQ_XMM_XMMM32); + map.put("VEX_Vpmovzxwq_ymm_xmmm64", Code.VEX_VPMOVZXWQ_YMM_XMMM64); + map.put("EVEX_Vpmovzxwq_xmm_k1z_xmmm32", Code.EVEX_VPMOVZXWQ_XMM_K1Z_XMMM32); + map.put("EVEX_Vpmovzxwq_ymm_k1z_xmmm64", Code.EVEX_VPMOVZXWQ_YMM_K1Z_XMMM64); + map.put("EVEX_Vpmovzxwq_zmm_k1z_xmmm128", Code.EVEX_VPMOVZXWQ_ZMM_K1Z_XMMM128); + map.put("EVEX_Vpmovqw_xmmm32_k1z_xmm", Code.EVEX_VPMOVQW_XMMM32_K1Z_XMM); + map.put("EVEX_Vpmovqw_xmmm64_k1z_ymm", Code.EVEX_VPMOVQW_XMMM64_K1Z_YMM); + map.put("EVEX_Vpmovqw_xmmm128_k1z_zmm", Code.EVEX_VPMOVQW_XMMM128_K1Z_ZMM); + map.put("Pmovzxdq_xmm_xmmm64", Code.PMOVZXDQ_XMM_XMMM64); + map.put("VEX_Vpmovzxdq_xmm_xmmm64", Code.VEX_VPMOVZXDQ_XMM_XMMM64); + map.put("VEX_Vpmovzxdq_ymm_xmmm128", Code.VEX_VPMOVZXDQ_YMM_XMMM128); + map.put("EVEX_Vpmovzxdq_xmm_k1z_xmmm64", Code.EVEX_VPMOVZXDQ_XMM_K1Z_XMMM64); + map.put("EVEX_Vpmovzxdq_ymm_k1z_xmmm128", Code.EVEX_VPMOVZXDQ_YMM_K1Z_XMMM128); + map.put("EVEX_Vpmovzxdq_zmm_k1z_ymmm256", Code.EVEX_VPMOVZXDQ_ZMM_K1Z_YMMM256); + map.put("EVEX_Vpmovqd_xmmm64_k1z_xmm", Code.EVEX_VPMOVQD_XMMM64_K1Z_XMM); + map.put("EVEX_Vpmovqd_xmmm128_k1z_ymm", Code.EVEX_VPMOVQD_XMMM128_K1Z_YMM); + map.put("EVEX_Vpmovqd_ymmm256_k1z_zmm", Code.EVEX_VPMOVQD_YMMM256_K1Z_ZMM); + map.put("VEX_Vpermd_ymm_ymm_ymmm256", Code.VEX_VPERMD_YMM_YMM_YMMM256); + map.put("EVEX_Vpermd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPERMD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpermd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPERMD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpermq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPERMQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpermq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPERMQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Pcmpgtq_xmm_xmmm128", Code.PCMPGTQ_XMM_XMMM128); + map.put("VEX_Vpcmpgtq_xmm_xmm_xmmm128", Code.VEX_VPCMPGTQ_XMM_XMM_XMMM128); + map.put("VEX_Vpcmpgtq_ymm_ymm_ymmm256", Code.VEX_VPCMPGTQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpcmpgtq_kr_k1_xmm_xmmm128b64", Code.EVEX_VPCMPGTQ_KR_K1_XMM_XMMM128B64); + map.put("EVEX_Vpcmpgtq_kr_k1_ymm_ymmm256b64", Code.EVEX_VPCMPGTQ_KR_K1_YMM_YMMM256B64); + map.put("EVEX_Vpcmpgtq_kr_k1_zmm_zmmm512b64", Code.EVEX_VPCMPGTQ_KR_K1_ZMM_ZMMM512B64); + map.put("Pminsb_xmm_xmmm128", Code.PMINSB_XMM_XMMM128); + map.put("VEX_Vpminsb_xmm_xmm_xmmm128", Code.VEX_VPMINSB_XMM_XMM_XMMM128); + map.put("VEX_Vpminsb_ymm_ymm_ymmm256", Code.VEX_VPMINSB_YMM_YMM_YMMM256); + map.put("EVEX_Vpminsb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMINSB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpminsb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMINSB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpminsb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMINSB_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpmovm2d_xmm_kr", Code.EVEX_VPMOVM2D_XMM_KR); + map.put("EVEX_Vpmovm2d_ymm_kr", Code.EVEX_VPMOVM2D_YMM_KR); + map.put("EVEX_Vpmovm2d_zmm_kr", Code.EVEX_VPMOVM2D_ZMM_KR); + map.put("EVEX_Vpmovm2q_xmm_kr", Code.EVEX_VPMOVM2Q_XMM_KR); + map.put("EVEX_Vpmovm2q_ymm_kr", Code.EVEX_VPMOVM2Q_YMM_KR); + map.put("EVEX_Vpmovm2q_zmm_kr", Code.EVEX_VPMOVM2Q_ZMM_KR); + map.put("Pminsd_xmm_xmmm128", Code.PMINSD_XMM_XMMM128); + map.put("VEX_Vpminsd_xmm_xmm_xmmm128", Code.VEX_VPMINSD_XMM_XMM_XMMM128); + map.put("VEX_Vpminsd_ymm_ymm_ymmm256", Code.VEX_VPMINSD_YMM_YMM_YMMM256); + map.put("EVEX_Vpminsd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPMINSD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpminsd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPMINSD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpminsd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPMINSD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpminsq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPMINSQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpminsq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPMINSQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpminsq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPMINSQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vpmovd2m_kr_xmm", Code.EVEX_VPMOVD2M_KR_XMM); + map.put("EVEX_Vpmovd2m_kr_ymm", Code.EVEX_VPMOVD2M_KR_YMM); + map.put("EVEX_Vpmovd2m_kr_zmm", Code.EVEX_VPMOVD2M_KR_ZMM); + map.put("EVEX_Vpmovq2m_kr_xmm", Code.EVEX_VPMOVQ2M_KR_XMM); + map.put("EVEX_Vpmovq2m_kr_ymm", Code.EVEX_VPMOVQ2M_KR_YMM); + map.put("EVEX_Vpmovq2m_kr_zmm", Code.EVEX_VPMOVQ2M_KR_ZMM); + map.put("Pminuw_xmm_xmmm128", Code.PMINUW_XMM_XMMM128); + map.put("VEX_Vpminuw_xmm_xmm_xmmm128", Code.VEX_VPMINUW_XMM_XMM_XMMM128); + map.put("VEX_Vpminuw_ymm_ymm_ymmm256", Code.VEX_VPMINUW_YMM_YMM_YMMM256); + map.put("EVEX_Vpminuw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMINUW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpminuw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMINUW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpminuw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMINUW_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpbroadcastmw2d_xmm_kr", Code.EVEX_VPBROADCASTMW2D_XMM_KR); + map.put("EVEX_Vpbroadcastmw2d_ymm_kr", Code.EVEX_VPBROADCASTMW2D_YMM_KR); + map.put("EVEX_Vpbroadcastmw2d_zmm_kr", Code.EVEX_VPBROADCASTMW2D_ZMM_KR); + map.put("Pminud_xmm_xmmm128", Code.PMINUD_XMM_XMMM128); + map.put("VEX_Vpminud_xmm_xmm_xmmm128", Code.VEX_VPMINUD_XMM_XMM_XMMM128); + map.put("VEX_Vpminud_ymm_ymm_ymmm256", Code.VEX_VPMINUD_YMM_YMM_YMMM256); + map.put("EVEX_Vpminud_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPMINUD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpminud_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPMINUD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpminud_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPMINUD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpminuq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPMINUQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpminuq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPMINUQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpminuq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPMINUQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Pmaxsb_xmm_xmmm128", Code.PMAXSB_XMM_XMMM128); + map.put("VEX_Vpmaxsb_xmm_xmm_xmmm128", Code.VEX_VPMAXSB_XMM_XMM_XMMM128); + map.put("VEX_Vpmaxsb_ymm_ymm_ymmm256", Code.VEX_VPMAXSB_YMM_YMM_YMMM256); + map.put("EVEX_Vpmaxsb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMAXSB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpmaxsb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMAXSB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpmaxsb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMAXSB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pmaxsd_xmm_xmmm128", Code.PMAXSD_XMM_XMMM128); + map.put("VEX_Vpmaxsd_xmm_xmm_xmmm128", Code.VEX_VPMAXSD_XMM_XMM_XMMM128); + map.put("VEX_Vpmaxsd_ymm_ymm_ymmm256", Code.VEX_VPMAXSD_YMM_YMM_YMMM256); + map.put("EVEX_Vpmaxsd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPMAXSD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpmaxsd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPMAXSD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpmaxsd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPMAXSD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpmaxsq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPMAXSQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpmaxsq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPMAXSQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpmaxsq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPMAXSQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Pmaxuw_xmm_xmmm128", Code.PMAXUW_XMM_XMMM128); + map.put("VEX_Vpmaxuw_xmm_xmm_xmmm128", Code.VEX_VPMAXUW_XMM_XMM_XMMM128); + map.put("VEX_Vpmaxuw_ymm_ymm_ymmm256", Code.VEX_VPMAXUW_YMM_YMM_YMMM256); + map.put("EVEX_Vpmaxuw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPMAXUW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpmaxuw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPMAXUW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpmaxuw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPMAXUW_ZMM_K1Z_ZMM_ZMMM512); + map.put("Pmaxud_xmm_xmmm128", Code.PMAXUD_XMM_XMMM128); + map.put("VEX_Vpmaxud_xmm_xmm_xmmm128", Code.VEX_VPMAXUD_XMM_XMM_XMMM128); + map.put("VEX_Vpmaxud_ymm_ymm_ymmm256", Code.VEX_VPMAXUD_YMM_YMM_YMMM256); + map.put("EVEX_Vpmaxud_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPMAXUD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpmaxud_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPMAXUD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpmaxud_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPMAXUD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpmaxuq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPMAXUQ_XMM_K1Z_XMM_XMMM128B64); + } + + private static void initMap6(HashMap map) { + map.put("EVEX_Vpmaxuq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPMAXUQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpmaxuq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPMAXUQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Pmulld_xmm_xmmm128", Code.PMULLD_XMM_XMMM128); + map.put("VEX_Vpmulld_xmm_xmm_xmmm128", Code.VEX_VPMULLD_XMM_XMM_XMMM128); + map.put("VEX_Vpmulld_ymm_ymm_ymmm256", Code.VEX_VPMULLD_YMM_YMM_YMMM256); + map.put("EVEX_Vpmulld_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPMULLD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpmulld_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPMULLD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpmulld_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPMULLD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpmullq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPMULLQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpmullq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPMULLQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpmullq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPMULLQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Phminposuw_xmm_xmmm128", Code.PHMINPOSUW_XMM_XMMM128); + map.put("VEX_Vphminposuw_xmm_xmmm128", Code.VEX_VPHMINPOSUW_XMM_XMMM128); + map.put("EVEX_Vgetexpps_xmm_k1z_xmmm128b32", Code.EVEX_VGETEXPPS_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vgetexpps_ymm_k1z_ymmm256b32", Code.EVEX_VGETEXPPS_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vgetexpps_zmm_k1z_zmmm512b32_sae", Code.EVEX_VGETEXPPS_ZMM_K1Z_ZMMM512B32_SAE); + map.put("EVEX_Vgetexppd_xmm_k1z_xmmm128b64", Code.EVEX_VGETEXPPD_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vgetexppd_ymm_k1z_ymmm256b64", Code.EVEX_VGETEXPPD_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vgetexppd_zmm_k1z_zmmm512b64_sae", Code.EVEX_VGETEXPPD_ZMM_K1Z_ZMMM512B64_SAE); + map.put("EVEX_Vgetexpss_xmm_k1z_xmm_xmmm32_sae", Code.EVEX_VGETEXPSS_XMM_K1Z_XMM_XMMM32_SAE); + map.put("EVEX_Vgetexpsd_xmm_k1z_xmm_xmmm64_sae", Code.EVEX_VGETEXPSD_XMM_K1Z_XMM_XMMM64_SAE); + map.put("EVEX_Vplzcntd_xmm_k1z_xmmm128b32", Code.EVEX_VPLZCNTD_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vplzcntd_ymm_k1z_ymmm256b32", Code.EVEX_VPLZCNTD_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vplzcntd_zmm_k1z_zmmm512b32", Code.EVEX_VPLZCNTD_ZMM_K1Z_ZMMM512B32); + map.put("EVEX_Vplzcntq_xmm_k1z_xmmm128b64", Code.EVEX_VPLZCNTQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vplzcntq_ymm_k1z_ymmm256b64", Code.EVEX_VPLZCNTQ_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vplzcntq_zmm_k1z_zmmm512b64", Code.EVEX_VPLZCNTQ_ZMM_K1Z_ZMMM512B64); + map.put("VEX_Vpsrlvd_xmm_xmm_xmmm128", Code.VEX_VPSRLVD_XMM_XMM_XMMM128); + map.put("VEX_Vpsrlvd_ymm_ymm_ymmm256", Code.VEX_VPSRLVD_YMM_YMM_YMMM256); + map.put("VEX_Vpsrlvq_xmm_xmm_xmmm128", Code.VEX_VPSRLVQ_XMM_XMM_XMMM128); + map.put("VEX_Vpsrlvq_ymm_ymm_ymmm256", Code.VEX_VPSRLVQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpsrlvd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPSRLVD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpsrlvd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPSRLVD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpsrlvd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPSRLVD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpsrlvq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPSRLVQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpsrlvq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPSRLVQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpsrlvq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPSRLVQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("VEX_Vpsravd_xmm_xmm_xmmm128", Code.VEX_VPSRAVD_XMM_XMM_XMMM128); + map.put("VEX_Vpsravd_ymm_ymm_ymmm256", Code.VEX_VPSRAVD_YMM_YMM_YMMM256); + map.put("EVEX_Vpsravd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPSRAVD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpsravd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPSRAVD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpsravd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPSRAVD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpsravq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPSRAVQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpsravq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPSRAVQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpsravq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPSRAVQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("VEX_Vpsllvd_xmm_xmm_xmmm128", Code.VEX_VPSLLVD_XMM_XMM_XMMM128); + map.put("VEX_Vpsllvd_ymm_ymm_ymmm256", Code.VEX_VPSLLVD_YMM_YMM_YMMM256); + map.put("VEX_Vpsllvq_xmm_xmm_xmmm128", Code.VEX_VPSLLVQ_XMM_XMM_XMMM128); + map.put("VEX_Vpsllvq_ymm_ymm_ymmm256", Code.VEX_VPSLLVQ_YMM_YMM_YMMM256); + map.put("EVEX_Vpsllvd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPSLLVD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpsllvd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPSLLVD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpsllvd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPSLLVD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpsllvq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPSLLVQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpsllvq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPSLLVQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpsllvq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPSLLVQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vrcp14ps_xmm_k1z_xmmm128b32", Code.EVEX_VRCP14PS_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vrcp14ps_ymm_k1z_ymmm256b32", Code.EVEX_VRCP14PS_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vrcp14ps_zmm_k1z_zmmm512b32", Code.EVEX_VRCP14PS_ZMM_K1Z_ZMMM512B32); + map.put("EVEX_Vrcp14pd_xmm_k1z_xmmm128b64", Code.EVEX_VRCP14PD_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vrcp14pd_ymm_k1z_ymmm256b64", Code.EVEX_VRCP14PD_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vrcp14pd_zmm_k1z_zmmm512b64", Code.EVEX_VRCP14PD_ZMM_K1Z_ZMMM512B64); + map.put("EVEX_Vrcp14ss_xmm_k1z_xmm_xmmm32", Code.EVEX_VRCP14SS_XMM_K1Z_XMM_XMMM32); + map.put("EVEX_Vrcp14sd_xmm_k1z_xmm_xmmm64", Code.EVEX_VRCP14SD_XMM_K1Z_XMM_XMMM64); + map.put("EVEX_Vrsqrt14ps_xmm_k1z_xmmm128b32", Code.EVEX_VRSQRT14PS_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vrsqrt14ps_ymm_k1z_ymmm256b32", Code.EVEX_VRSQRT14PS_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vrsqrt14ps_zmm_k1z_zmmm512b32", Code.EVEX_VRSQRT14PS_ZMM_K1Z_ZMMM512B32); + map.put("EVEX_Vrsqrt14pd_xmm_k1z_xmmm128b64", Code.EVEX_VRSQRT14PD_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vrsqrt14pd_ymm_k1z_ymmm256b64", Code.EVEX_VRSQRT14PD_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vrsqrt14pd_zmm_k1z_zmmm512b64", Code.EVEX_VRSQRT14PD_ZMM_K1Z_ZMMM512B64); + map.put("EVEX_Vrsqrt14ss_xmm_k1z_xmm_xmmm32", Code.EVEX_VRSQRT14SS_XMM_K1Z_XMM_XMMM32); + map.put("EVEX_Vrsqrt14sd_xmm_k1z_xmm_xmmm64", Code.EVEX_VRSQRT14SD_XMM_K1Z_XMM_XMMM64); + map.put("EVEX_Vpdpbusd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPDPBUSD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpdpbusd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPDPBUSD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpdpbusd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPDPBUSD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpdpbusds_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPDPBUSDS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpdpbusds_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPDPBUSDS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpdpbusds_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPDPBUSDS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpdpwssd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPDPWSSD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpdpwssd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPDPWSSD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpdpwssd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPDPWSSD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vdpbf16ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VDPBF16PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vdpbf16ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VDPBF16PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vdpbf16ps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VDPBF16PS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vp4dpwssd_zmm_k1z_zmmp3_m128", Code.EVEX_VP4DPWSSD_ZMM_K1Z_ZMMP3_M128); + map.put("EVEX_Vpdpwssds_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPDPWSSDS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpdpwssds_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPDPWSSDS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpdpwssds_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPDPWSSDS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vp4dpwssds_zmm_k1z_zmmp3_m128", Code.EVEX_VP4DPWSSDS_ZMM_K1Z_ZMMP3_M128); + map.put("EVEX_Vpopcntb_xmm_k1z_xmmm128", Code.EVEX_VPOPCNTB_XMM_K1Z_XMMM128); + map.put("EVEX_Vpopcntb_ymm_k1z_ymmm256", Code.EVEX_VPOPCNTB_YMM_K1Z_YMMM256); + map.put("EVEX_Vpopcntb_zmm_k1z_zmmm512", Code.EVEX_VPOPCNTB_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vpopcntw_xmm_k1z_xmmm128", Code.EVEX_VPOPCNTW_XMM_K1Z_XMMM128); + map.put("EVEX_Vpopcntw_ymm_k1z_ymmm256", Code.EVEX_VPOPCNTW_YMM_K1Z_YMMM256); + map.put("EVEX_Vpopcntw_zmm_k1z_zmmm512", Code.EVEX_VPOPCNTW_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vpopcntd_xmm_k1z_xmmm128b32", Code.EVEX_VPOPCNTD_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vpopcntd_ymm_k1z_ymmm256b32", Code.EVEX_VPOPCNTD_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vpopcntd_zmm_k1z_zmmm512b32", Code.EVEX_VPOPCNTD_ZMM_K1Z_ZMMM512B32); + map.put("EVEX_Vpopcntq_xmm_k1z_xmmm128b64", Code.EVEX_VPOPCNTQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vpopcntq_ymm_k1z_ymmm256b64", Code.EVEX_VPOPCNTQ_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vpopcntq_zmm_k1z_zmmm512b64", Code.EVEX_VPOPCNTQ_ZMM_K1Z_ZMMM512B64); + map.put("VEX_Vpbroadcastd_xmm_xmmm32", Code.VEX_VPBROADCASTD_XMM_XMMM32); + map.put("VEX_Vpbroadcastd_ymm_xmmm32", Code.VEX_VPBROADCASTD_YMM_XMMM32); + map.put("EVEX_Vpbroadcastd_xmm_k1z_xmmm32", Code.EVEX_VPBROADCASTD_XMM_K1Z_XMMM32); + map.put("EVEX_Vpbroadcastd_ymm_k1z_xmmm32", Code.EVEX_VPBROADCASTD_YMM_K1Z_XMMM32); + map.put("EVEX_Vpbroadcastd_zmm_k1z_xmmm32", Code.EVEX_VPBROADCASTD_ZMM_K1Z_XMMM32); + map.put("VEX_Vpbroadcastq_xmm_xmmm64", Code.VEX_VPBROADCASTQ_XMM_XMMM64); + map.put("VEX_Vpbroadcastq_ymm_xmmm64", Code.VEX_VPBROADCASTQ_YMM_XMMM64); + map.put("EVEX_Vbroadcasti32x2_xmm_k1z_xmmm64", Code.EVEX_VBROADCASTI32X2_XMM_K1Z_XMMM64); + map.put("EVEX_Vbroadcasti32x2_ymm_k1z_xmmm64", Code.EVEX_VBROADCASTI32X2_YMM_K1Z_XMMM64); + map.put("EVEX_Vbroadcasti32x2_zmm_k1z_xmmm64", Code.EVEX_VBROADCASTI32X2_ZMM_K1Z_XMMM64); + map.put("EVEX_Vpbroadcastq_xmm_k1z_xmmm64", Code.EVEX_VPBROADCASTQ_XMM_K1Z_XMMM64); + map.put("EVEX_Vpbroadcastq_ymm_k1z_xmmm64", Code.EVEX_VPBROADCASTQ_YMM_K1Z_XMMM64); + map.put("EVEX_Vpbroadcastq_zmm_k1z_xmmm64", Code.EVEX_VPBROADCASTQ_ZMM_K1Z_XMMM64); + map.put("VEX_Vbroadcasti128_ymm_m128", Code.VEX_VBROADCASTI128_YMM_M128); + map.put("EVEX_Vbroadcasti32x4_ymm_k1z_m128", Code.EVEX_VBROADCASTI32X4_YMM_K1Z_M128); + map.put("EVEX_Vbroadcasti32x4_zmm_k1z_m128", Code.EVEX_VBROADCASTI32X4_ZMM_K1Z_M128); + map.put("EVEX_Vbroadcasti64x2_ymm_k1z_m128", Code.EVEX_VBROADCASTI64X2_YMM_K1Z_M128); + map.put("EVEX_Vbroadcasti64x2_zmm_k1z_m128", Code.EVEX_VBROADCASTI64X2_ZMM_K1Z_M128); + map.put("EVEX_Vbroadcasti32x8_zmm_k1z_m256", Code.EVEX_VBROADCASTI32X8_ZMM_K1Z_M256); + map.put("EVEX_Vbroadcasti64x4_zmm_k1z_m256", Code.EVEX_VBROADCASTI64X4_ZMM_K1Z_M256); + map.put("EVEX_Vpexpandb_xmm_k1z_xmmm128", Code.EVEX_VPEXPANDB_XMM_K1Z_XMMM128); + map.put("EVEX_Vpexpandb_ymm_k1z_ymmm256", Code.EVEX_VPEXPANDB_YMM_K1Z_YMMM256); + map.put("EVEX_Vpexpandb_zmm_k1z_zmmm512", Code.EVEX_VPEXPANDB_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vpexpandw_xmm_k1z_xmmm128", Code.EVEX_VPEXPANDW_XMM_K1Z_XMMM128); + map.put("EVEX_Vpexpandw_ymm_k1z_ymmm256", Code.EVEX_VPEXPANDW_YMM_K1Z_YMMM256); + map.put("EVEX_Vpexpandw_zmm_k1z_zmmm512", Code.EVEX_VPEXPANDW_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vpcompressb_xmmm128_k1z_xmm", Code.EVEX_VPCOMPRESSB_XMMM128_K1Z_XMM); + map.put("EVEX_Vpcompressb_ymmm256_k1z_ymm", Code.EVEX_VPCOMPRESSB_YMMM256_K1Z_YMM); + map.put("EVEX_Vpcompressb_zmmm512_k1z_zmm", Code.EVEX_VPCOMPRESSB_ZMMM512_K1Z_ZMM); + map.put("EVEX_Vpcompressw_xmmm128_k1z_xmm", Code.EVEX_VPCOMPRESSW_XMMM128_K1Z_XMM); + map.put("EVEX_Vpcompressw_ymmm256_k1z_ymm", Code.EVEX_VPCOMPRESSW_YMMM256_K1Z_YMM); + map.put("EVEX_Vpcompressw_zmmm512_k1z_zmm", Code.EVEX_VPCOMPRESSW_ZMMM512_K1Z_ZMM); + map.put("EVEX_Vpblendmd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPBLENDMD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpblendmd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPBLENDMD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpblendmd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPBLENDMD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpblendmq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPBLENDMQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpblendmq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPBLENDMQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpblendmq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPBLENDMQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vblendmps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VBLENDMPS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vblendmps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VBLENDMPS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vblendmps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VBLENDMPS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vblendmpd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VBLENDMPD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vblendmpd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VBLENDMPD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vblendmpd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VBLENDMPD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vpblendmb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPBLENDMB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpblendmb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPBLENDMB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpblendmb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPBLENDMB_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpblendmw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPBLENDMW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpblendmw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPBLENDMW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpblendmw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPBLENDMW_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vp2intersectd_kp1_xmm_xmmm128b32", Code.EVEX_VP2INTERSECTD_KP1_XMM_XMMM128B32); + map.put("EVEX_Vp2intersectd_kp1_ymm_ymmm256b32", Code.EVEX_VP2INTERSECTD_KP1_YMM_YMMM256B32); + map.put("EVEX_Vp2intersectd_kp1_zmm_zmmm512b32", Code.EVEX_VP2INTERSECTD_KP1_ZMM_ZMMM512B32); + map.put("EVEX_Vp2intersectq_kp1_xmm_xmmm128b64", Code.EVEX_VP2INTERSECTQ_KP1_XMM_XMMM128B64); + map.put("EVEX_Vp2intersectq_kp1_ymm_ymmm256b64", Code.EVEX_VP2INTERSECTQ_KP1_YMM_YMMM256B64); + map.put("EVEX_Vp2intersectq_kp1_zmm_zmmm512b64", Code.EVEX_VP2INTERSECTQ_KP1_ZMM_ZMMM512B64); + map.put("EVEX_Vpshldvw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSHLDVW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpshldvw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSHLDVW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpshldvw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSHLDVW_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpshldvd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPSHLDVD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpshldvd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPSHLDVD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpshldvd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPSHLDVD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpshldvq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPSHLDVQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpshldvq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPSHLDVQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpshldvq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPSHLDVQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vpshrdvw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPSHRDVW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpshrdvw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPSHRDVW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpshrdvw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPSHRDVW_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vcvtneps2bf16_xmm_k1z_xmmm128b32", Code.EVEX_VCVTNEPS2BF16_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtneps2bf16_xmm_k1z_ymmm256b32", Code.EVEX_VCVTNEPS2BF16_XMM_K1Z_YMMM256B32); + map.put("EVEX_Vcvtneps2bf16_ymm_k1z_zmmm512b32", Code.EVEX_VCVTNEPS2BF16_YMM_K1Z_ZMMM512B32); + map.put("EVEX_Vcvtne2ps2bf16_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VCVTNE2PS2BF16_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vcvtne2ps2bf16_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VCVTNE2PS2BF16_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vcvtne2ps2bf16_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VCVTNE2PS2BF16_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpshrdvd_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPSHRDVD_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpshrdvd_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPSHRDVD_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpshrdvd_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPSHRDVD_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpshrdvq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPSHRDVQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpshrdvq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPSHRDVQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpshrdvq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPSHRDVQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vpermi2b_xmm_k1z_xmm_xmmm128", Code.EVEX_VPERMI2B_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpermi2b_ymm_k1z_ymm_ymmm256", Code.EVEX_VPERMI2B_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpermi2b_zmm_k1z_zmm_zmmm512", Code.EVEX_VPERMI2B_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpermi2w_xmm_k1z_xmm_xmmm128", Code.EVEX_VPERMI2W_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpermi2w_ymm_k1z_ymm_ymmm256", Code.EVEX_VPERMI2W_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpermi2w_zmm_k1z_zmm_zmmm512", Code.EVEX_VPERMI2W_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpermi2d_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPERMI2D_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpermi2d_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPERMI2D_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpermi2d_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPERMI2D_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpermi2q_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPERMI2Q_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpermi2q_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPERMI2Q_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpermi2q_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPERMI2Q_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vpermi2ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPERMI2PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpermi2ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPERMI2PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpermi2ps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPERMI2PS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpermi2pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPERMI2PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpermi2pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPERMI2PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpermi2pd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPERMI2PD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("VEX_Vpbroadcastb_xmm_xmmm8", Code.VEX_VPBROADCASTB_XMM_XMMM8); + map.put("VEX_Vpbroadcastb_ymm_xmmm8", Code.VEX_VPBROADCASTB_YMM_XMMM8); + map.put("EVEX_Vpbroadcastb_xmm_k1z_xmmm8", Code.EVEX_VPBROADCASTB_XMM_K1Z_XMMM8); + map.put("EVEX_Vpbroadcastb_ymm_k1z_xmmm8", Code.EVEX_VPBROADCASTB_YMM_K1Z_XMMM8); + map.put("EVEX_Vpbroadcastb_zmm_k1z_xmmm8", Code.EVEX_VPBROADCASTB_ZMM_K1Z_XMMM8); + map.put("VEX_Vpbroadcastw_xmm_xmmm16", Code.VEX_VPBROADCASTW_XMM_XMMM16); + map.put("VEX_Vpbroadcastw_ymm_xmmm16", Code.VEX_VPBROADCASTW_YMM_XMMM16); + map.put("EVEX_Vpbroadcastw_xmm_k1z_xmmm16", Code.EVEX_VPBROADCASTW_XMM_K1Z_XMMM16); + map.put("EVEX_Vpbroadcastw_ymm_k1z_xmmm16", Code.EVEX_VPBROADCASTW_YMM_K1Z_XMMM16); + map.put("EVEX_Vpbroadcastw_zmm_k1z_xmmm16", Code.EVEX_VPBROADCASTW_ZMM_K1Z_XMMM16); + map.put("EVEX_Vpbroadcastb_xmm_k1z_r32", Code.EVEX_VPBROADCASTB_XMM_K1Z_R32); + map.put("EVEX_Vpbroadcastb_ymm_k1z_r32", Code.EVEX_VPBROADCASTB_YMM_K1Z_R32); + map.put("EVEX_Vpbroadcastb_zmm_k1z_r32", Code.EVEX_VPBROADCASTB_ZMM_K1Z_R32); + map.put("EVEX_Vpbroadcastw_xmm_k1z_r32", Code.EVEX_VPBROADCASTW_XMM_K1Z_R32); + map.put("EVEX_Vpbroadcastw_ymm_k1z_r32", Code.EVEX_VPBROADCASTW_YMM_K1Z_R32); + map.put("EVEX_Vpbroadcastw_zmm_k1z_r32", Code.EVEX_VPBROADCASTW_ZMM_K1Z_R32); + map.put("EVEX_Vpbroadcastd_xmm_k1z_r32", Code.EVEX_VPBROADCASTD_XMM_K1Z_R32); + map.put("EVEX_Vpbroadcastd_ymm_k1z_r32", Code.EVEX_VPBROADCASTD_YMM_K1Z_R32); + map.put("EVEX_Vpbroadcastd_zmm_k1z_r32", Code.EVEX_VPBROADCASTD_ZMM_K1Z_R32); + map.put("EVEX_Vpbroadcastq_xmm_k1z_r64", Code.EVEX_VPBROADCASTQ_XMM_K1Z_R64); + map.put("EVEX_Vpbroadcastq_ymm_k1z_r64", Code.EVEX_VPBROADCASTQ_YMM_K1Z_R64); + map.put("EVEX_Vpbroadcastq_zmm_k1z_r64", Code.EVEX_VPBROADCASTQ_ZMM_K1Z_R64); + map.put("EVEX_Vpermt2b_xmm_k1z_xmm_xmmm128", Code.EVEX_VPERMT2B_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpermt2b_ymm_k1z_ymm_ymmm256", Code.EVEX_VPERMT2B_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpermt2b_zmm_k1z_zmm_zmmm512", Code.EVEX_VPERMT2B_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpermt2w_xmm_k1z_xmm_xmmm128", Code.EVEX_VPERMT2W_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpermt2w_ymm_k1z_ymm_ymmm256", Code.EVEX_VPERMT2W_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpermt2w_zmm_k1z_zmm_zmmm512", Code.EVEX_VPERMT2W_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpermt2d_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPERMT2D_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpermt2d_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPERMT2D_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpermt2d_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPERMT2D_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpermt2q_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPERMT2Q_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpermt2q_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPERMT2Q_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpermt2q_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPERMT2Q_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vpermt2ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VPERMT2PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vpermt2ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VPERMT2PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vpermt2ps_zmm_k1z_zmm_zmmm512b32", Code.EVEX_VPERMT2PS_ZMM_K1Z_ZMM_ZMMM512B32); + map.put("EVEX_Vpermt2pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPERMT2PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpermt2pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPERMT2PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpermt2pd_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPERMT2PD_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("Invept_r32_m128", Code.INVEPT_R32_M128); + map.put("Invept_r64_m128", Code.INVEPT_R64_M128); + map.put("Invvpid_r32_m128", Code.INVVPID_R32_M128); + map.put("Invvpid_r64_m128", Code.INVVPID_R64_M128); + map.put("Invpcid_r32_m128", Code.INVPCID_R32_M128); + map.put("Invpcid_r64_m128", Code.INVPCID_R64_M128); + map.put("EVEX_Vpmultishiftqb_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPMULTISHIFTQB_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpmultishiftqb_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPMULTISHIFTQB_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpmultishiftqb_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPMULTISHIFTQB_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vexpandps_xmm_k1z_xmmm128", Code.EVEX_VEXPANDPS_XMM_K1Z_XMMM128); + map.put("EVEX_Vexpandps_ymm_k1z_ymmm256", Code.EVEX_VEXPANDPS_YMM_K1Z_YMMM256); + map.put("EVEX_Vexpandps_zmm_k1z_zmmm512", Code.EVEX_VEXPANDPS_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vexpandpd_xmm_k1z_xmmm128", Code.EVEX_VEXPANDPD_XMM_K1Z_XMMM128); + map.put("EVEX_Vexpandpd_ymm_k1z_ymmm256", Code.EVEX_VEXPANDPD_YMM_K1Z_YMMM256); + map.put("EVEX_Vexpandpd_zmm_k1z_zmmm512", Code.EVEX_VEXPANDPD_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vpexpandd_xmm_k1z_xmmm128", Code.EVEX_VPEXPANDD_XMM_K1Z_XMMM128); + map.put("EVEX_Vpexpandd_ymm_k1z_ymmm256", Code.EVEX_VPEXPANDD_YMM_K1Z_YMMM256); + map.put("EVEX_Vpexpandd_zmm_k1z_zmmm512", Code.EVEX_VPEXPANDD_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vpexpandq_xmm_k1z_xmmm128", Code.EVEX_VPEXPANDQ_XMM_K1Z_XMMM128); + map.put("EVEX_Vpexpandq_ymm_k1z_ymmm256", Code.EVEX_VPEXPANDQ_YMM_K1Z_YMMM256); + map.put("EVEX_Vpexpandq_zmm_k1z_zmmm512", Code.EVEX_VPEXPANDQ_ZMM_K1Z_ZMMM512); + map.put("EVEX_Vcompressps_xmmm128_k1z_xmm", Code.EVEX_VCOMPRESSPS_XMMM128_K1Z_XMM); + map.put("EVEX_Vcompressps_ymmm256_k1z_ymm", Code.EVEX_VCOMPRESSPS_YMMM256_K1Z_YMM); + map.put("EVEX_Vcompressps_zmmm512_k1z_zmm", Code.EVEX_VCOMPRESSPS_ZMMM512_K1Z_ZMM); + map.put("EVEX_Vcompresspd_xmmm128_k1z_xmm", Code.EVEX_VCOMPRESSPD_XMMM128_K1Z_XMM); + map.put("EVEX_Vcompresspd_ymmm256_k1z_ymm", Code.EVEX_VCOMPRESSPD_YMMM256_K1Z_YMM); + map.put("EVEX_Vcompresspd_zmmm512_k1z_zmm", Code.EVEX_VCOMPRESSPD_ZMMM512_K1Z_ZMM); + map.put("EVEX_Vpcompressd_xmmm128_k1z_xmm", Code.EVEX_VPCOMPRESSD_XMMM128_K1Z_XMM); + map.put("EVEX_Vpcompressd_ymmm256_k1z_ymm", Code.EVEX_VPCOMPRESSD_YMMM256_K1Z_YMM); + map.put("EVEX_Vpcompressd_zmmm512_k1z_zmm", Code.EVEX_VPCOMPRESSD_ZMMM512_K1Z_ZMM); + map.put("EVEX_Vpcompressq_xmmm128_k1z_xmm", Code.EVEX_VPCOMPRESSQ_XMMM128_K1Z_XMM); + map.put("EVEX_Vpcompressq_ymmm256_k1z_ymm", Code.EVEX_VPCOMPRESSQ_YMMM256_K1Z_YMM); + map.put("EVEX_Vpcompressq_zmmm512_k1z_zmm", Code.EVEX_VPCOMPRESSQ_ZMMM512_K1Z_ZMM); + map.put("VEX_Vpmaskmovd_xmm_xmm_m128", Code.VEX_VPMASKMOVD_XMM_XMM_M128); + map.put("VEX_Vpmaskmovd_ymm_ymm_m256", Code.VEX_VPMASKMOVD_YMM_YMM_M256); + map.put("VEX_Vpmaskmovq_xmm_xmm_m128", Code.VEX_VPMASKMOVQ_XMM_XMM_M128); + map.put("VEX_Vpmaskmovq_ymm_ymm_m256", Code.VEX_VPMASKMOVQ_YMM_YMM_M256); + map.put("EVEX_Vpermb_xmm_k1z_xmm_xmmm128", Code.EVEX_VPERMB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpermb_ymm_k1z_ymm_ymmm256", Code.EVEX_VPERMB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpermb_zmm_k1z_zmm_zmmm512", Code.EVEX_VPERMB_ZMM_K1Z_ZMM_ZMMM512); + map.put("EVEX_Vpermw_xmm_k1z_xmm_xmmm128", Code.EVEX_VPERMW_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vpermw_ymm_k1z_ymm_ymmm256", Code.EVEX_VPERMW_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vpermw_zmm_k1z_zmm_zmmm512", Code.EVEX_VPERMW_ZMM_K1Z_ZMM_ZMMM512); + map.put("VEX_Vpmaskmovd_m128_xmm_xmm", Code.VEX_VPMASKMOVD_M128_XMM_XMM); + map.put("VEX_Vpmaskmovd_m256_ymm_ymm", Code.VEX_VPMASKMOVD_M256_YMM_YMM); + map.put("VEX_Vpmaskmovq_m128_xmm_xmm", Code.VEX_VPMASKMOVQ_M128_XMM_XMM); + map.put("VEX_Vpmaskmovq_m256_ymm_ymm", Code.VEX_VPMASKMOVQ_M256_YMM_YMM); + map.put("EVEX_Vpshufbitqmb_kr_k1_xmm_xmmm128", Code.EVEX_VPSHUFBITQMB_KR_K1_XMM_XMMM128); + map.put("EVEX_Vpshufbitqmb_kr_k1_ymm_ymmm256", Code.EVEX_VPSHUFBITQMB_KR_K1_YMM_YMMM256); + map.put("EVEX_Vpshufbitqmb_kr_k1_zmm_zmmm512", Code.EVEX_VPSHUFBITQMB_KR_K1_ZMM_ZMMM512); + map.put("VEX_Vpgatherdd_xmm_vm32x_xmm", Code.VEX_VPGATHERDD_XMM_VM32X_XMM); + map.put("VEX_Vpgatherdd_ymm_vm32y_ymm", Code.VEX_VPGATHERDD_YMM_VM32Y_YMM); + map.put("VEX_Vpgatherdq_xmm_vm32x_xmm", Code.VEX_VPGATHERDQ_XMM_VM32X_XMM); + map.put("VEX_Vpgatherdq_ymm_vm32x_ymm", Code.VEX_VPGATHERDQ_YMM_VM32X_YMM); + map.put("EVEX_Vpgatherdd_xmm_k1_vm32x", Code.EVEX_VPGATHERDD_XMM_K1_VM32X); + map.put("EVEX_Vpgatherdd_ymm_k1_vm32y", Code.EVEX_VPGATHERDD_YMM_K1_VM32Y); + map.put("EVEX_Vpgatherdd_zmm_k1_vm32z", Code.EVEX_VPGATHERDD_ZMM_K1_VM32Z); + map.put("EVEX_Vpgatherdq_xmm_k1_vm32x", Code.EVEX_VPGATHERDQ_XMM_K1_VM32X); + map.put("EVEX_Vpgatherdq_ymm_k1_vm32x", Code.EVEX_VPGATHERDQ_YMM_K1_VM32X); + map.put("EVEX_Vpgatherdq_zmm_k1_vm32y", Code.EVEX_VPGATHERDQ_ZMM_K1_VM32Y); + map.put("VEX_Vpgatherqd_xmm_vm64x_xmm", Code.VEX_VPGATHERQD_XMM_VM64X_XMM); + map.put("VEX_Vpgatherqd_xmm_vm64y_xmm", Code.VEX_VPGATHERQD_XMM_VM64Y_XMM); + map.put("VEX_Vpgatherqq_xmm_vm64x_xmm", Code.VEX_VPGATHERQQ_XMM_VM64X_XMM); + map.put("VEX_Vpgatherqq_ymm_vm64y_ymm", Code.VEX_VPGATHERQQ_YMM_VM64Y_YMM); + map.put("EVEX_Vpgatherqd_xmm_k1_vm64x", Code.EVEX_VPGATHERQD_XMM_K1_VM64X); + map.put("EVEX_Vpgatherqd_xmm_k1_vm64y", Code.EVEX_VPGATHERQD_XMM_K1_VM64Y); + map.put("EVEX_Vpgatherqd_ymm_k1_vm64z", Code.EVEX_VPGATHERQD_YMM_K1_VM64Z); + map.put("EVEX_Vpgatherqq_xmm_k1_vm64x", Code.EVEX_VPGATHERQQ_XMM_K1_VM64X); + map.put("EVEX_Vpgatherqq_ymm_k1_vm64y", Code.EVEX_VPGATHERQQ_YMM_K1_VM64Y); + map.put("EVEX_Vpgatherqq_zmm_k1_vm64z", Code.EVEX_VPGATHERQQ_ZMM_K1_VM64Z); + map.put("VEX_Vgatherdps_xmm_vm32x_xmm", Code.VEX_VGATHERDPS_XMM_VM32X_XMM); + map.put("VEX_Vgatherdps_ymm_vm32y_ymm", Code.VEX_VGATHERDPS_YMM_VM32Y_YMM); + map.put("VEX_Vgatherdpd_xmm_vm32x_xmm", Code.VEX_VGATHERDPD_XMM_VM32X_XMM); + map.put("VEX_Vgatherdpd_ymm_vm32x_ymm", Code.VEX_VGATHERDPD_YMM_VM32X_YMM); + map.put("EVEX_Vgatherdps_xmm_k1_vm32x", Code.EVEX_VGATHERDPS_XMM_K1_VM32X); + map.put("EVEX_Vgatherdps_ymm_k1_vm32y", Code.EVEX_VGATHERDPS_YMM_K1_VM32Y); + map.put("EVEX_Vgatherdps_zmm_k1_vm32z", Code.EVEX_VGATHERDPS_ZMM_K1_VM32Z); + map.put("EVEX_Vgatherdpd_xmm_k1_vm32x", Code.EVEX_VGATHERDPD_XMM_K1_VM32X); + map.put("EVEX_Vgatherdpd_ymm_k1_vm32x", Code.EVEX_VGATHERDPD_YMM_K1_VM32X); + map.put("EVEX_Vgatherdpd_zmm_k1_vm32y", Code.EVEX_VGATHERDPD_ZMM_K1_VM32Y); + map.put("VEX_Vgatherqps_xmm_vm64x_xmm", Code.VEX_VGATHERQPS_XMM_VM64X_XMM); + map.put("VEX_Vgatherqps_xmm_vm64y_xmm", Code.VEX_VGATHERQPS_XMM_VM64Y_XMM); + map.put("VEX_Vgatherqpd_xmm_vm64x_xmm", Code.VEX_VGATHERQPD_XMM_VM64X_XMM); + map.put("VEX_Vgatherqpd_ymm_vm64y_ymm", Code.VEX_VGATHERQPD_YMM_VM64Y_YMM); + map.put("EVEX_Vgatherqps_xmm_k1_vm64x", Code.EVEX_VGATHERQPS_XMM_K1_VM64X); + map.put("EVEX_Vgatherqps_xmm_k1_vm64y", Code.EVEX_VGATHERQPS_XMM_K1_VM64Y); + map.put("EVEX_Vgatherqps_ymm_k1_vm64z", Code.EVEX_VGATHERQPS_YMM_K1_VM64Z); + map.put("EVEX_Vgatherqpd_xmm_k1_vm64x", Code.EVEX_VGATHERQPD_XMM_K1_VM64X); + map.put("EVEX_Vgatherqpd_ymm_k1_vm64y", Code.EVEX_VGATHERQPD_YMM_K1_VM64Y); + map.put("EVEX_Vgatherqpd_zmm_k1_vm64z", Code.EVEX_VGATHERQPD_ZMM_K1_VM64Z); + map.put("VEX_Vfmaddsub132ps_xmm_xmm_xmmm128", Code.VEX_VFMADDSUB132PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmaddsub132ps_ymm_ymm_ymmm256", Code.VEX_VFMADDSUB132PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmaddsub132pd_xmm_xmm_xmmm128", Code.VEX_VFMADDSUB132PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmaddsub132pd_ymm_ymm_ymmm256", Code.VEX_VFMADDSUB132PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmaddsub132ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMADDSUB132PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmaddsub132ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMADDSUB132PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmaddsub132ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMADDSUB132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmaddsub132pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMADDSUB132PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmaddsub132pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMADDSUB132PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmaddsub132pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMADDSUB132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfmsubadd132ps_xmm_xmm_xmmm128", Code.VEX_VFMSUBADD132PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmsubadd132ps_ymm_ymm_ymmm256", Code.VEX_VFMSUBADD132PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmsubadd132pd_xmm_xmm_xmmm128", Code.VEX_VFMSUBADD132PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmsubadd132pd_ymm_ymm_ymmm256", Code.VEX_VFMSUBADD132PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmsubadd132ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMSUBADD132PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmsubadd132ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMSUBADD132PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmsubadd132ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMSUBADD132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmsubadd132pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMSUBADD132PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmsubadd132pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMSUBADD132PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmsubadd132pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMSUBADD132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfmadd132ps_xmm_xmm_xmmm128", Code.VEX_VFMADD132PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmadd132ps_ymm_ymm_ymmm256", Code.VEX_VFMADD132PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmadd132pd_xmm_xmm_xmmm128", Code.VEX_VFMADD132PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmadd132pd_ymm_ymm_ymmm256", Code.VEX_VFMADD132PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmadd132ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMADD132PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmadd132ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMADD132PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmadd132ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMADD132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmadd132pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMADD132PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmadd132pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMADD132PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmadd132pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMADD132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfmadd132ss_xmm_xmm_xmmm32", Code.VEX_VFMADD132SS_XMM_XMM_XMMM32); + map.put("VEX_Vfmadd132sd_xmm_xmm_xmmm64", Code.VEX_VFMADD132SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfmadd132ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFMADD132SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfmadd132sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFMADD132SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("VEX_Vfmsub132ps_xmm_xmm_xmmm128", Code.VEX_VFMSUB132PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmsub132ps_ymm_ymm_ymmm256", Code.VEX_VFMSUB132PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmsub132pd_xmm_xmm_xmmm128", Code.VEX_VFMSUB132PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmsub132pd_ymm_ymm_ymmm256", Code.VEX_VFMSUB132PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmsub132ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMSUB132PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmsub132ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMSUB132PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmsub132ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMSUB132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmsub132pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMSUB132PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmsub132pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMSUB132PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmsub132pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMSUB132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("EVEX_V4fmaddps_zmm_k1z_zmmp3_m128", Code.EVEX_V4FMADDPS_ZMM_K1Z_ZMMP3_M128); + map.put("VEX_Vfmsub132ss_xmm_xmm_xmmm32", Code.VEX_VFMSUB132SS_XMM_XMM_XMMM32); + map.put("VEX_Vfmsub132sd_xmm_xmm_xmmm64", Code.VEX_VFMSUB132SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfmsub132ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFMSUB132SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfmsub132sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFMSUB132SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("EVEX_V4fmaddss_xmm_k1z_xmmp3_m128", Code.EVEX_V4FMADDSS_XMM_K1Z_XMMP3_M128); + map.put("VEX_Vfnmadd132ps_xmm_xmm_xmmm128", Code.VEX_VFNMADD132PS_XMM_XMM_XMMM128); + map.put("VEX_Vfnmadd132ps_ymm_ymm_ymmm256", Code.VEX_VFNMADD132PS_YMM_YMM_YMMM256); + map.put("VEX_Vfnmadd132pd_xmm_xmm_xmmm128", Code.VEX_VFNMADD132PD_XMM_XMM_XMMM128); + map.put("VEX_Vfnmadd132pd_ymm_ymm_ymmm256", Code.VEX_VFNMADD132PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfnmadd132ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFNMADD132PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfnmadd132ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFNMADD132PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfnmadd132ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFNMADD132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfnmadd132pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFNMADD132PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfnmadd132pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFNMADD132PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfnmadd132pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFNMADD132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfnmadd132ss_xmm_xmm_xmmm32", Code.VEX_VFNMADD132SS_XMM_XMM_XMMM32); + map.put("VEX_Vfnmadd132sd_xmm_xmm_xmmm64", Code.VEX_VFNMADD132SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfnmadd132ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFNMADD132SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfnmadd132sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFNMADD132SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("VEX_Vfnmsub132ps_xmm_xmm_xmmm128", Code.VEX_VFNMSUB132PS_XMM_XMM_XMMM128); + map.put("VEX_Vfnmsub132ps_ymm_ymm_ymmm256", Code.VEX_VFNMSUB132PS_YMM_YMM_YMMM256); + map.put("VEX_Vfnmsub132pd_xmm_xmm_xmmm128", Code.VEX_VFNMSUB132PD_XMM_XMM_XMMM128); + map.put("VEX_Vfnmsub132pd_ymm_ymm_ymmm256", Code.VEX_VFNMSUB132PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfnmsub132ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFNMSUB132PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfnmsub132ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFNMSUB132PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfnmsub132ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFNMSUB132PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfnmsub132pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFNMSUB132PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfnmsub132pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFNMSUB132PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfnmsub132pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFNMSUB132PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfnmsub132ss_xmm_xmm_xmmm32", Code.VEX_VFNMSUB132SS_XMM_XMM_XMMM32); + map.put("VEX_Vfnmsub132sd_xmm_xmm_xmmm64", Code.VEX_VFNMSUB132SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfnmsub132ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFNMSUB132SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfnmsub132sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFNMSUB132SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("EVEX_Vpscatterdd_vm32x_k1_xmm", Code.EVEX_VPSCATTERDD_VM32X_K1_XMM); + map.put("EVEX_Vpscatterdd_vm32y_k1_ymm", Code.EVEX_VPSCATTERDD_VM32Y_K1_YMM); + map.put("EVEX_Vpscatterdd_vm32z_k1_zmm", Code.EVEX_VPSCATTERDD_VM32Z_K1_ZMM); + map.put("EVEX_Vpscatterdq_vm32x_k1_xmm", Code.EVEX_VPSCATTERDQ_VM32X_K1_XMM); + map.put("EVEX_Vpscatterdq_vm32x_k1_ymm", Code.EVEX_VPSCATTERDQ_VM32X_K1_YMM); + map.put("EVEX_Vpscatterdq_vm32y_k1_zmm", Code.EVEX_VPSCATTERDQ_VM32Y_K1_ZMM); + map.put("EVEX_Vpscatterqd_vm64x_k1_xmm", Code.EVEX_VPSCATTERQD_VM64X_K1_XMM); + map.put("EVEX_Vpscatterqd_vm64y_k1_xmm", Code.EVEX_VPSCATTERQD_VM64Y_K1_XMM); + map.put("EVEX_Vpscatterqd_vm64z_k1_ymm", Code.EVEX_VPSCATTERQD_VM64Z_K1_YMM); + map.put("EVEX_Vpscatterqq_vm64x_k1_xmm", Code.EVEX_VPSCATTERQQ_VM64X_K1_XMM); + map.put("EVEX_Vpscatterqq_vm64y_k1_ymm", Code.EVEX_VPSCATTERQQ_VM64Y_K1_YMM); + map.put("EVEX_Vpscatterqq_vm64z_k1_zmm", Code.EVEX_VPSCATTERQQ_VM64Z_K1_ZMM); + map.put("EVEX_Vscatterdps_vm32x_k1_xmm", Code.EVEX_VSCATTERDPS_VM32X_K1_XMM); + map.put("EVEX_Vscatterdps_vm32y_k1_ymm", Code.EVEX_VSCATTERDPS_VM32Y_K1_YMM); + map.put("EVEX_Vscatterdps_vm32z_k1_zmm", Code.EVEX_VSCATTERDPS_VM32Z_K1_ZMM); + map.put("EVEX_Vscatterdpd_vm32x_k1_xmm", Code.EVEX_VSCATTERDPD_VM32X_K1_XMM); + map.put("EVEX_Vscatterdpd_vm32x_k1_ymm", Code.EVEX_VSCATTERDPD_VM32X_K1_YMM); + map.put("EVEX_Vscatterdpd_vm32y_k1_zmm", Code.EVEX_VSCATTERDPD_VM32Y_K1_ZMM); + map.put("EVEX_Vscatterqps_vm64x_k1_xmm", Code.EVEX_VSCATTERQPS_VM64X_K1_XMM); + map.put("EVEX_Vscatterqps_vm64y_k1_xmm", Code.EVEX_VSCATTERQPS_VM64Y_K1_XMM); + map.put("EVEX_Vscatterqps_vm64z_k1_ymm", Code.EVEX_VSCATTERQPS_VM64Z_K1_YMM); + map.put("EVEX_Vscatterqpd_vm64x_k1_xmm", Code.EVEX_VSCATTERQPD_VM64X_K1_XMM); + map.put("EVEX_Vscatterqpd_vm64y_k1_ymm", Code.EVEX_VSCATTERQPD_VM64Y_K1_YMM); + map.put("EVEX_Vscatterqpd_vm64z_k1_zmm", Code.EVEX_VSCATTERQPD_VM64Z_K1_ZMM); + map.put("VEX_Vfmaddsub213ps_xmm_xmm_xmmm128", Code.VEX_VFMADDSUB213PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmaddsub213ps_ymm_ymm_ymmm256", Code.VEX_VFMADDSUB213PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmaddsub213pd_xmm_xmm_xmmm128", Code.VEX_VFMADDSUB213PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmaddsub213pd_ymm_ymm_ymmm256", Code.VEX_VFMADDSUB213PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmaddsub213ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMADDSUB213PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmaddsub213ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMADDSUB213PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmaddsub213ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMADDSUB213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmaddsub213pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMADDSUB213PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmaddsub213pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMADDSUB213PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmaddsub213pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMADDSUB213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfmsubadd213ps_xmm_xmm_xmmm128", Code.VEX_VFMSUBADD213PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmsubadd213ps_ymm_ymm_ymmm256", Code.VEX_VFMSUBADD213PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmsubadd213pd_xmm_xmm_xmmm128", Code.VEX_VFMSUBADD213PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmsubadd213pd_ymm_ymm_ymmm256", Code.VEX_VFMSUBADD213PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmsubadd213ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMSUBADD213PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmsubadd213ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMSUBADD213PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmsubadd213ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMSUBADD213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmsubadd213pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMSUBADD213PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmsubadd213pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMSUBADD213PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmsubadd213pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMSUBADD213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfmadd213ps_xmm_xmm_xmmm128", Code.VEX_VFMADD213PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmadd213ps_ymm_ymm_ymmm256", Code.VEX_VFMADD213PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmadd213pd_xmm_xmm_xmmm128", Code.VEX_VFMADD213PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmadd213pd_ymm_ymm_ymmm256", Code.VEX_VFMADD213PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmadd213ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMADD213PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmadd213ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMADD213PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmadd213ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMADD213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmadd213pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMADD213PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmadd213pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMADD213PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmadd213pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMADD213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfmadd213ss_xmm_xmm_xmmm32", Code.VEX_VFMADD213SS_XMM_XMM_XMMM32); + map.put("VEX_Vfmadd213sd_xmm_xmm_xmmm64", Code.VEX_VFMADD213SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfmadd213ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFMADD213SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfmadd213sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFMADD213SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("VEX_Vfmsub213ps_xmm_xmm_xmmm128", Code.VEX_VFMSUB213PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmsub213ps_ymm_ymm_ymmm256", Code.VEX_VFMSUB213PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmsub213pd_xmm_xmm_xmmm128", Code.VEX_VFMSUB213PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmsub213pd_ymm_ymm_ymmm256", Code.VEX_VFMSUB213PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmsub213ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMSUB213PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmsub213ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMSUB213PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmsub213ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMSUB213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmsub213pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMSUB213PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmsub213pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMSUB213PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmsub213pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMSUB213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("EVEX_V4fnmaddps_zmm_k1z_zmmp3_m128", Code.EVEX_V4FNMADDPS_ZMM_K1Z_ZMMP3_M128); + map.put("VEX_Vfmsub213ss_xmm_xmm_xmmm32", Code.VEX_VFMSUB213SS_XMM_XMM_XMMM32); + map.put("VEX_Vfmsub213sd_xmm_xmm_xmmm64", Code.VEX_VFMSUB213SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfmsub213ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFMSUB213SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfmsub213sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFMSUB213SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("EVEX_V4fnmaddss_xmm_k1z_xmmp3_m128", Code.EVEX_V4FNMADDSS_XMM_K1Z_XMMP3_M128); + map.put("VEX_Vfnmadd213ps_xmm_xmm_xmmm128", Code.VEX_VFNMADD213PS_XMM_XMM_XMMM128); + map.put("VEX_Vfnmadd213ps_ymm_ymm_ymmm256", Code.VEX_VFNMADD213PS_YMM_YMM_YMMM256); + map.put("VEX_Vfnmadd213pd_xmm_xmm_xmmm128", Code.VEX_VFNMADD213PD_XMM_XMM_XMMM128); + map.put("VEX_Vfnmadd213pd_ymm_ymm_ymmm256", Code.VEX_VFNMADD213PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfnmadd213ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFNMADD213PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfnmadd213ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFNMADD213PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfnmadd213ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFNMADD213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfnmadd213pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFNMADD213PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfnmadd213pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFNMADD213PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfnmadd213pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFNMADD213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfnmadd213ss_xmm_xmm_xmmm32", Code.VEX_VFNMADD213SS_XMM_XMM_XMMM32); + map.put("VEX_Vfnmadd213sd_xmm_xmm_xmmm64", Code.VEX_VFNMADD213SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfnmadd213ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFNMADD213SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfnmadd213sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFNMADD213SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("VEX_Vfnmsub213ps_xmm_xmm_xmmm128", Code.VEX_VFNMSUB213PS_XMM_XMM_XMMM128); + map.put("VEX_Vfnmsub213ps_ymm_ymm_ymmm256", Code.VEX_VFNMSUB213PS_YMM_YMM_YMMM256); + map.put("VEX_Vfnmsub213pd_xmm_xmm_xmmm128", Code.VEX_VFNMSUB213PD_XMM_XMM_XMMM128); + map.put("VEX_Vfnmsub213pd_ymm_ymm_ymmm256", Code.VEX_VFNMSUB213PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfnmsub213ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFNMSUB213PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfnmsub213ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFNMSUB213PS_YMM_K1Z_YMM_YMMM256B32); + } + + private static void initMap7(HashMap map) { + map.put("EVEX_Vfnmsub213ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFNMSUB213PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfnmsub213pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFNMSUB213PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfnmsub213pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFNMSUB213PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfnmsub213pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFNMSUB213PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfnmsub213ss_xmm_xmm_xmmm32", Code.VEX_VFNMSUB213SS_XMM_XMM_XMMM32); + map.put("VEX_Vfnmsub213sd_xmm_xmm_xmmm64", Code.VEX_VFNMSUB213SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfnmsub213ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFNMSUB213SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfnmsub213sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFNMSUB213SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("EVEX_Vpmadd52luq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPMADD52LUQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpmadd52luq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPMADD52LUQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpmadd52luq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPMADD52LUQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("EVEX_Vpmadd52huq_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VPMADD52HUQ_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vpmadd52huq_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VPMADD52HUQ_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vpmadd52huq_zmm_k1z_zmm_zmmm512b64", Code.EVEX_VPMADD52HUQ_ZMM_K1Z_ZMM_ZMMM512B64); + map.put("VEX_Vfmaddsub231ps_xmm_xmm_xmmm128", Code.VEX_VFMADDSUB231PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmaddsub231ps_ymm_ymm_ymmm256", Code.VEX_VFMADDSUB231PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmaddsub231pd_xmm_xmm_xmmm128", Code.VEX_VFMADDSUB231PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmaddsub231pd_ymm_ymm_ymmm256", Code.VEX_VFMADDSUB231PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmaddsub231ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMADDSUB231PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmaddsub231ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMADDSUB231PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmaddsub231ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMADDSUB231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmaddsub231pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMADDSUB231PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmaddsub231pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMADDSUB231PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmaddsub231pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMADDSUB231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfmsubadd231ps_xmm_xmm_xmmm128", Code.VEX_VFMSUBADD231PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmsubadd231ps_ymm_ymm_ymmm256", Code.VEX_VFMSUBADD231PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmsubadd231pd_xmm_xmm_xmmm128", Code.VEX_VFMSUBADD231PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmsubadd231pd_ymm_ymm_ymmm256", Code.VEX_VFMSUBADD231PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmsubadd231ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMSUBADD231PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmsubadd231ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMSUBADD231PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmsubadd231ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMSUBADD231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmsubadd231pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMSUBADD231PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmsubadd231pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMSUBADD231PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmsubadd231pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMSUBADD231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfmadd231ps_xmm_xmm_xmmm128", Code.VEX_VFMADD231PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmadd231ps_ymm_ymm_ymmm256", Code.VEX_VFMADD231PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmadd231pd_xmm_xmm_xmmm128", Code.VEX_VFMADD231PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmadd231pd_ymm_ymm_ymmm256", Code.VEX_VFMADD231PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmadd231ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMADD231PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmadd231ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMADD231PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmadd231ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMADD231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmadd231pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMADD231PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmadd231pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMADD231PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmadd231pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMADD231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfmadd231ss_xmm_xmm_xmmm32", Code.VEX_VFMADD231SS_XMM_XMM_XMMM32); + map.put("VEX_Vfmadd231sd_xmm_xmm_xmmm64", Code.VEX_VFMADD231SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfmadd231ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFMADD231SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfmadd231sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFMADD231SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("VEX_Vfmsub231ps_xmm_xmm_xmmm128", Code.VEX_VFMSUB231PS_XMM_XMM_XMMM128); + map.put("VEX_Vfmsub231ps_ymm_ymm_ymmm256", Code.VEX_VFMSUB231PS_YMM_YMM_YMMM256); + map.put("VEX_Vfmsub231pd_xmm_xmm_xmmm128", Code.VEX_VFMSUB231PD_XMM_XMM_XMMM128); + map.put("VEX_Vfmsub231pd_ymm_ymm_ymmm256", Code.VEX_VFMSUB231PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfmsub231ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMSUB231PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmsub231ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMSUB231PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmsub231ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMSUB231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmsub231pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFMSUB231PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfmsub231pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFMSUB231PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfmsub231pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFMSUB231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfmsub231ss_xmm_xmm_xmmm32", Code.VEX_VFMSUB231SS_XMM_XMM_XMMM32); + map.put("VEX_Vfmsub231sd_xmm_xmm_xmmm64", Code.VEX_VFMSUB231SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfmsub231ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFMSUB231SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfmsub231sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFMSUB231SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("VEX_Vfnmadd231ps_xmm_xmm_xmmm128", Code.VEX_VFNMADD231PS_XMM_XMM_XMMM128); + map.put("VEX_Vfnmadd231ps_ymm_ymm_ymmm256", Code.VEX_VFNMADD231PS_YMM_YMM_YMMM256); + map.put("VEX_Vfnmadd231pd_xmm_xmm_xmmm128", Code.VEX_VFNMADD231PD_XMM_XMM_XMMM128); + map.put("VEX_Vfnmadd231pd_ymm_ymm_ymmm256", Code.VEX_VFNMADD231PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfnmadd231ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFNMADD231PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfnmadd231ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFNMADD231PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfnmadd231ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFNMADD231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfnmadd231pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFNMADD231PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfnmadd231pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFNMADD231PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfnmadd231pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFNMADD231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfnmadd231ss_xmm_xmm_xmmm32", Code.VEX_VFNMADD231SS_XMM_XMM_XMMM32); + map.put("VEX_Vfnmadd231sd_xmm_xmm_xmmm64", Code.VEX_VFNMADD231SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfnmadd231ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFNMADD231SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfnmadd231sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFNMADD231SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("VEX_Vfnmsub231ps_xmm_xmm_xmmm128", Code.VEX_VFNMSUB231PS_XMM_XMM_XMMM128); + map.put("VEX_Vfnmsub231ps_ymm_ymm_ymmm256", Code.VEX_VFNMSUB231PS_YMM_YMM_YMMM256); + map.put("VEX_Vfnmsub231pd_xmm_xmm_xmmm128", Code.VEX_VFNMSUB231PD_XMM_XMM_XMMM128); + map.put("VEX_Vfnmsub231pd_ymm_ymm_ymmm256", Code.VEX_VFNMSUB231PD_YMM_YMM_YMMM256); + map.put("EVEX_Vfnmsub231ps_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFNMSUB231PS_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfnmsub231ps_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFNMSUB231PS_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfnmsub231ps_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFNMSUB231PS_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfnmsub231pd_xmm_k1z_xmm_xmmm128b64", Code.EVEX_VFNMSUB231PD_XMM_K1Z_XMM_XMMM128B64); + map.put("EVEX_Vfnmsub231pd_ymm_k1z_ymm_ymmm256b64", Code.EVEX_VFNMSUB231PD_YMM_K1Z_YMM_YMMM256B64); + map.put("EVEX_Vfnmsub231pd_zmm_k1z_zmm_zmmm512b64_er", Code.EVEX_VFNMSUB231PD_ZMM_K1Z_ZMM_ZMMM512B64_ER); + map.put("VEX_Vfnmsub231ss_xmm_xmm_xmmm32", Code.VEX_VFNMSUB231SS_XMM_XMM_XMMM32); + map.put("VEX_Vfnmsub231sd_xmm_xmm_xmmm64", Code.VEX_VFNMSUB231SD_XMM_XMM_XMMM64); + map.put("EVEX_Vfnmsub231ss_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFNMSUB231SS_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfnmsub231sd_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VFNMSUB231SD_XMM_K1Z_XMM_XMMM64_ER); + map.put("EVEX_Vpconflictd_xmm_k1z_xmmm128b32", Code.EVEX_VPCONFLICTD_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vpconflictd_ymm_k1z_ymmm256b32", Code.EVEX_VPCONFLICTD_YMM_K1Z_YMMM256B32); + map.put("EVEX_Vpconflictd_zmm_k1z_zmmm512b32", Code.EVEX_VPCONFLICTD_ZMM_K1Z_ZMMM512B32); + map.put("EVEX_Vpconflictq_xmm_k1z_xmmm128b64", Code.EVEX_VPCONFLICTQ_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vpconflictq_ymm_k1z_ymmm256b64", Code.EVEX_VPCONFLICTQ_YMM_K1Z_YMMM256B64); + map.put("EVEX_Vpconflictq_zmm_k1z_zmmm512b64", Code.EVEX_VPCONFLICTQ_ZMM_K1Z_ZMMM512B64); + map.put("EVEX_Vgatherpf0dps_vm32z_k1", Code.EVEX_VGATHERPF0DPS_VM32Z_K1); + map.put("EVEX_Vgatherpf0dpd_vm32y_k1", Code.EVEX_VGATHERPF0DPD_VM32Y_K1); + map.put("EVEX_Vgatherpf1dps_vm32z_k1", Code.EVEX_VGATHERPF1DPS_VM32Z_K1); + map.put("EVEX_Vgatherpf1dpd_vm32y_k1", Code.EVEX_VGATHERPF1DPD_VM32Y_K1); + map.put("EVEX_Vscatterpf0dps_vm32z_k1", Code.EVEX_VSCATTERPF0DPS_VM32Z_K1); + map.put("EVEX_Vscatterpf0dpd_vm32y_k1", Code.EVEX_VSCATTERPF0DPD_VM32Y_K1); + map.put("EVEX_Vscatterpf1dps_vm32z_k1", Code.EVEX_VSCATTERPF1DPS_VM32Z_K1); + map.put("EVEX_Vscatterpf1dpd_vm32y_k1", Code.EVEX_VSCATTERPF1DPD_VM32Y_K1); + map.put("EVEX_Vgatherpf0qps_vm64z_k1", Code.EVEX_VGATHERPF0QPS_VM64Z_K1); + map.put("EVEX_Vgatherpf0qpd_vm64z_k1", Code.EVEX_VGATHERPF0QPD_VM64Z_K1); + map.put("EVEX_Vgatherpf1qps_vm64z_k1", Code.EVEX_VGATHERPF1QPS_VM64Z_K1); + map.put("EVEX_Vgatherpf1qpd_vm64z_k1", Code.EVEX_VGATHERPF1QPD_VM64Z_K1); + map.put("EVEX_Vscatterpf0qps_vm64z_k1", Code.EVEX_VSCATTERPF0QPS_VM64Z_K1); + map.put("EVEX_Vscatterpf0qpd_vm64z_k1", Code.EVEX_VSCATTERPF0QPD_VM64Z_K1); + map.put("EVEX_Vscatterpf1qps_vm64z_k1", Code.EVEX_VSCATTERPF1QPS_VM64Z_K1); + map.put("EVEX_Vscatterpf1qpd_vm64z_k1", Code.EVEX_VSCATTERPF1QPD_VM64Z_K1); + map.put("Sha1nexte_xmm_xmmm128", Code.SHA1NEXTE_XMM_XMMM128); + map.put("EVEX_Vexp2ps_zmm_k1z_zmmm512b32_sae", Code.EVEX_VEXP2PS_ZMM_K1Z_ZMMM512B32_SAE); + map.put("EVEX_Vexp2pd_zmm_k1z_zmmm512b64_sae", Code.EVEX_VEXP2PD_ZMM_K1Z_ZMMM512B64_SAE); + map.put("Sha1msg1_xmm_xmmm128", Code.SHA1MSG1_XMM_XMMM128); + map.put("Sha1msg2_xmm_xmmm128", Code.SHA1MSG2_XMM_XMMM128); + map.put("EVEX_Vrcp28ps_zmm_k1z_zmmm512b32_sae", Code.EVEX_VRCP28PS_ZMM_K1Z_ZMMM512B32_SAE); + map.put("EVEX_Vrcp28pd_zmm_k1z_zmmm512b64_sae", Code.EVEX_VRCP28PD_ZMM_K1Z_ZMMM512B64_SAE); + map.put("Sha256rnds2_xmm_xmmm128", Code.SHA256RNDS2_XMM_XMMM128); + map.put("EVEX_Vrcp28ss_xmm_k1z_xmm_xmmm32_sae", Code.EVEX_VRCP28SS_XMM_K1Z_XMM_XMMM32_SAE); + map.put("EVEX_Vrcp28sd_xmm_k1z_xmm_xmmm64_sae", Code.EVEX_VRCP28SD_XMM_K1Z_XMM_XMMM64_SAE); + map.put("Sha256msg1_xmm_xmmm128", Code.SHA256MSG1_XMM_XMMM128); + map.put("EVEX_Vrsqrt28ps_zmm_k1z_zmmm512b32_sae", Code.EVEX_VRSQRT28PS_ZMM_K1Z_ZMMM512B32_SAE); + map.put("EVEX_Vrsqrt28pd_zmm_k1z_zmmm512b64_sae", Code.EVEX_VRSQRT28PD_ZMM_K1Z_ZMMM512B64_SAE); + map.put("Sha256msg2_xmm_xmmm128", Code.SHA256MSG2_XMM_XMMM128); + map.put("EVEX_Vrsqrt28ss_xmm_k1z_xmm_xmmm32_sae", Code.EVEX_VRSQRT28SS_XMM_K1Z_XMM_XMMM32_SAE); + map.put("EVEX_Vrsqrt28sd_xmm_k1z_xmm_xmmm64_sae", Code.EVEX_VRSQRT28SD_XMM_K1Z_XMM_XMMM64_SAE); + map.put("Gf2p8mulb_xmm_xmmm128", Code.GF2P8MULB_XMM_XMMM128); + map.put("VEX_Vgf2p8mulb_xmm_xmm_xmmm128", Code.VEX_VGF2P8MULB_XMM_XMM_XMMM128); + map.put("VEX_Vgf2p8mulb_ymm_ymm_ymmm256", Code.VEX_VGF2P8MULB_YMM_YMM_YMMM256); + map.put("EVEX_Vgf2p8mulb_xmm_k1z_xmm_xmmm128", Code.EVEX_VGF2P8MULB_XMM_K1Z_XMM_XMMM128); + map.put("EVEX_Vgf2p8mulb_ymm_k1z_ymm_ymmm256", Code.EVEX_VGF2P8MULB_YMM_K1Z_YMM_YMMM256); + map.put("EVEX_Vgf2p8mulb_zmm_k1z_zmm_zmmm512", Code.EVEX_VGF2P8MULB_ZMM_K1Z_ZMM_ZMMM512); + map.put("Aesimc_xmm_xmmm128", Code.AESIMC_XMM_XMMM128); + map.put("VEX_Vaesimc_xmm_xmmm128", Code.VEX_VAESIMC_XMM_XMMM128); + map.put("Aesenc_xmm_xmmm128", Code.AESENC_XMM_XMMM128); + map.put("VEX_Vaesenc_xmm_xmm_xmmm128", Code.VEX_VAESENC_XMM_XMM_XMMM128); + map.put("VEX_Vaesenc_ymm_ymm_ymmm256", Code.VEX_VAESENC_YMM_YMM_YMMM256); + map.put("EVEX_Vaesenc_xmm_xmm_xmmm128", Code.EVEX_VAESENC_XMM_XMM_XMMM128); + map.put("EVEX_Vaesenc_ymm_ymm_ymmm256", Code.EVEX_VAESENC_YMM_YMM_YMMM256); + map.put("EVEX_Vaesenc_zmm_zmm_zmmm512", Code.EVEX_VAESENC_ZMM_ZMM_ZMMM512); + map.put("Aesenclast_xmm_xmmm128", Code.AESENCLAST_XMM_XMMM128); + map.put("VEX_Vaesenclast_xmm_xmm_xmmm128", Code.VEX_VAESENCLAST_XMM_XMM_XMMM128); + map.put("VEX_Vaesenclast_ymm_ymm_ymmm256", Code.VEX_VAESENCLAST_YMM_YMM_YMMM256); + map.put("EVEX_Vaesenclast_xmm_xmm_xmmm128", Code.EVEX_VAESENCLAST_XMM_XMM_XMMM128); + map.put("EVEX_Vaesenclast_ymm_ymm_ymmm256", Code.EVEX_VAESENCLAST_YMM_YMM_YMMM256); + map.put("EVEX_Vaesenclast_zmm_zmm_zmmm512", Code.EVEX_VAESENCLAST_ZMM_ZMM_ZMMM512); + map.put("Aesdec_xmm_xmmm128", Code.AESDEC_XMM_XMMM128); + map.put("VEX_Vaesdec_xmm_xmm_xmmm128", Code.VEX_VAESDEC_XMM_XMM_XMMM128); + map.put("VEX_Vaesdec_ymm_ymm_ymmm256", Code.VEX_VAESDEC_YMM_YMM_YMMM256); + map.put("EVEX_Vaesdec_xmm_xmm_xmmm128", Code.EVEX_VAESDEC_XMM_XMM_XMMM128); + map.put("EVEX_Vaesdec_ymm_ymm_ymmm256", Code.EVEX_VAESDEC_YMM_YMM_YMMM256); + map.put("EVEX_Vaesdec_zmm_zmm_zmmm512", Code.EVEX_VAESDEC_ZMM_ZMM_ZMMM512); + map.put("Aesdeclast_xmm_xmmm128", Code.AESDECLAST_XMM_XMMM128); + map.put("VEX_Vaesdeclast_xmm_xmm_xmmm128", Code.VEX_VAESDECLAST_XMM_XMM_XMMM128); + map.put("VEX_Vaesdeclast_ymm_ymm_ymmm256", Code.VEX_VAESDECLAST_YMM_YMM_YMMM256); + map.put("EVEX_Vaesdeclast_xmm_xmm_xmmm128", Code.EVEX_VAESDECLAST_XMM_XMM_XMMM128); + map.put("EVEX_Vaesdeclast_ymm_ymm_ymmm256", Code.EVEX_VAESDECLAST_YMM_YMM_YMMM256); + map.put("EVEX_Vaesdeclast_zmm_zmm_zmmm512", Code.EVEX_VAESDECLAST_ZMM_ZMM_ZMMM512); + map.put("Movbe_r16_m16", Code.MOVBE_R16_M16); + map.put("Movbe_r32_m32", Code.MOVBE_R32_M32); + map.put("Movbe_r64_m64", Code.MOVBE_R64_M64); + map.put("Crc32_r32_rm8", Code.CRC32_R32_RM8); + map.put("Crc32_r64_rm8", Code.CRC32_R64_RM8); + map.put("Movbe_m16_r16", Code.MOVBE_M16_R16); + map.put("Movbe_m32_r32", Code.MOVBE_M32_R32); + map.put("Movbe_m64_r64", Code.MOVBE_M64_R64); + map.put("Crc32_r32_rm16", Code.CRC32_R32_RM16); + map.put("Crc32_r32_rm32", Code.CRC32_R32_RM32); + map.put("Crc32_r64_rm64", Code.CRC32_R64_RM64); + map.put("VEX_Andn_r32_r32_rm32", Code.VEX_ANDN_R32_R32_RM32); + map.put("VEX_Andn_r64_r64_rm64", Code.VEX_ANDN_R64_R64_RM64); + map.put("VEX_Blsr_r32_rm32", Code.VEX_BLSR_R32_RM32); + map.put("VEX_Blsr_r64_rm64", Code.VEX_BLSR_R64_RM64); + map.put("VEX_Blsmsk_r32_rm32", Code.VEX_BLSMSK_R32_RM32); + map.put("VEX_Blsmsk_r64_rm64", Code.VEX_BLSMSK_R64_RM64); + map.put("VEX_Blsi_r32_rm32", Code.VEX_BLSI_R32_RM32); + map.put("VEX_Blsi_r64_rm64", Code.VEX_BLSI_R64_RM64); + map.put("VEX_Bzhi_r32_rm32_r32", Code.VEX_BZHI_R32_RM32_R32); + map.put("VEX_Bzhi_r64_rm64_r64", Code.VEX_BZHI_R64_RM64_R64); + map.put("Wrussd_m32_r32", Code.WRUSSD_M32_R32); + map.put("Wrussq_m64_r64", Code.WRUSSQ_M64_R64); + map.put("VEX_Pext_r32_r32_rm32", Code.VEX_PEXT_R32_R32_RM32); + map.put("VEX_Pext_r64_r64_rm64", Code.VEX_PEXT_R64_R64_RM64); + map.put("VEX_Pdep_r32_r32_rm32", Code.VEX_PDEP_R32_R32_RM32); + map.put("VEX_Pdep_r64_r64_rm64", Code.VEX_PDEP_R64_R64_RM64); + map.put("Wrssd_m32_r32", Code.WRSSD_M32_R32); + map.put("Wrssq_m64_r64", Code.WRSSQ_M64_R64); + map.put("Adcx_r32_rm32", Code.ADCX_R32_RM32); + map.put("Adcx_r64_rm64", Code.ADCX_R64_RM64); + map.put("Adox_r32_rm32", Code.ADOX_R32_RM32); + map.put("Adox_r64_rm64", Code.ADOX_R64_RM64); + map.put("VEX_Mulx_r32_r32_rm32", Code.VEX_MULX_R32_R32_RM32); + map.put("VEX_Mulx_r64_r64_rm64", Code.VEX_MULX_R64_R64_RM64); + map.put("VEX_Bextr_r32_rm32_r32", Code.VEX_BEXTR_R32_RM32_R32); + map.put("VEX_Bextr_r64_rm64_r64", Code.VEX_BEXTR_R64_RM64_R64); + map.put("VEX_Shlx_r32_rm32_r32", Code.VEX_SHLX_R32_RM32_R32); + map.put("VEX_Shlx_r64_rm64_r64", Code.VEX_SHLX_R64_RM64_R64); + map.put("VEX_Sarx_r32_rm32_r32", Code.VEX_SARX_R32_RM32_R32); + map.put("VEX_Sarx_r64_rm64_r64", Code.VEX_SARX_R64_RM64_R64); + map.put("VEX_Shrx_r32_rm32_r32", Code.VEX_SHRX_R32_RM32_R32); + map.put("VEX_Shrx_r64_rm64_r64", Code.VEX_SHRX_R64_RM64_R64); + map.put("Movdir64b_r16_m512", Code.MOVDIR64B_R16_M512); + map.put("Movdir64b_r32_m512", Code.MOVDIR64B_R32_M512); + map.put("Movdir64b_r64_m512", Code.MOVDIR64B_R64_M512); + map.put("Enqcmds_r16_m512", Code.ENQCMDS_R16_M512); + map.put("Enqcmds_r32_m512", Code.ENQCMDS_R32_M512); + map.put("Enqcmds_r64_m512", Code.ENQCMDS_R64_M512); + map.put("Enqcmd_r16_m512", Code.ENQCMD_R16_M512); + map.put("Enqcmd_r32_m512", Code.ENQCMD_R32_M512); + map.put("Enqcmd_r64_m512", Code.ENQCMD_R64_M512); + map.put("Movdiri_m32_r32", Code.MOVDIRI_M32_R32); + map.put("Movdiri_m64_r64", Code.MOVDIRI_M64_R64); + map.put("VEX_Vpermq_ymm_ymmm256_imm8", Code.VEX_VPERMQ_YMM_YMMM256_IMM8); + map.put("EVEX_Vpermq_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VPERMQ_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vpermq_zmm_k1z_zmmm512b64_imm8", Code.EVEX_VPERMQ_ZMM_K1Z_ZMMM512B64_IMM8); + map.put("VEX_Vpermpd_ymm_ymmm256_imm8", Code.VEX_VPERMPD_YMM_YMMM256_IMM8); + map.put("EVEX_Vpermpd_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VPERMPD_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vpermpd_zmm_k1z_zmmm512b64_imm8", Code.EVEX_VPERMPD_ZMM_K1Z_ZMMM512B64_IMM8); + map.put("VEX_Vpblendd_xmm_xmm_xmmm128_imm8", Code.VEX_VPBLENDD_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vpblendd_ymm_ymm_ymmm256_imm8", Code.VEX_VPBLENDD_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Valignd_xmm_k1z_xmm_xmmm128b32_imm8", Code.EVEX_VALIGND_XMM_K1Z_XMM_XMMM128B32_IMM8); + map.put("EVEX_Valignd_ymm_k1z_ymm_ymmm256b32_imm8", Code.EVEX_VALIGND_YMM_K1Z_YMM_YMMM256B32_IMM8); + map.put("EVEX_Valignd_zmm_k1z_zmm_zmmm512b32_imm8", Code.EVEX_VALIGND_ZMM_K1Z_ZMM_ZMMM512B32_IMM8); + map.put("EVEX_Valignq_xmm_k1z_xmm_xmmm128b64_imm8", Code.EVEX_VALIGNQ_XMM_K1Z_XMM_XMMM128B64_IMM8); + map.put("EVEX_Valignq_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VALIGNQ_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Valignq_zmm_k1z_zmm_zmmm512b64_imm8", Code.EVEX_VALIGNQ_ZMM_K1Z_ZMM_ZMMM512B64_IMM8); + map.put("VEX_Vpermilps_xmm_xmmm128_imm8", Code.VEX_VPERMILPS_XMM_XMMM128_IMM8); + map.put("VEX_Vpermilps_ymm_ymmm256_imm8", Code.VEX_VPERMILPS_YMM_YMMM256_IMM8); + map.put("EVEX_Vpermilps_xmm_k1z_xmmm128b32_imm8", Code.EVEX_VPERMILPS_XMM_K1Z_XMMM128B32_IMM8); + map.put("EVEX_Vpermilps_ymm_k1z_ymmm256b32_imm8", Code.EVEX_VPERMILPS_YMM_K1Z_YMMM256B32_IMM8); + map.put("EVEX_Vpermilps_zmm_k1z_zmmm512b32_imm8", Code.EVEX_VPERMILPS_ZMM_K1Z_ZMMM512B32_IMM8); + map.put("VEX_Vpermilpd_xmm_xmmm128_imm8", Code.VEX_VPERMILPD_XMM_XMMM128_IMM8); + map.put("VEX_Vpermilpd_ymm_ymmm256_imm8", Code.VEX_VPERMILPD_YMM_YMMM256_IMM8); + map.put("EVEX_Vpermilpd_xmm_k1z_xmmm128b64_imm8", Code.EVEX_VPERMILPD_XMM_K1Z_XMMM128B64_IMM8); + map.put("EVEX_Vpermilpd_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VPERMILPD_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vpermilpd_zmm_k1z_zmmm512b64_imm8", Code.EVEX_VPERMILPD_ZMM_K1Z_ZMMM512B64_IMM8); + map.put("VEX_Vperm2f128_ymm_ymm_ymmm256_imm8", Code.VEX_VPERM2F128_YMM_YMM_YMMM256_IMM8); + map.put("Roundps_xmm_xmmm128_imm8", Code.ROUNDPS_XMM_XMMM128_IMM8); + map.put("VEX_Vroundps_xmm_xmmm128_imm8", Code.VEX_VROUNDPS_XMM_XMMM128_IMM8); + map.put("VEX_Vroundps_ymm_ymmm256_imm8", Code.VEX_VROUNDPS_YMM_YMMM256_IMM8); + map.put("EVEX_Vrndscaleps_xmm_k1z_xmmm128b32_imm8", Code.EVEX_VRNDSCALEPS_XMM_K1Z_XMMM128B32_IMM8); + map.put("EVEX_Vrndscaleps_ymm_k1z_ymmm256b32_imm8", Code.EVEX_VRNDSCALEPS_YMM_K1Z_YMMM256B32_IMM8); + map.put("EVEX_Vrndscaleps_zmm_k1z_zmmm512b32_imm8_sae", Code.EVEX_VRNDSCALEPS_ZMM_K1Z_ZMMM512B32_IMM8_SAE); + map.put("Roundpd_xmm_xmmm128_imm8", Code.ROUNDPD_XMM_XMMM128_IMM8); + map.put("VEX_Vroundpd_xmm_xmmm128_imm8", Code.VEX_VROUNDPD_XMM_XMMM128_IMM8); + map.put("VEX_Vroundpd_ymm_ymmm256_imm8", Code.VEX_VROUNDPD_YMM_YMMM256_IMM8); + map.put("EVEX_Vrndscalepd_xmm_k1z_xmmm128b64_imm8", Code.EVEX_VRNDSCALEPD_XMM_K1Z_XMMM128B64_IMM8); + map.put("EVEX_Vrndscalepd_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VRNDSCALEPD_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vrndscalepd_zmm_k1z_zmmm512b64_imm8_sae", Code.EVEX_VRNDSCALEPD_ZMM_K1Z_ZMMM512B64_IMM8_SAE); + map.put("Roundss_xmm_xmmm32_imm8", Code.ROUNDSS_XMM_XMMM32_IMM8); + map.put("VEX_Vroundss_xmm_xmm_xmmm32_imm8", Code.VEX_VROUNDSS_XMM_XMM_XMMM32_IMM8); + map.put("EVEX_Vrndscaless_xmm_k1z_xmm_xmmm32_imm8_sae", Code.EVEX_VRNDSCALESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE); + map.put("Roundsd_xmm_xmmm64_imm8", Code.ROUNDSD_XMM_XMMM64_IMM8); + map.put("VEX_Vroundsd_xmm_xmm_xmmm64_imm8", Code.VEX_VROUNDSD_XMM_XMM_XMMM64_IMM8); + map.put("EVEX_Vrndscalesd_xmm_k1z_xmm_xmmm64_imm8_sae", Code.EVEX_VRNDSCALESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE); + map.put("Blendps_xmm_xmmm128_imm8", Code.BLENDPS_XMM_XMMM128_IMM8); + map.put("VEX_Vblendps_xmm_xmm_xmmm128_imm8", Code.VEX_VBLENDPS_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vblendps_ymm_ymm_ymmm256_imm8", Code.VEX_VBLENDPS_YMM_YMM_YMMM256_IMM8); + map.put("Blendpd_xmm_xmmm128_imm8", Code.BLENDPD_XMM_XMMM128_IMM8); + map.put("VEX_Vblendpd_xmm_xmm_xmmm128_imm8", Code.VEX_VBLENDPD_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vblendpd_ymm_ymm_ymmm256_imm8", Code.VEX_VBLENDPD_YMM_YMM_YMMM256_IMM8); + map.put("Pblendw_xmm_xmmm128_imm8", Code.PBLENDW_XMM_XMMM128_IMM8); + map.put("VEX_Vpblendw_xmm_xmm_xmmm128_imm8", Code.VEX_VPBLENDW_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vpblendw_ymm_ymm_ymmm256_imm8", Code.VEX_VPBLENDW_YMM_YMM_YMMM256_IMM8); + map.put("Palignr_mm_mmm64_imm8", Code.PALIGNR_MM_MMM64_IMM8); + map.put("Palignr_xmm_xmmm128_imm8", Code.PALIGNR_XMM_XMMM128_IMM8); + map.put("VEX_Vpalignr_xmm_xmm_xmmm128_imm8", Code.VEX_VPALIGNR_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vpalignr_ymm_ymm_ymmm256_imm8", Code.VEX_VPALIGNR_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Vpalignr_xmm_k1z_xmm_xmmm128_imm8", Code.EVEX_VPALIGNR_XMM_K1Z_XMM_XMMM128_IMM8); + map.put("EVEX_Vpalignr_ymm_k1z_ymm_ymmm256_imm8", Code.EVEX_VPALIGNR_YMM_K1Z_YMM_YMMM256_IMM8); + map.put("EVEX_Vpalignr_zmm_k1z_zmm_zmmm512_imm8", Code.EVEX_VPALIGNR_ZMM_K1Z_ZMM_ZMMM512_IMM8); + map.put("Pextrb_r32m8_xmm_imm8", Code.PEXTRB_R32M8_XMM_IMM8); + map.put("Pextrb_r64m8_xmm_imm8", Code.PEXTRB_R64M8_XMM_IMM8); + map.put("VEX_Vpextrb_r32m8_xmm_imm8", Code.VEX_VPEXTRB_R32M8_XMM_IMM8); + map.put("VEX_Vpextrb_r64m8_xmm_imm8", Code.VEX_VPEXTRB_R64M8_XMM_IMM8); + map.put("EVEX_Vpextrb_r32m8_xmm_imm8", Code.EVEX_VPEXTRB_R32M8_XMM_IMM8); + map.put("EVEX_Vpextrb_r64m8_xmm_imm8", Code.EVEX_VPEXTRB_R64M8_XMM_IMM8); + map.put("Pextrw_r32m16_xmm_imm8", Code.PEXTRW_R32M16_XMM_IMM8); + map.put("Pextrw_r64m16_xmm_imm8", Code.PEXTRW_R64M16_XMM_IMM8); + map.put("VEX_Vpextrw_r32m16_xmm_imm8", Code.VEX_VPEXTRW_R32M16_XMM_IMM8); + map.put("VEX_Vpextrw_r64m16_xmm_imm8", Code.VEX_VPEXTRW_R64M16_XMM_IMM8); + map.put("EVEX_Vpextrw_r32m16_xmm_imm8", Code.EVEX_VPEXTRW_R32M16_XMM_IMM8); + map.put("EVEX_Vpextrw_r64m16_xmm_imm8", Code.EVEX_VPEXTRW_R64M16_XMM_IMM8); + map.put("Pextrd_rm32_xmm_imm8", Code.PEXTRD_RM32_XMM_IMM8); + map.put("Pextrq_rm64_xmm_imm8", Code.PEXTRQ_RM64_XMM_IMM8); + map.put("VEX_Vpextrd_rm32_xmm_imm8", Code.VEX_VPEXTRD_RM32_XMM_IMM8); + map.put("VEX_Vpextrq_rm64_xmm_imm8", Code.VEX_VPEXTRQ_RM64_XMM_IMM8); + map.put("EVEX_Vpextrd_rm32_xmm_imm8", Code.EVEX_VPEXTRD_RM32_XMM_IMM8); + map.put("EVEX_Vpextrq_rm64_xmm_imm8", Code.EVEX_VPEXTRQ_RM64_XMM_IMM8); + map.put("Extractps_rm32_xmm_imm8", Code.EXTRACTPS_RM32_XMM_IMM8); + map.put("Extractps_r64m32_xmm_imm8", Code.EXTRACTPS_R64M32_XMM_IMM8); + map.put("VEX_Vextractps_rm32_xmm_imm8", Code.VEX_VEXTRACTPS_RM32_XMM_IMM8); + map.put("VEX_Vextractps_r64m32_xmm_imm8", Code.VEX_VEXTRACTPS_R64M32_XMM_IMM8); + map.put("EVEX_Vextractps_rm32_xmm_imm8", Code.EVEX_VEXTRACTPS_RM32_XMM_IMM8); + map.put("EVEX_Vextractps_r64m32_xmm_imm8", Code.EVEX_VEXTRACTPS_R64M32_XMM_IMM8); + map.put("VEX_Vinsertf128_ymm_ymm_xmmm128_imm8", Code.VEX_VINSERTF128_YMM_YMM_XMMM128_IMM8); + map.put("EVEX_Vinsertf32x4_ymm_k1z_ymm_xmmm128_imm8", Code.EVEX_VINSERTF32X4_YMM_K1Z_YMM_XMMM128_IMM8); + map.put("EVEX_Vinsertf32x4_zmm_k1z_zmm_xmmm128_imm8", Code.EVEX_VINSERTF32X4_ZMM_K1Z_ZMM_XMMM128_IMM8); + map.put("EVEX_Vinsertf64x2_ymm_k1z_ymm_xmmm128_imm8", Code.EVEX_VINSERTF64X2_YMM_K1Z_YMM_XMMM128_IMM8); + map.put("EVEX_Vinsertf64x2_zmm_k1z_zmm_xmmm128_imm8", Code.EVEX_VINSERTF64X2_ZMM_K1Z_ZMM_XMMM128_IMM8); + map.put("VEX_Vextractf128_xmmm128_ymm_imm8", Code.VEX_VEXTRACTF128_XMMM128_YMM_IMM8); + map.put("EVEX_Vextractf32x4_xmmm128_k1z_ymm_imm8", Code.EVEX_VEXTRACTF32X4_XMMM128_K1Z_YMM_IMM8); + map.put("EVEX_Vextractf32x4_xmmm128_k1z_zmm_imm8", Code.EVEX_VEXTRACTF32X4_XMMM128_K1Z_ZMM_IMM8); + map.put("EVEX_Vextractf64x2_xmmm128_k1z_ymm_imm8", Code.EVEX_VEXTRACTF64X2_XMMM128_K1Z_YMM_IMM8); + map.put("EVEX_Vextractf64x2_xmmm128_k1z_zmm_imm8", Code.EVEX_VEXTRACTF64X2_XMMM128_K1Z_ZMM_IMM8); + map.put("EVEX_Vinsertf32x8_zmm_k1z_zmm_ymmm256_imm8", Code.EVEX_VINSERTF32X8_ZMM_K1Z_ZMM_YMMM256_IMM8); + map.put("EVEX_Vinsertf64x4_zmm_k1z_zmm_ymmm256_imm8", Code.EVEX_VINSERTF64X4_ZMM_K1Z_ZMM_YMMM256_IMM8); + map.put("EVEX_Vextractf32x8_ymmm256_k1z_zmm_imm8", Code.EVEX_VEXTRACTF32X8_YMMM256_K1Z_ZMM_IMM8); + map.put("EVEX_Vextractf64x4_ymmm256_k1z_zmm_imm8", Code.EVEX_VEXTRACTF64X4_YMMM256_K1Z_ZMM_IMM8); + map.put("VEX_Vcvtps2ph_xmmm64_xmm_imm8", Code.VEX_VCVTPS2PH_XMMM64_XMM_IMM8); + map.put("VEX_Vcvtps2ph_xmmm128_ymm_imm8", Code.VEX_VCVTPS2PH_XMMM128_YMM_IMM8); + map.put("EVEX_Vcvtps2ph_xmmm64_k1z_xmm_imm8", Code.EVEX_VCVTPS2PH_XMMM64_K1Z_XMM_IMM8); + map.put("EVEX_Vcvtps2ph_xmmm128_k1z_ymm_imm8", Code.EVEX_VCVTPS2PH_XMMM128_K1Z_YMM_IMM8); + map.put("EVEX_Vcvtps2ph_ymmm256_k1z_zmm_imm8_sae", Code.EVEX_VCVTPS2PH_YMMM256_K1Z_ZMM_IMM8_SAE); + map.put("EVEX_Vpcmpud_kr_k1_xmm_xmmm128b32_imm8", Code.EVEX_VPCMPUD_KR_K1_XMM_XMMM128B32_IMM8); + map.put("EVEX_Vpcmpud_kr_k1_ymm_ymmm256b32_imm8", Code.EVEX_VPCMPUD_KR_K1_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vpcmpud_kr_k1_zmm_zmmm512b32_imm8", Code.EVEX_VPCMPUD_KR_K1_ZMM_ZMMM512B32_IMM8); + map.put("EVEX_Vpcmpuq_kr_k1_xmm_xmmm128b64_imm8", Code.EVEX_VPCMPUQ_KR_K1_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vpcmpuq_kr_k1_ymm_ymmm256b64_imm8", Code.EVEX_VPCMPUQ_KR_K1_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vpcmpuq_kr_k1_zmm_zmmm512b64_imm8", Code.EVEX_VPCMPUQ_KR_K1_ZMM_ZMMM512B64_IMM8); + map.put("EVEX_Vpcmpd_kr_k1_xmm_xmmm128b32_imm8", Code.EVEX_VPCMPD_KR_K1_XMM_XMMM128B32_IMM8); + map.put("EVEX_Vpcmpd_kr_k1_ymm_ymmm256b32_imm8", Code.EVEX_VPCMPD_KR_K1_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vpcmpd_kr_k1_zmm_zmmm512b32_imm8", Code.EVEX_VPCMPD_KR_K1_ZMM_ZMMM512B32_IMM8); + map.put("EVEX_Vpcmpq_kr_k1_xmm_xmmm128b64_imm8", Code.EVEX_VPCMPQ_KR_K1_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vpcmpq_kr_k1_ymm_ymmm256b64_imm8", Code.EVEX_VPCMPQ_KR_K1_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vpcmpq_kr_k1_zmm_zmmm512b64_imm8", Code.EVEX_VPCMPQ_KR_K1_ZMM_ZMMM512B64_IMM8); + map.put("Pinsrb_xmm_r32m8_imm8", Code.PINSRB_XMM_R32M8_IMM8); + map.put("Pinsrb_xmm_r64m8_imm8", Code.PINSRB_XMM_R64M8_IMM8); + map.put("VEX_Vpinsrb_xmm_xmm_r32m8_imm8", Code.VEX_VPINSRB_XMM_XMM_R32M8_IMM8); + map.put("VEX_Vpinsrb_xmm_xmm_r64m8_imm8", Code.VEX_VPINSRB_XMM_XMM_R64M8_IMM8); + map.put("EVEX_Vpinsrb_xmm_xmm_r32m8_imm8", Code.EVEX_VPINSRB_XMM_XMM_R32M8_IMM8); + map.put("EVEX_Vpinsrb_xmm_xmm_r64m8_imm8", Code.EVEX_VPINSRB_XMM_XMM_R64M8_IMM8); + map.put("Insertps_xmm_xmmm32_imm8", Code.INSERTPS_XMM_XMMM32_IMM8); + map.put("VEX_Vinsertps_xmm_xmm_xmmm32_imm8", Code.VEX_VINSERTPS_XMM_XMM_XMMM32_IMM8); + map.put("EVEX_Vinsertps_xmm_xmm_xmmm32_imm8", Code.EVEX_VINSERTPS_XMM_XMM_XMMM32_IMM8); + map.put("Pinsrd_xmm_rm32_imm8", Code.PINSRD_XMM_RM32_IMM8); + map.put("Pinsrq_xmm_rm64_imm8", Code.PINSRQ_XMM_RM64_IMM8); + map.put("VEX_Vpinsrd_xmm_xmm_rm32_imm8", Code.VEX_VPINSRD_XMM_XMM_RM32_IMM8); + map.put("VEX_Vpinsrq_xmm_xmm_rm64_imm8", Code.VEX_VPINSRQ_XMM_XMM_RM64_IMM8); + map.put("EVEX_Vpinsrd_xmm_xmm_rm32_imm8", Code.EVEX_VPINSRD_XMM_XMM_RM32_IMM8); + map.put("EVEX_Vpinsrq_xmm_xmm_rm64_imm8", Code.EVEX_VPINSRQ_XMM_XMM_RM64_IMM8); + map.put("EVEX_Vshuff32x4_ymm_k1z_ymm_ymmm256b32_imm8", Code.EVEX_VSHUFF32X4_YMM_K1Z_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vshuff32x4_zmm_k1z_zmm_zmmm512b32_imm8", Code.EVEX_VSHUFF32X4_ZMM_K1Z_ZMM_ZMMM512B32_IMM8); + map.put("EVEX_Vshuff64x2_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VSHUFF64X2_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vshuff64x2_zmm_k1z_zmm_zmmm512b64_imm8", Code.EVEX_VSHUFF64X2_ZMM_K1Z_ZMM_ZMMM512B64_IMM8); + map.put("EVEX_Vpternlogd_xmm_k1z_xmm_xmmm128b32_imm8", Code.EVEX_VPTERNLOGD_XMM_K1Z_XMM_XMMM128B32_IMM8); + map.put("EVEX_Vpternlogd_ymm_k1z_ymm_ymmm256b32_imm8", Code.EVEX_VPTERNLOGD_YMM_K1Z_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vpternlogd_zmm_k1z_zmm_zmmm512b32_imm8", Code.EVEX_VPTERNLOGD_ZMM_K1Z_ZMM_ZMMM512B32_IMM8); + map.put("EVEX_Vpternlogq_xmm_k1z_xmm_xmmm128b64_imm8", Code.EVEX_VPTERNLOGQ_XMM_K1Z_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vpternlogq_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VPTERNLOGQ_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vpternlogq_zmm_k1z_zmm_zmmm512b64_imm8", Code.EVEX_VPTERNLOGQ_ZMM_K1Z_ZMM_ZMMM512B64_IMM8); + map.put("EVEX_Vgetmantps_xmm_k1z_xmmm128b32_imm8", Code.EVEX_VGETMANTPS_XMM_K1Z_XMMM128B32_IMM8); + map.put("EVEX_Vgetmantps_ymm_k1z_ymmm256b32_imm8", Code.EVEX_VGETMANTPS_YMM_K1Z_YMMM256B32_IMM8); + map.put("EVEX_Vgetmantps_zmm_k1z_zmmm512b32_imm8_sae", Code.EVEX_VGETMANTPS_ZMM_K1Z_ZMMM512B32_IMM8_SAE); + map.put("EVEX_Vgetmantpd_xmm_k1z_xmmm128b64_imm8", Code.EVEX_VGETMANTPD_XMM_K1Z_XMMM128B64_IMM8); + map.put("EVEX_Vgetmantpd_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VGETMANTPD_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vgetmantpd_zmm_k1z_zmmm512b64_imm8_sae", Code.EVEX_VGETMANTPD_ZMM_K1Z_ZMMM512B64_IMM8_SAE); + map.put("EVEX_Vgetmantss_xmm_k1z_xmm_xmmm32_imm8_sae", Code.EVEX_VGETMANTSS_XMM_K1Z_XMM_XMMM32_IMM8_SAE); + map.put("EVEX_Vgetmantsd_xmm_k1z_xmm_xmmm64_imm8_sae", Code.EVEX_VGETMANTSD_XMM_K1Z_XMM_XMMM64_IMM8_SAE); + map.put("VEX_Kshiftrb_kr_kr_imm8", Code.VEX_KSHIFTRB_KR_KR_IMM8); + map.put("VEX_Kshiftrw_kr_kr_imm8", Code.VEX_KSHIFTRW_KR_KR_IMM8); + map.put("VEX_Kshiftrd_kr_kr_imm8", Code.VEX_KSHIFTRD_KR_KR_IMM8); + map.put("VEX_Kshiftrq_kr_kr_imm8", Code.VEX_KSHIFTRQ_KR_KR_IMM8); + map.put("VEX_Kshiftlb_kr_kr_imm8", Code.VEX_KSHIFTLB_KR_KR_IMM8); + map.put("VEX_Kshiftlw_kr_kr_imm8", Code.VEX_KSHIFTLW_KR_KR_IMM8); + map.put("VEX_Kshiftld_kr_kr_imm8", Code.VEX_KSHIFTLD_KR_KR_IMM8); + map.put("VEX_Kshiftlq_kr_kr_imm8", Code.VEX_KSHIFTLQ_KR_KR_IMM8); + map.put("VEX_Vinserti128_ymm_ymm_xmmm128_imm8", Code.VEX_VINSERTI128_YMM_YMM_XMMM128_IMM8); + map.put("EVEX_Vinserti32x4_ymm_k1z_ymm_xmmm128_imm8", Code.EVEX_VINSERTI32X4_YMM_K1Z_YMM_XMMM128_IMM8); + map.put("EVEX_Vinserti32x4_zmm_k1z_zmm_xmmm128_imm8", Code.EVEX_VINSERTI32X4_ZMM_K1Z_ZMM_XMMM128_IMM8); + map.put("EVEX_Vinserti64x2_ymm_k1z_ymm_xmmm128_imm8", Code.EVEX_VINSERTI64X2_YMM_K1Z_YMM_XMMM128_IMM8); + map.put("EVEX_Vinserti64x2_zmm_k1z_zmm_xmmm128_imm8", Code.EVEX_VINSERTI64X2_ZMM_K1Z_ZMM_XMMM128_IMM8); + map.put("VEX_Vextracti128_xmmm128_ymm_imm8", Code.VEX_VEXTRACTI128_XMMM128_YMM_IMM8); + map.put("EVEX_Vextracti32x4_xmmm128_k1z_ymm_imm8", Code.EVEX_VEXTRACTI32X4_XMMM128_K1Z_YMM_IMM8); + map.put("EVEX_Vextracti32x4_xmmm128_k1z_zmm_imm8", Code.EVEX_VEXTRACTI32X4_XMMM128_K1Z_ZMM_IMM8); + map.put("EVEX_Vextracti64x2_xmmm128_k1z_ymm_imm8", Code.EVEX_VEXTRACTI64X2_XMMM128_K1Z_YMM_IMM8); + map.put("EVEX_Vextracti64x2_xmmm128_k1z_zmm_imm8", Code.EVEX_VEXTRACTI64X2_XMMM128_K1Z_ZMM_IMM8); + map.put("EVEX_Vinserti32x8_zmm_k1z_zmm_ymmm256_imm8", Code.EVEX_VINSERTI32X8_ZMM_K1Z_ZMM_YMMM256_IMM8); + map.put("EVEX_Vinserti64x4_zmm_k1z_zmm_ymmm256_imm8", Code.EVEX_VINSERTI64X4_ZMM_K1Z_ZMM_YMMM256_IMM8); + map.put("EVEX_Vextracti32x8_ymmm256_k1z_zmm_imm8", Code.EVEX_VEXTRACTI32X8_YMMM256_K1Z_ZMM_IMM8); + map.put("EVEX_Vextracti64x4_ymmm256_k1z_zmm_imm8", Code.EVEX_VEXTRACTI64X4_YMMM256_K1Z_ZMM_IMM8); + map.put("EVEX_Vpcmpub_kr_k1_xmm_xmmm128_imm8", Code.EVEX_VPCMPUB_KR_K1_XMM_XMMM128_IMM8); + map.put("EVEX_Vpcmpub_kr_k1_ymm_ymmm256_imm8", Code.EVEX_VPCMPUB_KR_K1_YMM_YMMM256_IMM8); + map.put("EVEX_Vpcmpub_kr_k1_zmm_zmmm512_imm8", Code.EVEX_VPCMPUB_KR_K1_ZMM_ZMMM512_IMM8); + map.put("EVEX_Vpcmpuw_kr_k1_xmm_xmmm128_imm8", Code.EVEX_VPCMPUW_KR_K1_XMM_XMMM128_IMM8); + map.put("EVEX_Vpcmpuw_kr_k1_ymm_ymmm256_imm8", Code.EVEX_VPCMPUW_KR_K1_YMM_YMMM256_IMM8); + map.put("EVEX_Vpcmpuw_kr_k1_zmm_zmmm512_imm8", Code.EVEX_VPCMPUW_KR_K1_ZMM_ZMMM512_IMM8); + map.put("EVEX_Vpcmpb_kr_k1_xmm_xmmm128_imm8", Code.EVEX_VPCMPB_KR_K1_XMM_XMMM128_IMM8); + map.put("EVEX_Vpcmpb_kr_k1_ymm_ymmm256_imm8", Code.EVEX_VPCMPB_KR_K1_YMM_YMMM256_IMM8); + map.put("EVEX_Vpcmpb_kr_k1_zmm_zmmm512_imm8", Code.EVEX_VPCMPB_KR_K1_ZMM_ZMMM512_IMM8); + map.put("EVEX_Vpcmpw_kr_k1_xmm_xmmm128_imm8", Code.EVEX_VPCMPW_KR_K1_XMM_XMMM128_IMM8); + map.put("EVEX_Vpcmpw_kr_k1_ymm_ymmm256_imm8", Code.EVEX_VPCMPW_KR_K1_YMM_YMMM256_IMM8); + map.put("EVEX_Vpcmpw_kr_k1_zmm_zmmm512_imm8", Code.EVEX_VPCMPW_KR_K1_ZMM_ZMMM512_IMM8); + map.put("Dpps_xmm_xmmm128_imm8", Code.DPPS_XMM_XMMM128_IMM8); + map.put("VEX_Vdpps_xmm_xmm_xmmm128_imm8", Code.VEX_VDPPS_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vdpps_ymm_ymm_ymmm256_imm8", Code.VEX_VDPPS_YMM_YMM_YMMM256_IMM8); + map.put("Dppd_xmm_xmmm128_imm8", Code.DPPD_XMM_XMMM128_IMM8); + map.put("VEX_Vdppd_xmm_xmm_xmmm128_imm8", Code.VEX_VDPPD_XMM_XMM_XMMM128_IMM8); + map.put("Mpsadbw_xmm_xmmm128_imm8", Code.MPSADBW_XMM_XMMM128_IMM8); + map.put("VEX_Vmpsadbw_xmm_xmm_xmmm128_imm8", Code.VEX_VMPSADBW_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vmpsadbw_ymm_ymm_ymmm256_imm8", Code.VEX_VMPSADBW_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Vdbpsadbw_xmm_k1z_xmm_xmmm128_imm8", Code.EVEX_VDBPSADBW_XMM_K1Z_XMM_XMMM128_IMM8); + map.put("EVEX_Vdbpsadbw_ymm_k1z_ymm_ymmm256_imm8", Code.EVEX_VDBPSADBW_YMM_K1Z_YMM_YMMM256_IMM8); + map.put("EVEX_Vdbpsadbw_zmm_k1z_zmm_zmmm512_imm8", Code.EVEX_VDBPSADBW_ZMM_K1Z_ZMM_ZMMM512_IMM8); + map.put("EVEX_Vshufi32x4_ymm_k1z_ymm_ymmm256b32_imm8", Code.EVEX_VSHUFI32X4_YMM_K1Z_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vshufi32x4_zmm_k1z_zmm_zmmm512b32_imm8", Code.EVEX_VSHUFI32X4_ZMM_K1Z_ZMM_ZMMM512B32_IMM8); + map.put("EVEX_Vshufi64x2_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VSHUFI64X2_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vshufi64x2_zmm_k1z_zmm_zmmm512b64_imm8", Code.EVEX_VSHUFI64X2_ZMM_K1Z_ZMM_ZMMM512B64_IMM8); + map.put("Pclmulqdq_xmm_xmmm128_imm8", Code.PCLMULQDQ_XMM_XMMM128_IMM8); + map.put("VEX_Vpclmulqdq_xmm_xmm_xmmm128_imm8", Code.VEX_VPCLMULQDQ_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vpclmulqdq_ymm_ymm_ymmm256_imm8", Code.VEX_VPCLMULQDQ_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Vpclmulqdq_xmm_xmm_xmmm128_imm8", Code.EVEX_VPCLMULQDQ_XMM_XMM_XMMM128_IMM8); + map.put("EVEX_Vpclmulqdq_ymm_ymm_ymmm256_imm8", Code.EVEX_VPCLMULQDQ_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Vpclmulqdq_zmm_zmm_zmmm512_imm8", Code.EVEX_VPCLMULQDQ_ZMM_ZMM_ZMMM512_IMM8); + map.put("VEX_Vperm2i128_ymm_ymm_ymmm256_imm8", Code.VEX_VPERM2I128_YMM_YMM_YMMM256_IMM8); + map.put("VEX_Vpermil2ps_xmm_xmm_xmmm128_xmm_imm4", Code.VEX_VPERMIL2PS_XMM_XMM_XMMM128_XMM_IMM4); + map.put("VEX_Vpermil2ps_ymm_ymm_ymmm256_ymm_imm4", Code.VEX_VPERMIL2PS_YMM_YMM_YMMM256_YMM_IMM4); + map.put("VEX_Vpermil2ps_xmm_xmm_xmm_xmmm128_imm4", Code.VEX_VPERMIL2PS_XMM_XMM_XMM_XMMM128_IMM4); + map.put("VEX_Vpermil2ps_ymm_ymm_ymm_ymmm256_imm4", Code.VEX_VPERMIL2PS_YMM_YMM_YMM_YMMM256_IMM4); + map.put("VEX_Vpermil2pd_xmm_xmm_xmmm128_xmm_imm4", Code.VEX_VPERMIL2PD_XMM_XMM_XMMM128_XMM_IMM4); + map.put("VEX_Vpermil2pd_ymm_ymm_ymmm256_ymm_imm4", Code.VEX_VPERMIL2PD_YMM_YMM_YMMM256_YMM_IMM4); + map.put("VEX_Vpermil2pd_xmm_xmm_xmm_xmmm128_imm4", Code.VEX_VPERMIL2PD_XMM_XMM_XMM_XMMM128_IMM4); + map.put("VEX_Vpermil2pd_ymm_ymm_ymm_ymmm256_imm4", Code.VEX_VPERMIL2PD_YMM_YMM_YMM_YMMM256_IMM4); + map.put("VEX_Vblendvps_xmm_xmm_xmmm128_xmm", Code.VEX_VBLENDVPS_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vblendvps_ymm_ymm_ymmm256_ymm", Code.VEX_VBLENDVPS_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vblendvpd_xmm_xmm_xmmm128_xmm", Code.VEX_VBLENDVPD_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vblendvpd_ymm_ymm_ymmm256_ymm", Code.VEX_VBLENDVPD_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vpblendvb_xmm_xmm_xmmm128_xmm", Code.VEX_VPBLENDVB_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vpblendvb_ymm_ymm_ymmm256_ymm", Code.VEX_VPBLENDVB_YMM_YMM_YMMM256_YMM); + map.put("EVEX_Vrangeps_xmm_k1z_xmm_xmmm128b32_imm8", Code.EVEX_VRANGEPS_XMM_K1Z_XMM_XMMM128B32_IMM8); + map.put("EVEX_Vrangeps_ymm_k1z_ymm_ymmm256b32_imm8", Code.EVEX_VRANGEPS_YMM_K1Z_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vrangeps_zmm_k1z_zmm_zmmm512b32_imm8_sae", Code.EVEX_VRANGEPS_ZMM_K1Z_ZMM_ZMMM512B32_IMM8_SAE); + map.put("EVEX_Vrangepd_xmm_k1z_xmm_xmmm128b64_imm8", Code.EVEX_VRANGEPD_XMM_K1Z_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vrangepd_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VRANGEPD_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vrangepd_zmm_k1z_zmm_zmmm512b64_imm8_sae", Code.EVEX_VRANGEPD_ZMM_K1Z_ZMM_ZMMM512B64_IMM8_SAE); + map.put("EVEX_Vrangess_xmm_k1z_xmm_xmmm32_imm8_sae", Code.EVEX_VRANGESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE); + map.put("EVEX_Vrangesd_xmm_k1z_xmm_xmmm64_imm8_sae", Code.EVEX_VRANGESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE); + map.put("EVEX_Vfixupimmps_xmm_k1z_xmm_xmmm128b32_imm8", Code.EVEX_VFIXUPIMMPS_XMM_K1Z_XMM_XMMM128B32_IMM8); + map.put("EVEX_Vfixupimmps_ymm_k1z_ymm_ymmm256b32_imm8", Code.EVEX_VFIXUPIMMPS_YMM_K1Z_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vfixupimmps_zmm_k1z_zmm_zmmm512b32_imm8_sae", Code.EVEX_VFIXUPIMMPS_ZMM_K1Z_ZMM_ZMMM512B32_IMM8_SAE); + map.put("EVEX_Vfixupimmpd_xmm_k1z_xmm_xmmm128b64_imm8", Code.EVEX_VFIXUPIMMPD_XMM_K1Z_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vfixupimmpd_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VFIXUPIMMPD_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vfixupimmpd_zmm_k1z_zmm_zmmm512b64_imm8_sae", Code.EVEX_VFIXUPIMMPD_ZMM_K1Z_ZMM_ZMMM512B64_IMM8_SAE); + map.put("EVEX_Vfixupimmss_xmm_k1z_xmm_xmmm32_imm8_sae", Code.EVEX_VFIXUPIMMSS_XMM_K1Z_XMM_XMMM32_IMM8_SAE); + map.put("EVEX_Vfixupimmsd_xmm_k1z_xmm_xmmm64_imm8_sae", Code.EVEX_VFIXUPIMMSD_XMM_K1Z_XMM_XMMM64_IMM8_SAE); + map.put("EVEX_Vreduceps_xmm_k1z_xmmm128b32_imm8", Code.EVEX_VREDUCEPS_XMM_K1Z_XMMM128B32_IMM8); + map.put("EVEX_Vreduceps_ymm_k1z_ymmm256b32_imm8", Code.EVEX_VREDUCEPS_YMM_K1Z_YMMM256B32_IMM8); + map.put("EVEX_Vreduceps_zmm_k1z_zmmm512b32_imm8_sae", Code.EVEX_VREDUCEPS_ZMM_K1Z_ZMMM512B32_IMM8_SAE); + map.put("EVEX_Vreducepd_xmm_k1z_xmmm128b64_imm8", Code.EVEX_VREDUCEPD_XMM_K1Z_XMMM128B64_IMM8); + map.put("EVEX_Vreducepd_ymm_k1z_ymmm256b64_imm8", Code.EVEX_VREDUCEPD_YMM_K1Z_YMMM256B64_IMM8); + map.put("EVEX_Vreducepd_zmm_k1z_zmmm512b64_imm8_sae", Code.EVEX_VREDUCEPD_ZMM_K1Z_ZMMM512B64_IMM8_SAE); + map.put("EVEX_Vreducess_xmm_k1z_xmm_xmmm32_imm8_sae", Code.EVEX_VREDUCESS_XMM_K1Z_XMM_XMMM32_IMM8_SAE); + map.put("EVEX_Vreducesd_xmm_k1z_xmm_xmmm64_imm8_sae", Code.EVEX_VREDUCESD_XMM_K1Z_XMM_XMMM64_IMM8_SAE); + map.put("VEX_Vfmaddsubps_xmm_xmm_xmmm128_xmm", Code.VEX_VFMADDSUBPS_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfmaddsubps_ymm_ymm_ymmm256_ymm", Code.VEX_VFMADDSUBPS_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfmaddsubps_xmm_xmm_xmm_xmmm128", Code.VEX_VFMADDSUBPS_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfmaddsubps_ymm_ymm_ymm_ymmm256", Code.VEX_VFMADDSUBPS_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfmaddsubpd_xmm_xmm_xmmm128_xmm", Code.VEX_VFMADDSUBPD_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfmaddsubpd_ymm_ymm_ymmm256_ymm", Code.VEX_VFMADDSUBPD_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfmaddsubpd_xmm_xmm_xmm_xmmm128", Code.VEX_VFMADDSUBPD_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfmaddsubpd_ymm_ymm_ymm_ymmm256", Code.VEX_VFMADDSUBPD_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfmsubaddps_xmm_xmm_xmmm128_xmm", Code.VEX_VFMSUBADDPS_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfmsubaddps_ymm_ymm_ymmm256_ymm", Code.VEX_VFMSUBADDPS_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfmsubaddps_xmm_xmm_xmm_xmmm128", Code.VEX_VFMSUBADDPS_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfmsubaddps_ymm_ymm_ymm_ymmm256", Code.VEX_VFMSUBADDPS_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfmsubaddpd_xmm_xmm_xmmm128_xmm", Code.VEX_VFMSUBADDPD_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfmsubaddpd_ymm_ymm_ymmm256_ymm", Code.VEX_VFMSUBADDPD_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfmsubaddpd_xmm_xmm_xmm_xmmm128", Code.VEX_VFMSUBADDPD_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfmsubaddpd_ymm_ymm_ymm_ymmm256", Code.VEX_VFMSUBADDPD_YMM_YMM_YMM_YMMM256); + map.put("Pcmpestrm_xmm_xmmm128_imm8", Code.PCMPESTRM_XMM_XMMM128_IMM8); + map.put("Pcmpestrm64_xmm_xmmm128_imm8", Code.PCMPESTRM64_XMM_XMMM128_IMM8); + map.put("VEX_Vpcmpestrm_xmm_xmmm128_imm8", Code.VEX_VPCMPESTRM_XMM_XMMM128_IMM8); + map.put("VEX_Vpcmpestrm64_xmm_xmmm128_imm8", Code.VEX_VPCMPESTRM64_XMM_XMMM128_IMM8); + map.put("Pcmpestri_xmm_xmmm128_imm8", Code.PCMPESTRI_XMM_XMMM128_IMM8); + map.put("Pcmpestri64_xmm_xmmm128_imm8", Code.PCMPESTRI64_XMM_XMMM128_IMM8); + map.put("VEX_Vpcmpestri_xmm_xmmm128_imm8", Code.VEX_VPCMPESTRI_XMM_XMMM128_IMM8); + map.put("VEX_Vpcmpestri64_xmm_xmmm128_imm8", Code.VEX_VPCMPESTRI64_XMM_XMMM128_IMM8); + map.put("Pcmpistrm_xmm_xmmm128_imm8", Code.PCMPISTRM_XMM_XMMM128_IMM8); + map.put("VEX_Vpcmpistrm_xmm_xmmm128_imm8", Code.VEX_VPCMPISTRM_XMM_XMMM128_IMM8); + map.put("Pcmpistri_xmm_xmmm128_imm8", Code.PCMPISTRI_XMM_XMMM128_IMM8); + map.put("VEX_Vpcmpistri_xmm_xmmm128_imm8", Code.VEX_VPCMPISTRI_XMM_XMMM128_IMM8); + map.put("EVEX_Vfpclassps_kr_k1_xmmm128b32_imm8", Code.EVEX_VFPCLASSPS_KR_K1_XMMM128B32_IMM8); + map.put("EVEX_Vfpclassps_kr_k1_ymmm256b32_imm8", Code.EVEX_VFPCLASSPS_KR_K1_YMMM256B32_IMM8); + map.put("EVEX_Vfpclassps_kr_k1_zmmm512b32_imm8", Code.EVEX_VFPCLASSPS_KR_K1_ZMMM512B32_IMM8); + map.put("EVEX_Vfpclasspd_kr_k1_xmmm128b64_imm8", Code.EVEX_VFPCLASSPD_KR_K1_XMMM128B64_IMM8); + map.put("EVEX_Vfpclasspd_kr_k1_ymmm256b64_imm8", Code.EVEX_VFPCLASSPD_KR_K1_YMMM256B64_IMM8); + map.put("EVEX_Vfpclasspd_kr_k1_zmmm512b64_imm8", Code.EVEX_VFPCLASSPD_KR_K1_ZMMM512B64_IMM8); + map.put("EVEX_Vfpclassss_kr_k1_xmmm32_imm8", Code.EVEX_VFPCLASSSS_KR_K1_XMMM32_IMM8); + map.put("EVEX_Vfpclasssd_kr_k1_xmmm64_imm8", Code.EVEX_VFPCLASSSD_KR_K1_XMMM64_IMM8); + map.put("VEX_Vfmaddps_xmm_xmm_xmmm128_xmm", Code.VEX_VFMADDPS_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfmaddps_ymm_ymm_ymmm256_ymm", Code.VEX_VFMADDPS_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfmaddps_xmm_xmm_xmm_xmmm128", Code.VEX_VFMADDPS_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfmaddps_ymm_ymm_ymm_ymmm256", Code.VEX_VFMADDPS_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfmaddpd_xmm_xmm_xmmm128_xmm", Code.VEX_VFMADDPD_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfmaddpd_ymm_ymm_ymmm256_ymm", Code.VEX_VFMADDPD_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfmaddpd_xmm_xmm_xmm_xmmm128", Code.VEX_VFMADDPD_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfmaddpd_ymm_ymm_ymm_ymmm256", Code.VEX_VFMADDPD_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfmaddss_xmm_xmm_xmmm32_xmm", Code.VEX_VFMADDSS_XMM_XMM_XMMM32_XMM); + } + + private static void initMap8(HashMap map) { + map.put("VEX_Vfmaddss_xmm_xmm_xmm_xmmm32", Code.VEX_VFMADDSS_XMM_XMM_XMM_XMMM32); + map.put("VEX_Vfmaddsd_xmm_xmm_xmmm64_xmm", Code.VEX_VFMADDSD_XMM_XMM_XMMM64_XMM); + map.put("VEX_Vfmaddsd_xmm_xmm_xmm_xmmm64", Code.VEX_VFMADDSD_XMM_XMM_XMM_XMMM64); + map.put("VEX_Vfmsubps_xmm_xmm_xmmm128_xmm", Code.VEX_VFMSUBPS_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfmsubps_ymm_ymm_ymmm256_ymm", Code.VEX_VFMSUBPS_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfmsubps_xmm_xmm_xmm_xmmm128", Code.VEX_VFMSUBPS_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfmsubps_ymm_ymm_ymm_ymmm256", Code.VEX_VFMSUBPS_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfmsubpd_xmm_xmm_xmmm128_xmm", Code.VEX_VFMSUBPD_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfmsubpd_ymm_ymm_ymmm256_ymm", Code.VEX_VFMSUBPD_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfmsubpd_xmm_xmm_xmm_xmmm128", Code.VEX_VFMSUBPD_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfmsubpd_ymm_ymm_ymm_ymmm256", Code.VEX_VFMSUBPD_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfmsubss_xmm_xmm_xmmm32_xmm", Code.VEX_VFMSUBSS_XMM_XMM_XMMM32_XMM); + map.put("VEX_Vfmsubss_xmm_xmm_xmm_xmmm32", Code.VEX_VFMSUBSS_XMM_XMM_XMM_XMMM32); + map.put("VEX_Vfmsubsd_xmm_xmm_xmmm64_xmm", Code.VEX_VFMSUBSD_XMM_XMM_XMMM64_XMM); + map.put("VEX_Vfmsubsd_xmm_xmm_xmm_xmmm64", Code.VEX_VFMSUBSD_XMM_XMM_XMM_XMMM64); + map.put("EVEX_Vpshldw_xmm_k1z_xmm_xmmm128_imm8", Code.EVEX_VPSHLDW_XMM_K1Z_XMM_XMMM128_IMM8); + map.put("EVEX_Vpshldw_ymm_k1z_ymm_ymmm256_imm8", Code.EVEX_VPSHLDW_YMM_K1Z_YMM_YMMM256_IMM8); + map.put("EVEX_Vpshldw_zmm_k1z_zmm_zmmm512_imm8", Code.EVEX_VPSHLDW_ZMM_K1Z_ZMM_ZMMM512_IMM8); + map.put("EVEX_Vpshldd_xmm_k1z_xmm_xmmm128b32_imm8", Code.EVEX_VPSHLDD_XMM_K1Z_XMM_XMMM128B32_IMM8); + map.put("EVEX_Vpshldd_ymm_k1z_ymm_ymmm256b32_imm8", Code.EVEX_VPSHLDD_YMM_K1Z_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vpshldd_zmm_k1z_zmm_zmmm512b32_imm8", Code.EVEX_VPSHLDD_ZMM_K1Z_ZMM_ZMMM512B32_IMM8); + map.put("EVEX_Vpshldq_xmm_k1z_xmm_xmmm128b64_imm8", Code.EVEX_VPSHLDQ_XMM_K1Z_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vpshldq_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VPSHLDQ_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vpshldq_zmm_k1z_zmm_zmmm512b64_imm8", Code.EVEX_VPSHLDQ_ZMM_K1Z_ZMM_ZMMM512B64_IMM8); + map.put("EVEX_Vpshrdw_xmm_k1z_xmm_xmmm128_imm8", Code.EVEX_VPSHRDW_XMM_K1Z_XMM_XMMM128_IMM8); + map.put("EVEX_Vpshrdw_ymm_k1z_ymm_ymmm256_imm8", Code.EVEX_VPSHRDW_YMM_K1Z_YMM_YMMM256_IMM8); + map.put("EVEX_Vpshrdw_zmm_k1z_zmm_zmmm512_imm8", Code.EVEX_VPSHRDW_ZMM_K1Z_ZMM_ZMMM512_IMM8); + map.put("EVEX_Vpshrdd_xmm_k1z_xmm_xmmm128b32_imm8", Code.EVEX_VPSHRDD_XMM_K1Z_XMM_XMMM128B32_IMM8); + map.put("EVEX_Vpshrdd_ymm_k1z_ymm_ymmm256b32_imm8", Code.EVEX_VPSHRDD_YMM_K1Z_YMM_YMMM256B32_IMM8); + map.put("EVEX_Vpshrdd_zmm_k1z_zmm_zmmm512b32_imm8", Code.EVEX_VPSHRDD_ZMM_K1Z_ZMM_ZMMM512B32_IMM8); + map.put("EVEX_Vpshrdq_xmm_k1z_xmm_xmmm128b64_imm8", Code.EVEX_VPSHRDQ_XMM_K1Z_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vpshrdq_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VPSHRDQ_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vpshrdq_zmm_k1z_zmm_zmmm512b64_imm8", Code.EVEX_VPSHRDQ_ZMM_K1Z_ZMM_ZMMM512B64_IMM8); + map.put("VEX_Vfnmaddps_xmm_xmm_xmmm128_xmm", Code.VEX_VFNMADDPS_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfnmaddps_ymm_ymm_ymmm256_ymm", Code.VEX_VFNMADDPS_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfnmaddps_xmm_xmm_xmm_xmmm128", Code.VEX_VFNMADDPS_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfnmaddps_ymm_ymm_ymm_ymmm256", Code.VEX_VFNMADDPS_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfnmaddpd_xmm_xmm_xmmm128_xmm", Code.VEX_VFNMADDPD_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfnmaddpd_ymm_ymm_ymmm256_ymm", Code.VEX_VFNMADDPD_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfnmaddpd_xmm_xmm_xmm_xmmm128", Code.VEX_VFNMADDPD_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfnmaddpd_ymm_ymm_ymm_ymmm256", Code.VEX_VFNMADDPD_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfnmaddss_xmm_xmm_xmmm32_xmm", Code.VEX_VFNMADDSS_XMM_XMM_XMMM32_XMM); + map.put("VEX_Vfnmaddss_xmm_xmm_xmm_xmmm32", Code.VEX_VFNMADDSS_XMM_XMM_XMM_XMMM32); + map.put("VEX_Vfnmaddsd_xmm_xmm_xmmm64_xmm", Code.VEX_VFNMADDSD_XMM_XMM_XMMM64_XMM); + map.put("VEX_Vfnmaddsd_xmm_xmm_xmm_xmmm64", Code.VEX_VFNMADDSD_XMM_XMM_XMM_XMMM64); + map.put("VEX_Vfnmsubps_xmm_xmm_xmmm128_xmm", Code.VEX_VFNMSUBPS_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfnmsubps_ymm_ymm_ymmm256_ymm", Code.VEX_VFNMSUBPS_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfnmsubps_xmm_xmm_xmm_xmmm128", Code.VEX_VFNMSUBPS_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfnmsubps_ymm_ymm_ymm_ymmm256", Code.VEX_VFNMSUBPS_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfnmsubpd_xmm_xmm_xmmm128_xmm", Code.VEX_VFNMSUBPD_XMM_XMM_XMMM128_XMM); + map.put("VEX_Vfnmsubpd_ymm_ymm_ymmm256_ymm", Code.VEX_VFNMSUBPD_YMM_YMM_YMMM256_YMM); + map.put("VEX_Vfnmsubpd_xmm_xmm_xmm_xmmm128", Code.VEX_VFNMSUBPD_XMM_XMM_XMM_XMMM128); + map.put("VEX_Vfnmsubpd_ymm_ymm_ymm_ymmm256", Code.VEX_VFNMSUBPD_YMM_YMM_YMM_YMMM256); + map.put("VEX_Vfnmsubss_xmm_xmm_xmmm32_xmm", Code.VEX_VFNMSUBSS_XMM_XMM_XMMM32_XMM); + map.put("VEX_Vfnmsubss_xmm_xmm_xmm_xmmm32", Code.VEX_VFNMSUBSS_XMM_XMM_XMM_XMMM32); + map.put("VEX_Vfnmsubsd_xmm_xmm_xmmm64_xmm", Code.VEX_VFNMSUBSD_XMM_XMM_XMMM64_XMM); + map.put("VEX_Vfnmsubsd_xmm_xmm_xmm_xmmm64", Code.VEX_VFNMSUBSD_XMM_XMM_XMM_XMMM64); + map.put("Sha1rnds4_xmm_xmmm128_imm8", Code.SHA1RNDS4_XMM_XMMM128_IMM8); + map.put("Gf2p8affineqb_xmm_xmmm128_imm8", Code.GF2P8AFFINEQB_XMM_XMMM128_IMM8); + map.put("VEX_Vgf2p8affineqb_xmm_xmm_xmmm128_imm8", Code.VEX_VGF2P8AFFINEQB_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vgf2p8affineqb_ymm_ymm_ymmm256_imm8", Code.VEX_VGF2P8AFFINEQB_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Vgf2p8affineqb_xmm_k1z_xmm_xmmm128b64_imm8", Code.EVEX_VGF2P8AFFINEQB_XMM_K1Z_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vgf2p8affineqb_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VGF2P8AFFINEQB_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vgf2p8affineqb_zmm_k1z_zmm_zmmm512b64_imm8", Code.EVEX_VGF2P8AFFINEQB_ZMM_K1Z_ZMM_ZMMM512B64_IMM8); + map.put("Gf2p8affineinvqb_xmm_xmmm128_imm8", Code.GF2P8AFFINEINVQB_XMM_XMMM128_IMM8); + map.put("VEX_Vgf2p8affineinvqb_xmm_xmm_xmmm128_imm8", Code.VEX_VGF2P8AFFINEINVQB_XMM_XMM_XMMM128_IMM8); + map.put("VEX_Vgf2p8affineinvqb_ymm_ymm_ymmm256_imm8", Code.VEX_VGF2P8AFFINEINVQB_YMM_YMM_YMMM256_IMM8); + map.put("EVEX_Vgf2p8affineinvqb_xmm_k1z_xmm_xmmm128b64_imm8", Code.EVEX_VGF2P8AFFINEINVQB_XMM_K1Z_XMM_XMMM128B64_IMM8); + map.put("EVEX_Vgf2p8affineinvqb_ymm_k1z_ymm_ymmm256b64_imm8", Code.EVEX_VGF2P8AFFINEINVQB_YMM_K1Z_YMM_YMMM256B64_IMM8); + map.put("EVEX_Vgf2p8affineinvqb_zmm_k1z_zmm_zmmm512b64_imm8", Code.EVEX_VGF2P8AFFINEINVQB_ZMM_K1Z_ZMM_ZMMM512B64_IMM8); + map.put("Aeskeygenassist_xmm_xmmm128_imm8", Code.AESKEYGENASSIST_XMM_XMMM128_IMM8); + map.put("VEX_Vaeskeygenassist_xmm_xmmm128_imm8", Code.VEX_VAESKEYGENASSIST_XMM_XMMM128_IMM8); + map.put("VEX_Rorx_r32_rm32_imm8", Code.VEX_RORX_R32_RM32_IMM8); + map.put("VEX_Rorx_r64_rm64_imm8", Code.VEX_RORX_R64_RM64_IMM8); + map.put("XOP_Vpmacssww_xmm_xmm_xmmm128_xmm", Code.XOP_VPMACSSWW_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpmacsswd_xmm_xmm_xmmm128_xmm", Code.XOP_VPMACSSWD_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpmacssdql_xmm_xmm_xmmm128_xmm", Code.XOP_VPMACSSDQL_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpmacssdd_xmm_xmm_xmmm128_xmm", Code.XOP_VPMACSSDD_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpmacssdqh_xmm_xmm_xmmm128_xmm", Code.XOP_VPMACSSDQH_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpmacsww_xmm_xmm_xmmm128_xmm", Code.XOP_VPMACSWW_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpmacswd_xmm_xmm_xmmm128_xmm", Code.XOP_VPMACSWD_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpmacsdql_xmm_xmm_xmmm128_xmm", Code.XOP_VPMACSDQL_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpmacsdd_xmm_xmm_xmmm128_xmm", Code.XOP_VPMACSDD_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpmacsdqh_xmm_xmm_xmmm128_xmm", Code.XOP_VPMACSDQH_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpcmov_xmm_xmm_xmmm128_xmm", Code.XOP_VPCMOV_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpcmov_ymm_ymm_ymmm256_ymm", Code.XOP_VPCMOV_YMM_YMM_YMMM256_YMM); + map.put("XOP_Vpcmov_xmm_xmm_xmm_xmmm128", Code.XOP_VPCMOV_XMM_XMM_XMM_XMMM128); + map.put("XOP_Vpcmov_ymm_ymm_ymm_ymmm256", Code.XOP_VPCMOV_YMM_YMM_YMM_YMMM256); + map.put("XOP_Vpperm_xmm_xmm_xmmm128_xmm", Code.XOP_VPPERM_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpperm_xmm_xmm_xmm_xmmm128", Code.XOP_VPPERM_XMM_XMM_XMM_XMMM128); + map.put("XOP_Vpmadcsswd_xmm_xmm_xmmm128_xmm", Code.XOP_VPMADCSSWD_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vpmadcswd_xmm_xmm_xmmm128_xmm", Code.XOP_VPMADCSWD_XMM_XMM_XMMM128_XMM); + map.put("XOP_Vprotb_xmm_xmmm128_imm8", Code.XOP_VPROTB_XMM_XMMM128_IMM8); + map.put("XOP_Vprotw_xmm_xmmm128_imm8", Code.XOP_VPROTW_XMM_XMMM128_IMM8); + map.put("XOP_Vprotd_xmm_xmmm128_imm8", Code.XOP_VPROTD_XMM_XMMM128_IMM8); + map.put("XOP_Vprotq_xmm_xmmm128_imm8", Code.XOP_VPROTQ_XMM_XMMM128_IMM8); + map.put("XOP_Vpcomb_xmm_xmm_xmmm128_imm8", Code.XOP_VPCOMB_XMM_XMM_XMMM128_IMM8); + map.put("XOP_Vpcomw_xmm_xmm_xmmm128_imm8", Code.XOP_VPCOMW_XMM_XMM_XMMM128_IMM8); + map.put("XOP_Vpcomd_xmm_xmm_xmmm128_imm8", Code.XOP_VPCOMD_XMM_XMM_XMMM128_IMM8); + map.put("XOP_Vpcomq_xmm_xmm_xmmm128_imm8", Code.XOP_VPCOMQ_XMM_XMM_XMMM128_IMM8); + map.put("XOP_Vpcomub_xmm_xmm_xmmm128_imm8", Code.XOP_VPCOMUB_XMM_XMM_XMMM128_IMM8); + map.put("XOP_Vpcomuw_xmm_xmm_xmmm128_imm8", Code.XOP_VPCOMUW_XMM_XMM_XMMM128_IMM8); + map.put("XOP_Vpcomud_xmm_xmm_xmmm128_imm8", Code.XOP_VPCOMUD_XMM_XMM_XMMM128_IMM8); + map.put("XOP_Vpcomuq_xmm_xmm_xmmm128_imm8", Code.XOP_VPCOMUQ_XMM_XMM_XMMM128_IMM8); + map.put("XOP_Blcfill_r32_rm32", Code.XOP_BLCFILL_R32_RM32); + map.put("XOP_Blcfill_r64_rm64", Code.XOP_BLCFILL_R64_RM64); + map.put("XOP_Blsfill_r32_rm32", Code.XOP_BLSFILL_R32_RM32); + map.put("XOP_Blsfill_r64_rm64", Code.XOP_BLSFILL_R64_RM64); + map.put("XOP_Blcs_r32_rm32", Code.XOP_BLCS_R32_RM32); + map.put("XOP_Blcs_r64_rm64", Code.XOP_BLCS_R64_RM64); + map.put("XOP_Tzmsk_r32_rm32", Code.XOP_TZMSK_R32_RM32); + map.put("XOP_Tzmsk_r64_rm64", Code.XOP_TZMSK_R64_RM64); + map.put("XOP_Blcic_r32_rm32", Code.XOP_BLCIC_R32_RM32); + map.put("XOP_Blcic_r64_rm64", Code.XOP_BLCIC_R64_RM64); + map.put("XOP_Blsic_r32_rm32", Code.XOP_BLSIC_R32_RM32); + map.put("XOP_Blsic_r64_rm64", Code.XOP_BLSIC_R64_RM64); + map.put("XOP_T1mskc_r32_rm32", Code.XOP_T1MSKC_R32_RM32); + map.put("XOP_T1mskc_r64_rm64", Code.XOP_T1MSKC_R64_RM64); + map.put("XOP_Blcmsk_r32_rm32", Code.XOP_BLCMSK_R32_RM32); + map.put("XOP_Blcmsk_r64_rm64", Code.XOP_BLCMSK_R64_RM64); + map.put("XOP_Blci_r32_rm32", Code.XOP_BLCI_R32_RM32); + map.put("XOP_Blci_r64_rm64", Code.XOP_BLCI_R64_RM64); + map.put("XOP_Llwpcb_r32", Code.XOP_LLWPCB_R32); + map.put("XOP_Llwpcb_r64", Code.XOP_LLWPCB_R64); + map.put("XOP_Slwpcb_r32", Code.XOP_SLWPCB_R32); + map.put("XOP_Slwpcb_r64", Code.XOP_SLWPCB_R64); + map.put("XOP_Vfrczps_xmm_xmmm128", Code.XOP_VFRCZPS_XMM_XMMM128); + map.put("XOP_Vfrczps_ymm_ymmm256", Code.XOP_VFRCZPS_YMM_YMMM256); + map.put("XOP_Vfrczpd_xmm_xmmm128", Code.XOP_VFRCZPD_XMM_XMMM128); + map.put("XOP_Vfrczpd_ymm_ymmm256", Code.XOP_VFRCZPD_YMM_YMMM256); + map.put("XOP_Vfrczss_xmm_xmmm32", Code.XOP_VFRCZSS_XMM_XMMM32); + map.put("XOP_Vfrczsd_xmm_xmmm64", Code.XOP_VFRCZSD_XMM_XMMM64); + map.put("XOP_Vprotb_xmm_xmmm128_xmm", Code.XOP_VPROTB_XMM_XMMM128_XMM); + map.put("XOP_Vprotb_xmm_xmm_xmmm128", Code.XOP_VPROTB_XMM_XMM_XMMM128); + map.put("XOP_Vprotw_xmm_xmmm128_xmm", Code.XOP_VPROTW_XMM_XMMM128_XMM); + map.put("XOP_Vprotw_xmm_xmm_xmmm128", Code.XOP_VPROTW_XMM_XMM_XMMM128); + map.put("XOP_Vprotd_xmm_xmmm128_xmm", Code.XOP_VPROTD_XMM_XMMM128_XMM); + map.put("XOP_Vprotd_xmm_xmm_xmmm128", Code.XOP_VPROTD_XMM_XMM_XMMM128); + map.put("XOP_Vprotq_xmm_xmmm128_xmm", Code.XOP_VPROTQ_XMM_XMMM128_XMM); + map.put("XOP_Vprotq_xmm_xmm_xmmm128", Code.XOP_VPROTQ_XMM_XMM_XMMM128); + map.put("XOP_Vpshlb_xmm_xmmm128_xmm", Code.XOP_VPSHLB_XMM_XMMM128_XMM); + map.put("XOP_Vpshlb_xmm_xmm_xmmm128", Code.XOP_VPSHLB_XMM_XMM_XMMM128); + map.put("XOP_Vpshlw_xmm_xmmm128_xmm", Code.XOP_VPSHLW_XMM_XMMM128_XMM); + map.put("XOP_Vpshlw_xmm_xmm_xmmm128", Code.XOP_VPSHLW_XMM_XMM_XMMM128); + map.put("XOP_Vpshld_xmm_xmmm128_xmm", Code.XOP_VPSHLD_XMM_XMMM128_XMM); + map.put("XOP_Vpshld_xmm_xmm_xmmm128", Code.XOP_VPSHLD_XMM_XMM_XMMM128); + map.put("XOP_Vpshlq_xmm_xmmm128_xmm", Code.XOP_VPSHLQ_XMM_XMMM128_XMM); + map.put("XOP_Vpshlq_xmm_xmm_xmmm128", Code.XOP_VPSHLQ_XMM_XMM_XMMM128); + map.put("XOP_Vpshab_xmm_xmmm128_xmm", Code.XOP_VPSHAB_XMM_XMMM128_XMM); + map.put("XOP_Vpshab_xmm_xmm_xmmm128", Code.XOP_VPSHAB_XMM_XMM_XMMM128); + map.put("XOP_Vpshaw_xmm_xmmm128_xmm", Code.XOP_VPSHAW_XMM_XMMM128_XMM); + map.put("XOP_Vpshaw_xmm_xmm_xmmm128", Code.XOP_VPSHAW_XMM_XMM_XMMM128); + map.put("XOP_Vpshad_xmm_xmmm128_xmm", Code.XOP_VPSHAD_XMM_XMMM128_XMM); + map.put("XOP_Vpshad_xmm_xmm_xmmm128", Code.XOP_VPSHAD_XMM_XMM_XMMM128); + map.put("XOP_Vpshaq_xmm_xmmm128_xmm", Code.XOP_VPSHAQ_XMM_XMMM128_XMM); + map.put("XOP_Vpshaq_xmm_xmm_xmmm128", Code.XOP_VPSHAQ_XMM_XMM_XMMM128); + map.put("XOP_Vphaddbw_xmm_xmmm128", Code.XOP_VPHADDBW_XMM_XMMM128); + map.put("XOP_Vphaddbd_xmm_xmmm128", Code.XOP_VPHADDBD_XMM_XMMM128); + map.put("XOP_Vphaddbq_xmm_xmmm128", Code.XOP_VPHADDBQ_XMM_XMMM128); + map.put("XOP_Vphaddwd_xmm_xmmm128", Code.XOP_VPHADDWD_XMM_XMMM128); + map.put("XOP_Vphaddwq_xmm_xmmm128", Code.XOP_VPHADDWQ_XMM_XMMM128); + map.put("XOP_Vphadddq_xmm_xmmm128", Code.XOP_VPHADDDQ_XMM_XMMM128); + map.put("XOP_Vphaddubw_xmm_xmmm128", Code.XOP_VPHADDUBW_XMM_XMMM128); + map.put("XOP_Vphaddubd_xmm_xmmm128", Code.XOP_VPHADDUBD_XMM_XMMM128); + map.put("XOP_Vphaddubq_xmm_xmmm128", Code.XOP_VPHADDUBQ_XMM_XMMM128); + map.put("XOP_Vphadduwd_xmm_xmmm128", Code.XOP_VPHADDUWD_XMM_XMMM128); + map.put("XOP_Vphadduwq_xmm_xmmm128", Code.XOP_VPHADDUWQ_XMM_XMMM128); + map.put("XOP_Vphaddudq_xmm_xmmm128", Code.XOP_VPHADDUDQ_XMM_XMMM128); + map.put("XOP_Vphsubbw_xmm_xmmm128", Code.XOP_VPHSUBBW_XMM_XMMM128); + map.put("XOP_Vphsubwd_xmm_xmmm128", Code.XOP_VPHSUBWD_XMM_XMMM128); + map.put("XOP_Vphsubdq_xmm_xmmm128", Code.XOP_VPHSUBDQ_XMM_XMMM128); + map.put("XOP_Bextr_r32_rm32_imm32", Code.XOP_BEXTR_R32_RM32_IMM32); + map.put("XOP_Bextr_r64_rm64_imm32", Code.XOP_BEXTR_R64_RM64_IMM32); + map.put("XOP_Lwpins_r32_rm32_imm32", Code.XOP_LWPINS_R32_RM32_IMM32); + map.put("XOP_Lwpins_r64_rm32_imm32", Code.XOP_LWPINS_R64_RM32_IMM32); + map.put("XOP_Lwpval_r32_rm32_imm32", Code.XOP_LWPVAL_R32_RM32_IMM32); + map.put("XOP_Lwpval_r64_rm32_imm32", Code.XOP_LWPVAL_R64_RM32_IMM32); + map.put("D3NOW_Pi2fw_mm_mmm64", Code.D3NOW_PI2FW_MM_MMM64); + map.put("D3NOW_Pi2fd_mm_mmm64", Code.D3NOW_PI2FD_MM_MMM64); + map.put("D3NOW_Pf2iw_mm_mmm64", Code.D3NOW_PF2IW_MM_MMM64); + map.put("D3NOW_Pf2id_mm_mmm64", Code.D3NOW_PF2ID_MM_MMM64); + map.put("D3NOW_Pfrcpv_mm_mmm64", Code.D3NOW_PFRCPV_MM_MMM64); + map.put("D3NOW_Pfrsqrtv_mm_mmm64", Code.D3NOW_PFRSQRTV_MM_MMM64); + map.put("D3NOW_Pfnacc_mm_mmm64", Code.D3NOW_PFNACC_MM_MMM64); + map.put("D3NOW_Pfpnacc_mm_mmm64", Code.D3NOW_PFPNACC_MM_MMM64); + map.put("D3NOW_Pfcmpge_mm_mmm64", Code.D3NOW_PFCMPGE_MM_MMM64); + map.put("D3NOW_Pfmin_mm_mmm64", Code.D3NOW_PFMIN_MM_MMM64); + map.put("D3NOW_Pfrcp_mm_mmm64", Code.D3NOW_PFRCP_MM_MMM64); + map.put("D3NOW_Pfrsqrt_mm_mmm64", Code.D3NOW_PFRSQRT_MM_MMM64); + map.put("D3NOW_Pfsub_mm_mmm64", Code.D3NOW_PFSUB_MM_MMM64); + map.put("D3NOW_Pfadd_mm_mmm64", Code.D3NOW_PFADD_MM_MMM64); + map.put("D3NOW_Pfcmpgt_mm_mmm64", Code.D3NOW_PFCMPGT_MM_MMM64); + map.put("D3NOW_Pfmax_mm_mmm64", Code.D3NOW_PFMAX_MM_MMM64); + map.put("D3NOW_Pfrcpit1_mm_mmm64", Code.D3NOW_PFRCPIT1_MM_MMM64); + map.put("D3NOW_Pfrsqit1_mm_mmm64", Code.D3NOW_PFRSQIT1_MM_MMM64); + map.put("D3NOW_Pfsubr_mm_mmm64", Code.D3NOW_PFSUBR_MM_MMM64); + map.put("D3NOW_Pfacc_mm_mmm64", Code.D3NOW_PFACC_MM_MMM64); + map.put("D3NOW_Pfcmpeq_mm_mmm64", Code.D3NOW_PFCMPEQ_MM_MMM64); + map.put("D3NOW_Pfmul_mm_mmm64", Code.D3NOW_PFMUL_MM_MMM64); + map.put("D3NOW_Pfrcpit2_mm_mmm64", Code.D3NOW_PFRCPIT2_MM_MMM64); + map.put("D3NOW_Pmulhrw_mm_mmm64", Code.D3NOW_PMULHRW_MM_MMM64); + map.put("D3NOW_Pswapd_mm_mmm64", Code.D3NOW_PSWAPD_MM_MMM64); + map.put("D3NOW_Pavgusb_mm_mmm64", Code.D3NOW_PAVGUSB_MM_MMM64); + map.put("Rmpadjust", Code.RMPADJUST); + map.put("Rmpupdate", Code.RMPUPDATE); + map.put("Psmash", Code.PSMASH); + map.put("Pvalidatew", Code.PVALIDATEW); + map.put("Pvalidated", Code.PVALIDATED); + map.put("Pvalidateq", Code.PVALIDATEQ); + map.put("Serialize", Code.SERIALIZE); + map.put("Xsusldtrk", Code.XSUSLDTRK); + map.put("Xresldtrk", Code.XRESLDTRK); + map.put("Invlpgbw", Code.INVLPGBW); + map.put("Invlpgbd", Code.INVLPGBD); + map.put("Invlpgbq", Code.INVLPGBQ); + map.put("Tlbsync", Code.TLBSYNC); + map.put("Prefetchreserved3_m8", Code.PREFETCHRESERVED3_M8); + map.put("Prefetchreserved4_m8", Code.PREFETCHRESERVED4_M8); + map.put("Prefetchreserved5_m8", Code.PREFETCHRESERVED5_M8); + map.put("Prefetchreserved6_m8", Code.PREFETCHRESERVED6_M8); + map.put("Prefetchreserved7_m8", Code.PREFETCHRESERVED7_M8); + map.put("Ud0", Code.UD0); + map.put("Vmgexit", Code.VMGEXIT); + map.put("Getsecq", Code.GETSECQ); + map.put("VEX_Ldtilecfg_m512", Code.VEX_LDTILECFG_M512); + map.put("VEX_Tilerelease", Code.VEX_TILERELEASE); + map.put("VEX_Sttilecfg_m512", Code.VEX_STTILECFG_M512); + map.put("VEX_Tilezero_tmm", Code.VEX_TILEZERO_TMM); + map.put("VEX_Tileloaddt1_tmm_sibmem", Code.VEX_TILELOADDT1_TMM_SIBMEM); + map.put("VEX_Tilestored_sibmem_tmm", Code.VEX_TILESTORED_SIBMEM_TMM); + map.put("VEX_Tileloadd_tmm_sibmem", Code.VEX_TILELOADD_TMM_SIBMEM); + map.put("VEX_Tdpbf16ps_tmm_tmm_tmm", Code.VEX_TDPBF16PS_TMM_TMM_TMM); + map.put("VEX_Tdpbuud_tmm_tmm_tmm", Code.VEX_TDPBUUD_TMM_TMM_TMM); + map.put("VEX_Tdpbusd_tmm_tmm_tmm", Code.VEX_TDPBUSD_TMM_TMM_TMM); + map.put("VEX_Tdpbsud_tmm_tmm_tmm", Code.VEX_TDPBSUD_TMM_TMM_TMM); + map.put("VEX_Tdpbssd_tmm_tmm_tmm", Code.VEX_TDPBSSD_TMM_TMM_TMM); + map.put("Fnstdw_AX", Code.FNSTDW_AX); + map.put("Fnstsg_AX", Code.FNSTSG_AX); + map.put("Rdshr_rm32", Code.RDSHR_RM32); + map.put("Wrshr_rm32", Code.WRSHR_RM32); + map.put("Smint", Code.SMINT); + map.put("Dmint", Code.DMINT); + map.put("Rdm", Code.RDM); + map.put("Svdc_m80_Sreg", Code.SVDC_M80_SREG); + map.put("Rsdc_Sreg_m80", Code.RSDC_SREG_M80); + map.put("Svldt_m80", Code.SVLDT_M80); + map.put("Rsldt_m80", Code.RSLDT_M80); + map.put("Svts_m80", Code.SVTS_M80); + map.put("Rsts_m80", Code.RSTS_M80); + map.put("Smint_0F7E", Code.SMINT_0F7E); + map.put("Bb0_reset", Code.BB0_RESET); + map.put("Bb1_reset", Code.BB1_RESET); + map.put("Cpu_write", Code.CPU_WRITE); + map.put("Cpu_read", Code.CPU_READ); + map.put("Altinst", Code.ALTINST); + map.put("Paveb_mm_mmm64", Code.PAVEB_MM_MMM64); + map.put("Paddsiw_mm_mmm64", Code.PADDSIW_MM_MMM64); + map.put("Pmagw_mm_mmm64", Code.PMAGW_MM_MMM64); + map.put("Pdistib_mm_m64", Code.PDISTIB_MM_M64); + map.put("Psubsiw_mm_mmm64", Code.PSUBSIW_MM_MMM64); + map.put("Pmvzb_mm_m64", Code.PMVZB_MM_M64); + map.put("Pmulhrw_mm_mmm64", Code.PMULHRW_MM_MMM64); + map.put("Pmvnzb_mm_m64", Code.PMVNZB_MM_M64); + map.put("Pmvlzb_mm_m64", Code.PMVLZB_MM_M64); + map.put("Pmvgezb_mm_m64", Code.PMVGEZB_MM_M64); + map.put("Pmulhriw_mm_mmm64", Code.PMULHRIW_MM_MMM64); + map.put("Pmachriw_mm_m64", Code.PMACHRIW_MM_M64); + map.put("Cyrix_D9D7", Code.CYRIX_D9D7); + map.put("Cyrix_D9E2", Code.CYRIX_D9E2); + map.put("Ftstp", Code.FTSTP); + map.put("Cyrix_D9E7", Code.CYRIX_D9E7); + map.put("Frint2", Code.FRINT2); + map.put("Frichop", Code.FRICHOP); + map.put("Cyrix_DED8", Code.CYRIX_DED8); + map.put("Cyrix_DEDA", Code.CYRIX_DEDA); + map.put("Cyrix_DEDC", Code.CYRIX_DEDC); + map.put("Cyrix_DEDD", Code.CYRIX_DEDD); + map.put("Cyrix_DEDE", Code.CYRIX_DEDE); + map.put("Frinear", Code.FRINEAR); + map.put("Tdcall", Code.TDCALL); + map.put("Seamret", Code.SEAMRET); + map.put("Seamops", Code.SEAMOPS); + map.put("Seamcall", Code.SEAMCALL); + map.put("Aesencwide128kl_m384", Code.AESENCWIDE128KL_M384); + map.put("Aesdecwide128kl_m384", Code.AESDECWIDE128KL_M384); + map.put("Aesencwide256kl_m512", Code.AESENCWIDE256KL_M512); + map.put("Aesdecwide256kl_m512", Code.AESDECWIDE256KL_M512); + map.put("Loadiwkey_xmm_xmm", Code.LOADIWKEY_XMM_XMM); + map.put("Aesenc128kl_xmm_m384", Code.AESENC128KL_XMM_M384); + map.put("Aesdec128kl_xmm_m384", Code.AESDEC128KL_XMM_M384); + map.put("Aesenc256kl_xmm_m512", Code.AESENC256KL_XMM_M512); + map.put("Aesdec256kl_xmm_m512", Code.AESDEC256KL_XMM_M512); + map.put("Encodekey128_r32_r32", Code.ENCODEKEY128_R32_R32); + map.put("Encodekey256_r32_r32", Code.ENCODEKEY256_R32_R32); + map.put("VEX_Vbroadcastss_xmm_xmm", Code.VEX_VBROADCASTSS_XMM_XMM); + map.put("VEX_Vbroadcastss_ymm_xmm", Code.VEX_VBROADCASTSS_YMM_XMM); + map.put("VEX_Vbroadcastsd_ymm_xmm", Code.VEX_VBROADCASTSD_YMM_XMM); + map.put("Vmgexit_F2", Code.VMGEXIT_F2); + map.put("Uiret", Code.UIRET); + map.put("Testui", Code.TESTUI); + map.put("Clui", Code.CLUI); + map.put("Stui", Code.STUI); + map.put("Senduipi_r64", Code.SENDUIPI_R64); + map.put("Hreset_imm8", Code.HRESET_IMM8); + map.put("VEX_Vpdpbusd_xmm_xmm_xmmm128", Code.VEX_VPDPBUSD_XMM_XMM_XMMM128); + map.put("VEX_Vpdpbusd_ymm_ymm_ymmm256", Code.VEX_VPDPBUSD_YMM_YMM_YMMM256); + map.put("VEX_Vpdpbusds_xmm_xmm_xmmm128", Code.VEX_VPDPBUSDS_XMM_XMM_XMMM128); + map.put("VEX_Vpdpbusds_ymm_ymm_ymmm256", Code.VEX_VPDPBUSDS_YMM_YMM_YMMM256); + map.put("VEX_Vpdpwssd_xmm_xmm_xmmm128", Code.VEX_VPDPWSSD_XMM_XMM_XMMM128); + map.put("VEX_Vpdpwssd_ymm_ymm_ymmm256", Code.VEX_VPDPWSSD_YMM_YMM_YMMM256); + map.put("VEX_Vpdpwssds_xmm_xmm_xmmm128", Code.VEX_VPDPWSSDS_XMM_XMM_XMMM128); + map.put("VEX_Vpdpwssds_ymm_ymm_ymmm256", Code.VEX_VPDPWSSDS_YMM_YMM_YMMM256); + map.put("Ccs_hash_16", Code.CCS_HASH_16); + map.put("Ccs_hash_32", Code.CCS_HASH_32); + map.put("Ccs_hash_64", Code.CCS_HASH_64); + map.put("Ccs_encrypt_16", Code.CCS_ENCRYPT_16); + map.put("Ccs_encrypt_32", Code.CCS_ENCRYPT_32); + map.put("Ccs_encrypt_64", Code.CCS_ENCRYPT_64); + map.put("Lkgs_rm16", Code.LKGS_RM16); + map.put("Lkgs_r32m16", Code.LKGS_R32M16); + map.put("Lkgs_r64m16", Code.LKGS_R64M16); + map.put("Eretu", Code.ERETU); + map.put("Erets", Code.ERETS); + map.put("EVEX_Vaddph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VADDPH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vaddph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VADDPH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vaddph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VADDPH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vaddsh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VADDSH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vcmpph_kr_k1_xmm_xmmm128b16_imm8", Code.EVEX_VCMPPH_KR_K1_XMM_XMMM128B16_IMM8); + map.put("EVEX_Vcmpph_kr_k1_ymm_ymmm256b16_imm8", Code.EVEX_VCMPPH_KR_K1_YMM_YMMM256B16_IMM8); + map.put("EVEX_Vcmpph_kr_k1_zmm_zmmm512b16_imm8_sae", Code.EVEX_VCMPPH_KR_K1_ZMM_ZMMM512B16_IMM8_SAE); + map.put("EVEX_Vcmpsh_kr_k1_xmm_xmmm16_imm8_sae", Code.EVEX_VCMPSH_KR_K1_XMM_XMMM16_IMM8_SAE); + map.put("EVEX_Vcomish_xmm_xmmm16_sae", Code.EVEX_VCOMISH_XMM_XMMM16_SAE); + map.put("EVEX_Vcvtdq2ph_xmm_k1z_xmmm128b32", Code.EVEX_VCVTDQ2PH_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtdq2ph_xmm_k1z_ymmm256b32", Code.EVEX_VCVTDQ2PH_XMM_K1Z_YMMM256B32); + map.put("EVEX_Vcvtdq2ph_ymm_k1z_zmmm512b32_er", Code.EVEX_VCVTDQ2PH_YMM_K1Z_ZMMM512B32_ER); + map.put("EVEX_Vcvtpd2ph_xmm_k1z_xmmm128b64", Code.EVEX_VCVTPD2PH_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtpd2ph_xmm_k1z_ymmm256b64", Code.EVEX_VCVTPD2PH_XMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtpd2ph_xmm_k1z_zmmm512b64_er", Code.EVEX_VCVTPD2PH_XMM_K1Z_ZMMM512B64_ER); + map.put("EVEX_Vcvtph2dq_xmm_k1z_xmmm64b16", Code.EVEX_VCVTPH2DQ_XMM_K1Z_XMMM64B16); + map.put("EVEX_Vcvtph2dq_ymm_k1z_xmmm128b16", Code.EVEX_VCVTPH2DQ_YMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvtph2dq_zmm_k1z_ymmm256b16_er", Code.EVEX_VCVTPH2DQ_ZMM_K1Z_YMMM256B16_ER); + map.put("EVEX_Vcvtph2pd_xmm_k1z_xmmm32b16", Code.EVEX_VCVTPH2PD_XMM_K1Z_XMMM32B16); + map.put("EVEX_Vcvtph2pd_ymm_k1z_xmmm64b16", Code.EVEX_VCVTPH2PD_YMM_K1Z_XMMM64B16); + map.put("EVEX_Vcvtph2pd_zmm_k1z_xmmm128b16_sae", Code.EVEX_VCVTPH2PD_ZMM_K1Z_XMMM128B16_SAE); + map.put("EVEX_Vcvtph2psx_xmm_k1z_xmmm64b16", Code.EVEX_VCVTPH2PSX_XMM_K1Z_XMMM64B16); + map.put("EVEX_Vcvtph2psx_ymm_k1z_xmmm128b16", Code.EVEX_VCVTPH2PSX_YMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvtph2psx_zmm_k1z_ymmm256b16_sae", Code.EVEX_VCVTPH2PSX_ZMM_K1Z_YMMM256B16_SAE); + map.put("EVEX_Vcvtph2qq_xmm_k1z_xmmm32b16", Code.EVEX_VCVTPH2QQ_XMM_K1Z_XMMM32B16); + map.put("EVEX_Vcvtph2qq_ymm_k1z_xmmm64b16", Code.EVEX_VCVTPH2QQ_YMM_K1Z_XMMM64B16); + map.put("EVEX_Vcvtph2qq_zmm_k1z_xmmm128b16_er", Code.EVEX_VCVTPH2QQ_ZMM_K1Z_XMMM128B16_ER); + map.put("EVEX_Vcvtph2udq_xmm_k1z_xmmm64b16", Code.EVEX_VCVTPH2UDQ_XMM_K1Z_XMMM64B16); + map.put("EVEX_Vcvtph2udq_ymm_k1z_xmmm128b16", Code.EVEX_VCVTPH2UDQ_YMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvtph2udq_zmm_k1z_ymmm256b16_er", Code.EVEX_VCVTPH2UDQ_ZMM_K1Z_YMMM256B16_ER); + map.put("EVEX_Vcvtph2uqq_xmm_k1z_xmmm32b16", Code.EVEX_VCVTPH2UQQ_XMM_K1Z_XMMM32B16); + map.put("EVEX_Vcvtph2uqq_ymm_k1z_xmmm64b16", Code.EVEX_VCVTPH2UQQ_YMM_K1Z_XMMM64B16); + map.put("EVEX_Vcvtph2uqq_zmm_k1z_xmmm128b16_er", Code.EVEX_VCVTPH2UQQ_ZMM_K1Z_XMMM128B16_ER); + map.put("EVEX_Vcvtph2uw_xmm_k1z_xmmm128b16", Code.EVEX_VCVTPH2UW_XMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvtph2uw_ymm_k1z_ymmm256b16", Code.EVEX_VCVTPH2UW_YMM_K1Z_YMMM256B16); + map.put("EVEX_Vcvtph2uw_zmm_k1z_zmmm512b16_er", Code.EVEX_VCVTPH2UW_ZMM_K1Z_ZMMM512B16_ER); + map.put("EVEX_Vcvtph2w_xmm_k1z_xmmm128b16", Code.EVEX_VCVTPH2W_XMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvtph2w_ymm_k1z_ymmm256b16", Code.EVEX_VCVTPH2W_YMM_K1Z_YMMM256B16); + map.put("EVEX_Vcvtph2w_zmm_k1z_zmmm512b16_er", Code.EVEX_VCVTPH2W_ZMM_K1Z_ZMMM512B16_ER); + map.put("EVEX_Vcvtps2phx_xmm_k1z_xmmm128b32", Code.EVEX_VCVTPS2PHX_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtps2phx_xmm_k1z_ymmm256b32", Code.EVEX_VCVTPS2PHX_XMM_K1Z_YMMM256B32); + map.put("EVEX_Vcvtps2phx_ymm_k1z_zmmm512b32_er", Code.EVEX_VCVTPS2PHX_YMM_K1Z_ZMMM512B32_ER); + map.put("EVEX_Vcvtqq2ph_xmm_k1z_xmmm128b64", Code.EVEX_VCVTQQ2PH_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtqq2ph_xmm_k1z_ymmm256b64", Code.EVEX_VCVTQQ2PH_XMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtqq2ph_xmm_k1z_zmmm512b64_er", Code.EVEX_VCVTQQ2PH_XMM_K1Z_ZMMM512B64_ER); + map.put("EVEX_Vcvtsd2sh_xmm_k1z_xmm_xmmm64_er", Code.EVEX_VCVTSD2SH_XMM_K1Z_XMM_XMMM64_ER); + map.put("EVEX_Vcvtsh2sd_xmm_k1z_xmm_xmmm16_sae", Code.EVEX_VCVTSH2SD_XMM_K1Z_XMM_XMMM16_SAE); + map.put("EVEX_Vcvtsh2si_r32_xmmm16_er", Code.EVEX_VCVTSH2SI_R32_XMMM16_ER); + map.put("EVEX_Vcvtsh2si_r64_xmmm16_er", Code.EVEX_VCVTSH2SI_R64_XMMM16_ER); + map.put("EVEX_Vcvtsh2ss_xmm_k1z_xmm_xmmm16_sae", Code.EVEX_VCVTSH2SS_XMM_K1Z_XMM_XMMM16_SAE); + map.put("EVEX_Vcvtsh2usi_r32_xmmm16_er", Code.EVEX_VCVTSH2USI_R32_XMMM16_ER); + map.put("EVEX_Vcvtsh2usi_r64_xmmm16_er", Code.EVEX_VCVTSH2USI_R64_XMMM16_ER); + map.put("EVEX_Vcvtsi2sh_xmm_xmm_rm32_er", Code.EVEX_VCVTSI2SH_XMM_XMM_RM32_ER); + map.put("EVEX_Vcvtsi2sh_xmm_xmm_rm64_er", Code.EVEX_VCVTSI2SH_XMM_XMM_RM64_ER); + map.put("EVEX_Vcvtss2sh_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VCVTSS2SH_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vcvttph2dq_xmm_k1z_xmmm64b16", Code.EVEX_VCVTTPH2DQ_XMM_K1Z_XMMM64B16); + map.put("EVEX_Vcvttph2dq_ymm_k1z_xmmm128b16", Code.EVEX_VCVTTPH2DQ_YMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvttph2dq_zmm_k1z_ymmm256b16_sae", Code.EVEX_VCVTTPH2DQ_ZMM_K1Z_YMMM256B16_SAE); + map.put("EVEX_Vcvttph2qq_xmm_k1z_xmmm32b16", Code.EVEX_VCVTTPH2QQ_XMM_K1Z_XMMM32B16); + map.put("EVEX_Vcvttph2qq_ymm_k1z_xmmm64b16", Code.EVEX_VCVTTPH2QQ_YMM_K1Z_XMMM64B16); + map.put("EVEX_Vcvttph2qq_zmm_k1z_xmmm128b16_sae", Code.EVEX_VCVTTPH2QQ_ZMM_K1Z_XMMM128B16_SAE); + map.put("EVEX_Vcvttph2udq_xmm_k1z_xmmm64b16", Code.EVEX_VCVTTPH2UDQ_XMM_K1Z_XMMM64B16); + map.put("EVEX_Vcvttph2udq_ymm_k1z_xmmm128b16", Code.EVEX_VCVTTPH2UDQ_YMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvttph2udq_zmm_k1z_ymmm256b16_sae", Code.EVEX_VCVTTPH2UDQ_ZMM_K1Z_YMMM256B16_SAE); + map.put("EVEX_Vcvttph2uqq_xmm_k1z_xmmm32b16", Code.EVEX_VCVTTPH2UQQ_XMM_K1Z_XMMM32B16); + map.put("EVEX_Vcvttph2uqq_ymm_k1z_xmmm64b16", Code.EVEX_VCVTTPH2UQQ_YMM_K1Z_XMMM64B16); + map.put("EVEX_Vcvttph2uqq_zmm_k1z_xmmm128b16_sae", Code.EVEX_VCVTTPH2UQQ_ZMM_K1Z_XMMM128B16_SAE); + map.put("EVEX_Vcvttph2uw_xmm_k1z_xmmm128b16", Code.EVEX_VCVTTPH2UW_XMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvttph2uw_ymm_k1z_ymmm256b16", Code.EVEX_VCVTTPH2UW_YMM_K1Z_YMMM256B16); + map.put("EVEX_Vcvttph2uw_zmm_k1z_zmmm512b16_sae", Code.EVEX_VCVTTPH2UW_ZMM_K1Z_ZMMM512B16_SAE); + map.put("EVEX_Vcvttph2w_xmm_k1z_xmmm128b16", Code.EVEX_VCVTTPH2W_XMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvttph2w_ymm_k1z_ymmm256b16", Code.EVEX_VCVTTPH2W_YMM_K1Z_YMMM256B16); + map.put("EVEX_Vcvttph2w_zmm_k1z_zmmm512b16_sae", Code.EVEX_VCVTTPH2W_ZMM_K1Z_ZMMM512B16_SAE); + map.put("EVEX_Vcvttsh2si_r32_xmmm16_sae", Code.EVEX_VCVTTSH2SI_R32_XMMM16_SAE); + map.put("EVEX_Vcvttsh2si_r64_xmmm16_sae", Code.EVEX_VCVTTSH2SI_R64_XMMM16_SAE); + map.put("EVEX_Vcvttsh2usi_r32_xmmm16_sae", Code.EVEX_VCVTTSH2USI_R32_XMMM16_SAE); + map.put("EVEX_Vcvttsh2usi_r64_xmmm16_sae", Code.EVEX_VCVTTSH2USI_R64_XMMM16_SAE); + map.put("EVEX_Vcvtudq2ph_xmm_k1z_xmmm128b32", Code.EVEX_VCVTUDQ2PH_XMM_K1Z_XMMM128B32); + map.put("EVEX_Vcvtudq2ph_xmm_k1z_ymmm256b32", Code.EVEX_VCVTUDQ2PH_XMM_K1Z_YMMM256B32); + map.put("EVEX_Vcvtudq2ph_ymm_k1z_zmmm512b32_er", Code.EVEX_VCVTUDQ2PH_YMM_K1Z_ZMMM512B32_ER); + map.put("EVEX_Vcvtuqq2ph_xmm_k1z_xmmm128b64", Code.EVEX_VCVTUQQ2PH_XMM_K1Z_XMMM128B64); + map.put("EVEX_Vcvtuqq2ph_xmm_k1z_ymmm256b64", Code.EVEX_VCVTUQQ2PH_XMM_K1Z_YMMM256B64); + map.put("EVEX_Vcvtuqq2ph_xmm_k1z_zmmm512b64_er", Code.EVEX_VCVTUQQ2PH_XMM_K1Z_ZMMM512B64_ER); + map.put("EVEX_Vcvtusi2sh_xmm_xmm_rm32_er", Code.EVEX_VCVTUSI2SH_XMM_XMM_RM32_ER); + map.put("EVEX_Vcvtusi2sh_xmm_xmm_rm64_er", Code.EVEX_VCVTUSI2SH_XMM_XMM_RM64_ER); + map.put("EVEX_Vcvtuw2ph_xmm_k1z_xmmm128b16", Code.EVEX_VCVTUW2PH_XMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvtuw2ph_ymm_k1z_ymmm256b16", Code.EVEX_VCVTUW2PH_YMM_K1Z_YMMM256B16); + map.put("EVEX_Vcvtuw2ph_zmm_k1z_zmmm512b16_er", Code.EVEX_VCVTUW2PH_ZMM_K1Z_ZMMM512B16_ER); + map.put("EVEX_Vcvtw2ph_xmm_k1z_xmmm128b16", Code.EVEX_VCVTW2PH_XMM_K1Z_XMMM128B16); + map.put("EVEX_Vcvtw2ph_ymm_k1z_ymmm256b16", Code.EVEX_VCVTW2PH_YMM_K1Z_YMMM256B16); + map.put("EVEX_Vcvtw2ph_zmm_k1z_zmmm512b16_er", Code.EVEX_VCVTW2PH_ZMM_K1Z_ZMMM512B16_ER); + map.put("EVEX_Vdivph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VDIVPH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vdivph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VDIVPH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vdivph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VDIVPH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vdivsh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VDIVSH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfcmaddcph_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFCMADDCPH_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfcmaddcph_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFCMADDCPH_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfcmaddcph_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFCMADDCPH_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmaddcph_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMADDCPH_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmaddcph_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMADDCPH_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmaddcph_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMADDCPH_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfcmaddcsh_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFCMADDCSH_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfmaddcsh_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFMADDCSH_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfcmulcph_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFCMULCPH_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfcmulcph_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFCMULCPH_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfcmulcph_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFCMULCPH_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfmulcph_xmm_k1z_xmm_xmmm128b32", Code.EVEX_VFMULCPH_XMM_K1Z_XMM_XMMM128B32); + map.put("EVEX_Vfmulcph_ymm_k1z_ymm_ymmm256b32", Code.EVEX_VFMULCPH_YMM_K1Z_YMM_YMMM256B32); + map.put("EVEX_Vfmulcph_zmm_k1z_zmm_zmmm512b32_er", Code.EVEX_VFMULCPH_ZMM_K1Z_ZMM_ZMMM512B32_ER); + map.put("EVEX_Vfcmulcsh_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFCMULCSH_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfmulcsh_xmm_k1z_xmm_xmmm32_er", Code.EVEX_VFMULCSH_XMM_K1Z_XMM_XMMM32_ER); + map.put("EVEX_Vfmaddsub132ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMADDSUB132PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmaddsub132ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMADDSUB132PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmaddsub132ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMADDSUB132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmaddsub213ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMADDSUB213PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmaddsub213ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMADDSUB213PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmaddsub213ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMADDSUB213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmaddsub231ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMADDSUB231PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmaddsub231ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMADDSUB231PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmaddsub231ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMADDSUB231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmsubadd132ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMSUBADD132PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmsubadd132ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMSUBADD132PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmsubadd132ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMSUBADD132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmsubadd213ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMSUBADD213PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmsubadd213ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMSUBADD213PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmsubadd213ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMSUBADD213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmsubadd231ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMSUBADD231PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmsubadd231ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMSUBADD231PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmsubadd231ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMSUBADD231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmadd132ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMADD132PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmadd132ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMADD132PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmadd132ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMADD132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmadd213ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMADD213PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmadd213ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMADD213PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmadd213ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMADD213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmadd231ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMADD231PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmadd231ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMADD231PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmadd231ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMADD231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfnmadd132ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFNMADD132PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfnmadd132ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFNMADD132PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfnmadd132ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFNMADD132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfnmadd213ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFNMADD213PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfnmadd213ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFNMADD213PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfnmadd213ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFNMADD213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfnmadd231ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFNMADD231PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfnmadd231ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFNMADD231PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfnmadd231ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFNMADD231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmadd132sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFMADD132SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfmadd213sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFMADD213SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfmadd231sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFMADD231SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfnmadd132sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFNMADD132SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfnmadd213sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFNMADD213SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfnmadd231sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFNMADD231SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfmsub132ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMSUB132PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmsub132ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMSUB132PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmsub132ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMSUB132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmsub213ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMSUB213PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmsub213ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMSUB213PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmsub213ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMSUB213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmsub231ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFMSUB231PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfmsub231ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFMSUB231PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfmsub231ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFMSUB231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfnmsub132ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFNMSUB132PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfnmsub132ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFNMSUB132PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfnmsub132ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFNMSUB132PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfnmsub213ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFNMSUB213PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfnmsub213ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFNMSUB213PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfnmsub213ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFNMSUB213PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfnmsub231ph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VFNMSUB231PH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vfnmsub231ph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VFNMSUB231PH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vfnmsub231ph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VFNMSUB231PH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vfmsub132sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFMSUB132SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfmsub213sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFMSUB213SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfmsub231sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFMSUB231SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfnmsub132sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFNMSUB132SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfnmsub213sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFNMSUB213SH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vfnmsub231sh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VFNMSUB231SH_XMM_K1Z_XMM_XMMM16_ER); + } + + private static void initMap9(HashMap map) { + map.put("EVEX_Vfpclassph_kr_k1_xmmm128b16_imm8", Code.EVEX_VFPCLASSPH_KR_K1_XMMM128B16_IMM8); + map.put("EVEX_Vfpclassph_kr_k1_ymmm256b16_imm8", Code.EVEX_VFPCLASSPH_KR_K1_YMMM256B16_IMM8); + map.put("EVEX_Vfpclassph_kr_k1_zmmm512b16_imm8", Code.EVEX_VFPCLASSPH_KR_K1_ZMMM512B16_IMM8); + map.put("EVEX_Vfpclasssh_kr_k1_xmmm16_imm8", Code.EVEX_VFPCLASSSH_KR_K1_XMMM16_IMM8); + map.put("EVEX_Vgetexpph_xmm_k1z_xmmm128b16", Code.EVEX_VGETEXPPH_XMM_K1Z_XMMM128B16); + map.put("EVEX_Vgetexpph_ymm_k1z_ymmm256b16", Code.EVEX_VGETEXPPH_YMM_K1Z_YMMM256B16); + map.put("EVEX_Vgetexpph_zmm_k1z_zmmm512b16_sae", Code.EVEX_VGETEXPPH_ZMM_K1Z_ZMMM512B16_SAE); + map.put("EVEX_Vgetexpsh_xmm_k1z_xmm_xmmm16_sae", Code.EVEX_VGETEXPSH_XMM_K1Z_XMM_XMMM16_SAE); + map.put("EVEX_Vgetmantph_xmm_k1z_xmmm128b16_imm8", Code.EVEX_VGETMANTPH_XMM_K1Z_XMMM128B16_IMM8); + map.put("EVEX_Vgetmantph_ymm_k1z_ymmm256b16_imm8", Code.EVEX_VGETMANTPH_YMM_K1Z_YMMM256B16_IMM8); + map.put("EVEX_Vgetmantph_zmm_k1z_zmmm512b16_imm8_sae", Code.EVEX_VGETMANTPH_ZMM_K1Z_ZMMM512B16_IMM8_SAE); + map.put("EVEX_Vgetmantsh_xmm_k1z_xmm_xmmm16_imm8_sae", Code.EVEX_VGETMANTSH_XMM_K1Z_XMM_XMMM16_IMM8_SAE); + map.put("EVEX_Vmaxph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VMAXPH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vmaxph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VMAXPH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vmaxph_zmm_k1z_zmm_zmmm512b16_sae", Code.EVEX_VMAXPH_ZMM_K1Z_ZMM_ZMMM512B16_SAE); + map.put("EVEX_Vmaxsh_xmm_k1z_xmm_xmmm16_sae", Code.EVEX_VMAXSH_XMM_K1Z_XMM_XMMM16_SAE); + map.put("EVEX_Vminph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VMINPH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vminph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VMINPH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vminph_zmm_k1z_zmm_zmmm512b16_sae", Code.EVEX_VMINPH_ZMM_K1Z_ZMM_ZMMM512B16_SAE); + map.put("EVEX_Vminsh_xmm_k1z_xmm_xmmm16_sae", Code.EVEX_VMINSH_XMM_K1Z_XMM_XMMM16_SAE); + map.put("EVEX_Vmovsh_xmm_k1z_m16", Code.EVEX_VMOVSH_XMM_K1Z_M16); + map.put("EVEX_Vmovsh_m16_k1_xmm", Code.EVEX_VMOVSH_M16_K1_XMM); + map.put("EVEX_Vmovsh_xmm_k1z_xmm_xmm", Code.EVEX_VMOVSH_XMM_K1Z_XMM_XMM); + map.put("EVEX_Vmovsh_xmm_k1z_xmm_xmm_MAP5_11", Code.EVEX_VMOVSH_XMM_K1Z_XMM_XMM_MAP5_11); + map.put("EVEX_Vmovw_xmm_r32m16", Code.EVEX_VMOVW_XMM_R32M16); + map.put("EVEX_Vmovw_xmm_r64m16", Code.EVEX_VMOVW_XMM_R64M16); + map.put("EVEX_Vmovw_r32m16_xmm", Code.EVEX_VMOVW_R32M16_XMM); + map.put("EVEX_Vmovw_r64m16_xmm", Code.EVEX_VMOVW_R64M16_XMM); + map.put("EVEX_Vmulph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VMULPH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vmulph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VMULPH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vmulph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VMULPH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vmulsh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VMULSH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vrcpph_xmm_k1z_xmmm128b16", Code.EVEX_VRCPPH_XMM_K1Z_XMMM128B16); + map.put("EVEX_Vrcpph_ymm_k1z_ymmm256b16", Code.EVEX_VRCPPH_YMM_K1Z_YMMM256B16); + map.put("EVEX_Vrcpph_zmm_k1z_zmmm512b16", Code.EVEX_VRCPPH_ZMM_K1Z_ZMMM512B16); + map.put("EVEX_Vrcpsh_xmm_k1z_xmm_xmmm16", Code.EVEX_VRCPSH_XMM_K1Z_XMM_XMMM16); + map.put("EVEX_Vreduceph_xmm_k1z_xmmm128b16_imm8", Code.EVEX_VREDUCEPH_XMM_K1Z_XMMM128B16_IMM8); + map.put("EVEX_Vreduceph_ymm_k1z_ymmm256b16_imm8", Code.EVEX_VREDUCEPH_YMM_K1Z_YMMM256B16_IMM8); + map.put("EVEX_Vreduceph_zmm_k1z_zmmm512b16_imm8_sae", Code.EVEX_VREDUCEPH_ZMM_K1Z_ZMMM512B16_IMM8_SAE); + map.put("EVEX_Vreducesh_xmm_k1z_xmm_xmmm16_imm8_sae", Code.EVEX_VREDUCESH_XMM_K1Z_XMM_XMMM16_IMM8_SAE); + map.put("EVEX_Vrndscaleph_xmm_k1z_xmmm128b16_imm8", Code.EVEX_VRNDSCALEPH_XMM_K1Z_XMMM128B16_IMM8); + map.put("EVEX_Vrndscaleph_ymm_k1z_ymmm256b16_imm8", Code.EVEX_VRNDSCALEPH_YMM_K1Z_YMMM256B16_IMM8); + map.put("EVEX_Vrndscaleph_zmm_k1z_zmmm512b16_imm8_sae", Code.EVEX_VRNDSCALEPH_ZMM_K1Z_ZMMM512B16_IMM8_SAE); + map.put("EVEX_Vrndscalesh_xmm_k1z_xmm_xmmm16_imm8_sae", Code.EVEX_VRNDSCALESH_XMM_K1Z_XMM_XMMM16_IMM8_SAE); + map.put("EVEX_Vrsqrtph_xmm_k1z_xmmm128b16", Code.EVEX_VRSQRTPH_XMM_K1Z_XMMM128B16); + map.put("EVEX_Vrsqrtph_ymm_k1z_ymmm256b16", Code.EVEX_VRSQRTPH_YMM_K1Z_YMMM256B16); + map.put("EVEX_Vrsqrtph_zmm_k1z_zmmm512b16", Code.EVEX_VRSQRTPH_ZMM_K1Z_ZMMM512B16); + map.put("EVEX_Vrsqrtsh_xmm_k1z_xmm_xmmm16", Code.EVEX_VRSQRTSH_XMM_K1Z_XMM_XMMM16); + map.put("EVEX_Vscalefph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VSCALEFPH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vscalefph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VSCALEFPH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vscalefph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VSCALEFPH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vscalefsh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VSCALEFSH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vsqrtph_xmm_k1z_xmmm128b16", Code.EVEX_VSQRTPH_XMM_K1Z_XMMM128B16); + map.put("EVEX_Vsqrtph_ymm_k1z_ymmm256b16", Code.EVEX_VSQRTPH_YMM_K1Z_YMMM256B16); + map.put("EVEX_Vsqrtph_zmm_k1z_zmmm512b16_er", Code.EVEX_VSQRTPH_ZMM_K1Z_ZMMM512B16_ER); + map.put("EVEX_Vsqrtsh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VSQRTSH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vsubph_xmm_k1z_xmm_xmmm128b16", Code.EVEX_VSUBPH_XMM_K1Z_XMM_XMMM128B16); + map.put("EVEX_Vsubph_ymm_k1z_ymm_ymmm256b16", Code.EVEX_VSUBPH_YMM_K1Z_YMM_YMMM256B16); + map.put("EVEX_Vsubph_zmm_k1z_zmm_zmmm512b16_er", Code.EVEX_VSUBPH_ZMM_K1Z_ZMM_ZMMM512B16_ER); + map.put("EVEX_Vsubsh_xmm_k1z_xmm_xmmm16_er", Code.EVEX_VSUBSH_XMM_K1Z_XMM_XMMM16_ER); + map.put("EVEX_Vucomish_xmm_xmmm16_sae", Code.EVEX_VUCOMISH_XMM_XMMM16_SAE); + map.put("Rdudbg", Code.RDUDBG); + map.put("Wrudbg", Code.WRUDBG); + map.put("VEX_KNC_Jkzd_kr_rel8_64", Code.VEX_KNC_JKZD_KR_REL8_64); + map.put("VEX_KNC_Jknzd_kr_rel8_64", Code.VEX_KNC_JKNZD_KR_REL8_64); + map.put("VEX_KNC_Vprefetchnta_m8", Code.VEX_KNC_VPREFETCHNTA_M8); + map.put("VEX_KNC_Vprefetch0_m8", Code.VEX_KNC_VPREFETCH0_M8); + map.put("VEX_KNC_Vprefetch1_m8", Code.VEX_KNC_VPREFETCH1_M8); + map.put("VEX_KNC_Vprefetch2_m8", Code.VEX_KNC_VPREFETCH2_M8); + map.put("VEX_KNC_Vprefetchenta_m8", Code.VEX_KNC_VPREFETCHENTA_M8); + map.put("VEX_KNC_Vprefetche0_m8", Code.VEX_KNC_VPREFETCHE0_M8); + map.put("VEX_KNC_Vprefetche1_m8", Code.VEX_KNC_VPREFETCHE1_M8); + map.put("VEX_KNC_Vprefetche2_m8", Code.VEX_KNC_VPREFETCHE2_M8); + map.put("VEX_KNC_Kand_kr_kr", Code.VEX_KNC_KAND_KR_KR); + map.put("VEX_KNC_Kandn_kr_kr", Code.VEX_KNC_KANDN_KR_KR); + map.put("VEX_KNC_Kandnr_kr_kr", Code.VEX_KNC_KANDNR_KR_KR); + map.put("VEX_KNC_Knot_kr_kr", Code.VEX_KNC_KNOT_KR_KR); + map.put("VEX_KNC_Kor_kr_kr", Code.VEX_KNC_KOR_KR_KR); + map.put("VEX_KNC_Kxnor_kr_kr", Code.VEX_KNC_KXNOR_KR_KR); + map.put("VEX_KNC_Kxor_kr_kr", Code.VEX_KNC_KXOR_KR_KR); + map.put("VEX_KNC_Kmerge2l1h_kr_kr", Code.VEX_KNC_KMERGE2L1H_KR_KR); + map.put("VEX_KNC_Kmerge2l1l_kr_kr", Code.VEX_KNC_KMERGE2L1L_KR_KR); + map.put("VEX_KNC_Jkzd_kr_rel32_64", Code.VEX_KNC_JKZD_KR_REL32_64); + map.put("VEX_KNC_Jknzd_kr_rel32_64", Code.VEX_KNC_JKNZD_KR_REL32_64); + map.put("VEX_KNC_Kmov_kr_kr", Code.VEX_KNC_KMOV_KR_KR); + map.put("VEX_KNC_Kmov_kr_r32", Code.VEX_KNC_KMOV_KR_R32); + map.put("VEX_KNC_Kmov_r32_kr", Code.VEX_KNC_KMOV_R32_KR); + map.put("VEX_KNC_Kconcath_r64_kr_kr", Code.VEX_KNC_KCONCATH_R64_KR_KR); + map.put("VEX_KNC_Kconcatl_r64_kr_kr", Code.VEX_KNC_KCONCATL_R64_KR_KR); + map.put("VEX_KNC_Kortest_kr_kr", Code.VEX_KNC_KORTEST_KR_KR); + map.put("VEX_KNC_Delay_r32", Code.VEX_KNC_DELAY_R32); + map.put("VEX_KNC_Delay_r64", Code.VEX_KNC_DELAY_R64); + map.put("VEX_KNC_Spflt_r32", Code.VEX_KNC_SPFLT_R32); + map.put("VEX_KNC_Spflt_r64", Code.VEX_KNC_SPFLT_R64); + map.put("VEX_KNC_Clevict1_m8", Code.VEX_KNC_CLEVICT1_M8); + map.put("VEX_KNC_Clevict0_m8", Code.VEX_KNC_CLEVICT0_M8); + map.put("VEX_KNC_Popcnt_r32_r32", Code.VEX_KNC_POPCNT_R32_R32); + map.put("VEX_KNC_Popcnt_r64_r64", Code.VEX_KNC_POPCNT_R64_R64); + map.put("VEX_KNC_Tzcnt_r32_r32", Code.VEX_KNC_TZCNT_R32_R32); + map.put("VEX_KNC_Tzcnt_r64_r64", Code.VEX_KNC_TZCNT_R64_R64); + map.put("VEX_KNC_Tzcnti_r32_r32", Code.VEX_KNC_TZCNTI_R32_R32); + map.put("VEX_KNC_Tzcnti_r64_r64", Code.VEX_KNC_TZCNTI_R64_R64); + map.put("VEX_KNC_Lzcnt_r32_r32", Code.VEX_KNC_LZCNT_R32_R32); + map.put("VEX_KNC_Lzcnt_r64_r64", Code.VEX_KNC_LZCNT_R64_R64); + map.put("VEX_KNC_Undoc_r32_rm32_128_F3_0F38_W0_F0", Code.VEX_KNC_UNDOC_R32_RM32_128_F3_0F38_W0_F0); + map.put("VEX_KNC_Undoc_r64_rm64_128_F3_0F38_W1_F0", Code.VEX_KNC_UNDOC_R64_RM64_128_F3_0F38_W1_F0); + map.put("VEX_KNC_Undoc_r32_rm32_128_F2_0F38_W0_F0", Code.VEX_KNC_UNDOC_R32_RM32_128_F2_0F38_W0_F0); + map.put("VEX_KNC_Undoc_r64_rm64_128_F2_0F38_W1_F0", Code.VEX_KNC_UNDOC_R64_RM64_128_F2_0F38_W1_F0); + map.put("VEX_KNC_Undoc_r32_rm32_128_F2_0F38_W0_F1", Code.VEX_KNC_UNDOC_R32_RM32_128_F2_0F38_W0_F1); + map.put("VEX_KNC_Undoc_r64_rm64_128_F2_0F38_W1_F1", Code.VEX_KNC_UNDOC_R64_RM64_128_F2_0F38_W1_F1); + map.put("VEX_KNC_Kextract_kr_r64_imm8", Code.VEX_KNC_KEXTRACT_KR_R64_IMM8); + map.put("MVEX_Vprefetchnta_m", Code.MVEX_VPREFETCHNTA_M); + map.put("MVEX_Vprefetch0_m", Code.MVEX_VPREFETCH0_M); + map.put("MVEX_Vprefetch1_m", Code.MVEX_VPREFETCH1_M); + map.put("MVEX_Vprefetch2_m", Code.MVEX_VPREFETCH2_M); + map.put("MVEX_Vprefetchenta_m", Code.MVEX_VPREFETCHENTA_M); + map.put("MVEX_Vprefetche0_m", Code.MVEX_VPREFETCHE0_M); + map.put("MVEX_Vprefetche1_m", Code.MVEX_VPREFETCHE1_M); + map.put("MVEX_Vprefetche2_m", Code.MVEX_VPREFETCHE2_M); + map.put("MVEX_Vmovaps_zmm_k1_zmmmt", Code.MVEX_VMOVAPS_ZMM_K1_ZMMMT); + map.put("MVEX_Vmovapd_zmm_k1_zmmmt", Code.MVEX_VMOVAPD_ZMM_K1_ZMMMT); + map.put("MVEX_Vmovaps_mt_k1_zmm", Code.MVEX_VMOVAPS_MT_K1_ZMM); + map.put("MVEX_Vmovapd_mt_k1_zmm", Code.MVEX_VMOVAPD_MT_K1_ZMM); + map.put("MVEX_Vmovnrapd_m_k1_zmm", Code.MVEX_VMOVNRAPD_M_K1_ZMM); + map.put("MVEX_Vmovnrngoapd_m_k1_zmm", Code.MVEX_VMOVNRNGOAPD_M_K1_ZMM); + map.put("MVEX_Vmovnraps_m_k1_zmm", Code.MVEX_VMOVNRAPS_M_K1_ZMM); + map.put("MVEX_Vmovnrngoaps_m_k1_zmm", Code.MVEX_VMOVNRNGOAPS_M_K1_ZMM); + map.put("MVEX_Vaddps_zmm_k1_zmm_zmmmt", Code.MVEX_VADDPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vaddpd_zmm_k1_zmm_zmmmt", Code.MVEX_VADDPD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vmulps_zmm_k1_zmm_zmmmt", Code.MVEX_VMULPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vmulpd_zmm_k1_zmm_zmmmt", Code.MVEX_VMULPD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vcvtps2pd_zmm_k1_zmmmt", Code.MVEX_VCVTPS2PD_ZMM_K1_ZMMMT); + map.put("MVEX_Vcvtpd2ps_zmm_k1_zmmmt", Code.MVEX_VCVTPD2PS_ZMM_K1_ZMMMT); + map.put("MVEX_Vsubps_zmm_k1_zmm_zmmmt", Code.MVEX_VSUBPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vsubpd_zmm_k1_zmm_zmmmt", Code.MVEX_VSUBPD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpcmpgtd_kr_k1_zmm_zmmmt", Code.MVEX_VPCMPGTD_KR_K1_ZMM_ZMMMT); + map.put("MVEX_Vmovdqa32_zmm_k1_zmmmt", Code.MVEX_VMOVDQA32_ZMM_K1_ZMMMT); + map.put("MVEX_Vmovdqa64_zmm_k1_zmmmt", Code.MVEX_VMOVDQA64_ZMM_K1_ZMMMT); + map.put("MVEX_Vpshufd_zmm_k1_zmmmt_imm8", Code.MVEX_VPSHUFD_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vpsrld_zmm_k1_zmmmt_imm8", Code.MVEX_VPSRLD_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vpsrad_zmm_k1_zmmmt_imm8", Code.MVEX_VPSRAD_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vpslld_zmm_k1_zmmmt_imm8", Code.MVEX_VPSLLD_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vpcmpeqd_kr_k1_zmm_zmmmt", Code.MVEX_VPCMPEQD_KR_K1_ZMM_ZMMMT); + map.put("MVEX_Vcvtudq2pd_zmm_k1_zmmmt", Code.MVEX_VCVTUDQ2PD_ZMM_K1_ZMMMT); + map.put("MVEX_Vmovdqa32_mt_k1_zmm", Code.MVEX_VMOVDQA32_MT_K1_ZMM); + map.put("MVEX_Vmovdqa64_mt_k1_zmm", Code.MVEX_VMOVDQA64_MT_K1_ZMM); + map.put("MVEX_Clevict1_m", Code.MVEX_CLEVICT1_M); + map.put("MVEX_Clevict0_m", Code.MVEX_CLEVICT0_M); + map.put("MVEX_Vcmpps_kr_k1_zmm_zmmmt_imm8", Code.MVEX_VCMPPS_KR_K1_ZMM_ZMMMT_IMM8); + map.put("MVEX_Vcmppd_kr_k1_zmm_zmmmt_imm8", Code.MVEX_VCMPPD_KR_K1_ZMM_ZMMMT_IMM8); + map.put("MVEX_Vpandd_zmm_k1_zmm_zmmmt", Code.MVEX_VPANDD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpandq_zmm_k1_zmm_zmmmt", Code.MVEX_VPANDQ_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpandnd_zmm_k1_zmm_zmmmt", Code.MVEX_VPANDND_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpandnq_zmm_k1_zmm_zmmmt", Code.MVEX_VPANDNQ_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vcvtdq2pd_zmm_k1_zmmmt", Code.MVEX_VCVTDQ2PD_ZMM_K1_ZMMMT); + map.put("MVEX_Vpord_zmm_k1_zmm_zmmmt", Code.MVEX_VPORD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vporq_zmm_k1_zmm_zmmmt", Code.MVEX_VPORQ_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpxord_zmm_k1_zmm_zmmmt", Code.MVEX_VPXORD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpxorq_zmm_k1_zmm_zmmmt", Code.MVEX_VPXORQ_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpsubd_zmm_k1_zmm_zmmmt", Code.MVEX_VPSUBD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpaddd_zmm_k1_zmm_zmmmt", Code.MVEX_VPADDD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vbroadcastss_zmm_k1_mt", Code.MVEX_VBROADCASTSS_ZMM_K1_MT); + map.put("MVEX_Vbroadcastsd_zmm_k1_mt", Code.MVEX_VBROADCASTSD_ZMM_K1_MT); + map.put("MVEX_Vbroadcastf32x4_zmm_k1_mt", Code.MVEX_VBROADCASTF32X4_ZMM_K1_MT); + map.put("MVEX_Vbroadcastf64x4_zmm_k1_mt", Code.MVEX_VBROADCASTF64X4_ZMM_K1_MT); + map.put("MVEX_Vptestmd_kr_k1_zmm_zmmmt", Code.MVEX_VPTESTMD_KR_K1_ZMM_ZMMMT); + map.put("MVEX_Vpermd_zmm_k1_zmm_zmmmt", Code.MVEX_VPERMD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpminsd_zmm_k1_zmm_zmmmt", Code.MVEX_VPMINSD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpminud_zmm_k1_zmm_zmmmt", Code.MVEX_VPMINUD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpmaxsd_zmm_k1_zmm_zmmmt", Code.MVEX_VPMAXSD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpmaxud_zmm_k1_zmm_zmmmt", Code.MVEX_VPMAXUD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpmulld_zmm_k1_zmm_zmmmt", Code.MVEX_VPMULLD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vgetexpps_zmm_k1_zmmmt", Code.MVEX_VGETEXPPS_ZMM_K1_ZMMMT); + map.put("MVEX_Vgetexppd_zmm_k1_zmmmt", Code.MVEX_VGETEXPPD_ZMM_K1_ZMMMT); + map.put("MVEX_Vpsrlvd_zmm_k1_zmm_zmmmt", Code.MVEX_VPSRLVD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpsravd_zmm_k1_zmm_zmmmt", Code.MVEX_VPSRAVD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpsllvd_zmm_k1_zmm_zmmmt", Code.MVEX_VPSLLVD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_48", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_66_0F38_W0_48); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_49", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_66_0F38_W0_49); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_4A", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_66_0F38_W0_4A); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_4B", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_66_0F38_W0_4B); + map.put("MVEX_Vaddnps_zmm_k1_zmm_zmmmt", Code.MVEX_VADDNPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vaddnpd_zmm_k1_zmm_zmmmt", Code.MVEX_VADDNPD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vgmaxabsps_zmm_k1_zmm_zmmmt", Code.MVEX_VGMAXABSPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vgminps_zmm_k1_zmm_zmmmt", Code.MVEX_VGMINPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vgminpd_zmm_k1_zmm_zmmmt", Code.MVEX_VGMINPD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vgmaxps_zmm_k1_zmm_zmmmt", Code.MVEX_VGMAXPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vgmaxpd_zmm_k1_zmm_zmmmt", Code.MVEX_VGMAXPD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_54", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_54); + map.put("MVEX_Vfixupnanps_zmm_k1_zmm_zmmmt", Code.MVEX_VFIXUPNANPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfixupnanpd_zmm_k1_zmm_zmmmt", Code.MVEX_VFIXUPNANPD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_56", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_56); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_57", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_57); + map.put("MVEX_Vpbroadcastd_zmm_k1_mt", Code.MVEX_VPBROADCASTD_ZMM_K1_MT); + map.put("MVEX_Vpbroadcastq_zmm_k1_mt", Code.MVEX_VPBROADCASTQ_ZMM_K1_MT); + map.put("MVEX_Vbroadcasti32x4_zmm_k1_mt", Code.MVEX_VBROADCASTI32X4_ZMM_K1_MT); + map.put("MVEX_Vbroadcasti64x4_zmm_k1_mt", Code.MVEX_VBROADCASTI64X4_ZMM_K1_MT); + map.put("MVEX_Vpadcd_zmm_k1_kr_zmmmt", Code.MVEX_VPADCD_ZMM_K1_KR_ZMMMT); + map.put("MVEX_Vpaddsetcd_zmm_k1_kr_zmmmt", Code.MVEX_VPADDSETCD_ZMM_K1_KR_ZMMMT); + map.put("MVEX_Vpsbbd_zmm_k1_kr_zmmmt", Code.MVEX_VPSBBD_ZMM_K1_KR_ZMMMT); + map.put("MVEX_Vpsubsetbd_zmm_k1_kr_zmmmt", Code.MVEX_VPSUBSETBD_ZMM_K1_KR_ZMMMT); + map.put("MVEX_Vpblendmd_zmm_k1_zmm_zmmmt", Code.MVEX_VPBLENDMD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpblendmq_zmm_k1_zmm_zmmmt", Code.MVEX_VPBLENDMQ_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vblendmps_zmm_k1_zmm_zmmmt", Code.MVEX_VBLENDMPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vblendmpd_zmm_k1_zmm_zmmmt", Code.MVEX_VBLENDMPD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_67", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_67); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_68", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_66_0F38_W0_68); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_69", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_66_0F38_W0_69); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_6A", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_66_0F38_W0_6A); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_6B", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_66_0F38_W0_6B); + map.put("MVEX_Vpsubrd_zmm_k1_zmm_zmmmt", Code.MVEX_VPSUBRD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vsubrps_zmm_k1_zmm_zmmmt", Code.MVEX_VSUBRPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vsubrpd_zmm_k1_zmm_zmmmt", Code.MVEX_VSUBRPD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpsbbrd_zmm_k1_kr_zmmmt", Code.MVEX_VPSBBRD_ZMM_K1_KR_ZMMMT); + map.put("MVEX_Vpsubrsetbd_zmm_k1_kr_zmmmt", Code.MVEX_VPSUBRSETBD_ZMM_K1_KR_ZMMMT); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_70", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_70); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_71", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_71); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_72", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_72); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_73", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_73); + map.put("MVEX_Vpcmpltd_kr_k1_zmm_zmmmt", Code.MVEX_VPCMPLTD_KR_K1_ZMM_ZMMMT); + map.put("MVEX_Vscaleps_zmm_k1_zmm_zmmmt", Code.MVEX_VSCALEPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpmulhud_zmm_k1_zmm_zmmmt", Code.MVEX_VPMULHUD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpmulhd_zmm_k1_zmm_zmmmt", Code.MVEX_VPMULHD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpgatherdd_zmm_k1_mvt", Code.MVEX_VPGATHERDD_ZMM_K1_MVT); + map.put("MVEX_Vpgatherdq_zmm_k1_mvt", Code.MVEX_VPGATHERDQ_ZMM_K1_MVT); + map.put("MVEX_Vgatherdps_zmm_k1_mvt", Code.MVEX_VGATHERDPS_ZMM_K1_MVT); + map.put("MVEX_Vgatherdpd_zmm_k1_mvt", Code.MVEX_VGATHERDPD_ZMM_K1_MVT); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_94", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_94); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W1_94", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W1_94); + map.put("MVEX_Vfmadd132ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFMADD132PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmadd132pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFMADD132PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmsub132ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFMSUB132PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmsub132pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFMSUB132PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmadd132ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMADD132PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmadd132pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMADD132PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmsub132ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMSUB132PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmsub132pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMSUB132PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpscatterdd_mvt_k1_zmm", Code.MVEX_VPSCATTERDD_MVT_K1_ZMM); + map.put("MVEX_Vpscatterdq_mvt_k1_zmm", Code.MVEX_VPSCATTERDQ_MVT_K1_ZMM); + map.put("MVEX_Vscatterdps_mvt_k1_zmm", Code.MVEX_VSCATTERDPS_MVT_K1_ZMM); + map.put("MVEX_Vscatterdpd_mvt_k1_zmm", Code.MVEX_VSCATTERDPD_MVT_K1_ZMM); + map.put("MVEX_Vfmadd233ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFMADD233PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmadd213ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFMADD213PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmadd213pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFMADD213PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmsub213ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFMSUB213PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmsub213pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFMSUB213PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmadd213ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMADD213PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmadd213pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMADD213PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmsub213ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMSUB213PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmsub213pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMSUB213PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_B0", Code.MVEX_UNDOC_ZMM_K1_MVT_512_66_0F38_W0_B0); + map.put("MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_B2", Code.MVEX_UNDOC_ZMM_K1_MVT_512_66_0F38_W0_B2); + map.put("MVEX_Vpmadd233d_zmm_k1_zmm_zmmmt", Code.MVEX_VPMADD233D_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpmadd231d_zmm_k1_zmm_zmmmt", Code.MVEX_VPMADD231D_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmadd231ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFMADD231PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmadd231pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFMADD231PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmsub231ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFMSUB231PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfmsub231pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFMSUB231PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmadd231ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMADD231PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmadd231pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMADD231PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmsub231ps_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMSUB231PS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vfnmsub231pd_zmm_k1_zmm_zmmmt", Code.MVEX_VFNMSUB231PD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Undoc_zmm_k1_mvt_512_66_0F38_W0_C0", Code.MVEX_UNDOC_ZMM_K1_MVT_512_66_0F38_W0_C0); + map.put("MVEX_Vgatherpf0hintdps_mvt_k1", Code.MVEX_VGATHERPF0HINTDPS_MVT_K1); + map.put("MVEX_Vgatherpf0hintdpd_mvt_k1", Code.MVEX_VGATHERPF0HINTDPD_MVT_K1); + map.put("MVEX_Vgatherpf0dps_mvt_k1", Code.MVEX_VGATHERPF0DPS_MVT_K1); + map.put("MVEX_Vgatherpf1dps_mvt_k1", Code.MVEX_VGATHERPF1DPS_MVT_K1); + map.put("MVEX_Vscatterpf0hintdps_mvt_k1", Code.MVEX_VSCATTERPF0HINTDPS_MVT_K1); + map.put("MVEX_Vscatterpf0hintdpd_mvt_k1", Code.MVEX_VSCATTERPF0HINTDPD_MVT_K1); + map.put("MVEX_Vscatterpf0dps_mvt_k1", Code.MVEX_VSCATTERPF0DPS_MVT_K1); + map.put("MVEX_Vscatterpf1dps_mvt_k1", Code.MVEX_VSCATTERPF1DPS_MVT_K1); + map.put("MVEX_Vexp223ps_zmm_k1_zmmmt", Code.MVEX_VEXP223PS_ZMM_K1_ZMMMT); + map.put("MVEX_Vlog2ps_zmm_k1_zmmmt", Code.MVEX_VLOG2PS_ZMM_K1_ZMMMT); + map.put("MVEX_Vrcp23ps_zmm_k1_zmmmt", Code.MVEX_VRCP23PS_ZMM_K1_ZMMMT); + map.put("MVEX_Vrsqrt23ps_zmm_k1_zmmmt", Code.MVEX_VRSQRT23PS_ZMM_K1_ZMMMT); + map.put("MVEX_Vaddsetsps_zmm_k1_zmm_zmmmt", Code.MVEX_VADDSETSPS_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Vpaddsetsd_zmm_k1_zmm_zmmmt", Code.MVEX_VPADDSETSD_ZMM_K1_ZMM_ZMMMT); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_CE", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_CE); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W1_CE", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W1_CE); + map.put("MVEX_Undoc_zmm_k1_zmm_zmmmt_512_66_0F38_W0_CF", Code.MVEX_UNDOC_ZMM_K1_ZMM_ZMMMT_512_66_0F38_W0_CF); + map.put("MVEX_Vloadunpackld_zmm_k1_mt", Code.MVEX_VLOADUNPACKLD_ZMM_K1_MT); + map.put("MVEX_Vloadunpacklq_zmm_k1_mt", Code.MVEX_VLOADUNPACKLQ_ZMM_K1_MT); + map.put("MVEX_Vpackstoreld_mt_k1_zmm", Code.MVEX_VPACKSTORELD_MT_K1_ZMM); + map.put("MVEX_Vpackstorelq_mt_k1_zmm", Code.MVEX_VPACKSTORELQ_MT_K1_ZMM); + map.put("MVEX_Vloadunpacklps_zmm_k1_mt", Code.MVEX_VLOADUNPACKLPS_ZMM_K1_MT); + map.put("MVEX_Vloadunpacklpd_zmm_k1_mt", Code.MVEX_VLOADUNPACKLPD_ZMM_K1_MT); + map.put("MVEX_Vpackstorelps_mt_k1_zmm", Code.MVEX_VPACKSTORELPS_MT_K1_ZMM); + map.put("MVEX_Vpackstorelpd_mt_k1_zmm", Code.MVEX_VPACKSTORELPD_MT_K1_ZMM); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D2", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_0F38_W0_D2); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_D2", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_66_0F38_W0_D2); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D3", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_0F38_W0_D3); + map.put("MVEX_Vloadunpackhd_zmm_k1_mt", Code.MVEX_VLOADUNPACKHD_ZMM_K1_MT); + map.put("MVEX_Vloadunpackhq_zmm_k1_mt", Code.MVEX_VLOADUNPACKHQ_ZMM_K1_MT); + map.put("MVEX_Vpackstorehd_mt_k1_zmm", Code.MVEX_VPACKSTOREHD_MT_K1_ZMM); + map.put("MVEX_Vpackstorehq_mt_k1_zmm", Code.MVEX_VPACKSTOREHQ_MT_K1_ZMM); + map.put("MVEX_Vloadunpackhps_zmm_k1_mt", Code.MVEX_VLOADUNPACKHPS_ZMM_K1_MT); + map.put("MVEX_Vloadunpackhpd_zmm_k1_mt", Code.MVEX_VLOADUNPACKHPD_ZMM_K1_MT); + map.put("MVEX_Vpackstorehps_mt_k1_zmm", Code.MVEX_VPACKSTOREHPS_MT_K1_ZMM); + map.put("MVEX_Vpackstorehpd_mt_k1_zmm", Code.MVEX_VPACKSTOREHPD_MT_K1_ZMM); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D6", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_0F38_W0_D6); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_66_0F38_W0_D6", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_66_0F38_W0_D6); + map.put("MVEX_Undoc_zmm_k1_zmmmt_512_0F38_W0_D7", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_512_0F38_W0_D7); + map.put("MVEX_Valignd_zmm_k1_zmm_zmmmt_imm8", Code.MVEX_VALIGND_ZMM_K1_ZMM_ZMMMT_IMM8); + map.put("MVEX_Vpermf32x4_zmm_k1_zmmmt_imm8", Code.MVEX_VPERMF32X4_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vpcmpud_kr_k1_zmm_zmmmt_imm8", Code.MVEX_VPCMPUD_KR_K1_ZMM_ZMMMT_IMM8); + map.put("MVEX_Vpcmpd_kr_k1_zmm_zmmmt_imm8", Code.MVEX_VPCMPD_KR_K1_ZMM_ZMMMT_IMM8); + map.put("MVEX_Vgetmantps_zmm_k1_zmmmt_imm8", Code.MVEX_VGETMANTPS_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vgetmantpd_zmm_k1_zmmmt_imm8", Code.MVEX_VGETMANTPD_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vrndfxpntps_zmm_k1_zmmmt_imm8", Code.MVEX_VRNDFXPNTPS_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vrndfxpntpd_zmm_k1_zmmmt_imm8", Code.MVEX_VRNDFXPNTPD_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vcvtfxpntudq2ps_zmm_k1_zmmmt_imm8", Code.MVEX_VCVTFXPNTUDQ2PS_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vcvtfxpntps2udq_zmm_k1_zmmmt_imm8", Code.MVEX_VCVTFXPNTPS2UDQ_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vcvtfxpntpd2udq_zmm_k1_zmmmt_imm8", Code.MVEX_VCVTFXPNTPD2UDQ_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vcvtfxpntdq2ps_zmm_k1_zmmmt_imm8", Code.MVEX_VCVTFXPNTDQ2PS_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Vcvtfxpntps2dq_zmm_k1_zmmmt_imm8", Code.MVEX_VCVTFXPNTPS2DQ_ZMM_K1_ZMMMT_IMM8); + map.put("MVEX_Undoc_zmm_k1_zmmmt_imm8_512_66_0F3A_W0_D0", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_IMM8_512_66_0F3A_W0_D0); + map.put("MVEX_Undoc_zmm_k1_zmmmt_imm8_512_66_0F3A_W0_D1", Code.MVEX_UNDOC_ZMM_K1_ZMMMT_IMM8_512_66_0F3A_W0_D1); + map.put("MVEX_Vcvtfxpntpd2dq_zmm_k1_zmmmt_imm8", Code.MVEX_VCVTFXPNTPD2DQ_ZMM_K1_ZMMMT_IMM8); + map.put("Via_undoc_F30FA6F0_16", Code.VIA_UNDOC_F30FA6F0_16); + map.put("Via_undoc_F30FA6F0_32", Code.VIA_UNDOC_F30FA6F0_32); + map.put("Via_undoc_F30FA6F0_64", Code.VIA_UNDOC_F30FA6F0_64); + map.put("Via_undoc_F30FA6F8_16", Code.VIA_UNDOC_F30FA6F8_16); + map.put("Via_undoc_F30FA6F8_32", Code.VIA_UNDOC_F30FA6F8_32); + map.put("Via_undoc_F30FA6F8_64", Code.VIA_UNDOC_F30FA6F8_64); + map.put("Xsha512_16", Code.XSHA512_16); + map.put("Xsha512_32", Code.XSHA512_32); + map.put("Xsha512_64", Code.XSHA512_64); + map.put("Xstore_alt_16", Code.XSTORE_ALT_16); + map.put("Xstore_alt_32", Code.XSTORE_ALT_32); + map.put("Xstore_alt_64", Code.XSTORE_ALT_64); + map.put("Xsha512_alt_16", Code.XSHA512_ALT_16); + map.put("Xsha512_alt_32", Code.XSHA512_ALT_32); + map.put("Xsha512_alt_64", Code.XSHA512_ALT_64); + map.put("Zero_bytes", Code.ZERO_BYTES); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToConditionCode.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToConditionCode.java new file mode 100644 index 000000000..b3936041b --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToConditionCode.java @@ -0,0 +1,66 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToConditionCode { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant ConditionCode.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(17); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("None", ConditionCode.NONE); + map.put("o", ConditionCode.O); + map.put("no", ConditionCode.NO); + map.put("b", ConditionCode.B); + map.put("ae", ConditionCode.AE); + map.put("e", ConditionCode.E); + map.put("ne", ConditionCode.NE); + map.put("be", ConditionCode.BE); + map.put("a", ConditionCode.A); + map.put("s", ConditionCode.S); + map.put("ns", ConditionCode.NS); + map.put("p", ConditionCode.P); + map.put("np", ConditionCode.NP); + map.put("l", ConditionCode.L); + map.put("ge", ConditionCode.GE); + map.put("le", ConditionCode.LE); + map.put("g", ConditionCode.G); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCpuidFeature.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCpuidFeature.java new file mode 100644 index 000000000..e3deb4eb2 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToCpuidFeature.java @@ -0,0 +1,211 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToCpuidFeature { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant CpuidFeature.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(162); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("INTEL8086", CpuidFeature.INTEL8086); + map.put("INTEL8086_ONLY", CpuidFeature.INTEL8086_ONLY); + map.put("INTEL186", CpuidFeature.INTEL186); + map.put("INTEL286", CpuidFeature.INTEL286); + map.put("INTEL286_ONLY", CpuidFeature.INTEL286_ONLY); + map.put("INTEL386", CpuidFeature.INTEL386); + map.put("INTEL386_ONLY", CpuidFeature.INTEL386_ONLY); + map.put("INTEL386_A0_ONLY", CpuidFeature.INTEL386_A0_ONLY); + map.put("INTEL486", CpuidFeature.INTEL486); + map.put("INTEL486_A_ONLY", CpuidFeature.INTEL486_A_ONLY); + map.put("UMOV", CpuidFeature.UMOV); + map.put("IA64", CpuidFeature.IA64); + map.put("X64", CpuidFeature.X64); + map.put("ADX", CpuidFeature.ADX); + map.put("AES", CpuidFeature.AES); + map.put("AVX", CpuidFeature.AVX); + map.put("AVX2", CpuidFeature.AVX2); + map.put("AVX512_4FMAPS", CpuidFeature.AVX512_4FMAPS); + map.put("AVX512_4VNNIW", CpuidFeature.AVX512_4VNNIW); + map.put("AVX512_BF16", CpuidFeature.AVX512_BF16); + map.put("AVX512_BITALG", CpuidFeature.AVX512_BITALG); + map.put("AVX512_IFMA", CpuidFeature.AVX512_IFMA); + map.put("AVX512_VBMI", CpuidFeature.AVX512_VBMI); + map.put("AVX512_VBMI2", CpuidFeature.AVX512_VBMI2); + map.put("AVX512_VNNI", CpuidFeature.AVX512_VNNI); + map.put("AVX512_VP2INTERSECT", CpuidFeature.AVX512_VP2INTERSECT); + map.put("AVX512_VPOPCNTDQ", CpuidFeature.AVX512_VPOPCNTDQ); + map.put("AVX512BW", CpuidFeature.AVX512BW); + map.put("AVX512CD", CpuidFeature.AVX512CD); + map.put("AVX512DQ", CpuidFeature.AVX512DQ); + map.put("AVX512ER", CpuidFeature.AVX512ER); + map.put("AVX512F", CpuidFeature.AVX512F); + map.put("AVX512PF", CpuidFeature.AVX512PF); + map.put("AVX512VL", CpuidFeature.AVX512VL); + map.put("BMI1", CpuidFeature.BMI1); + map.put("BMI2", CpuidFeature.BMI2); + map.put("CET_IBT", CpuidFeature.CET_IBT); + map.put("CET_SS", CpuidFeature.CET_SS); + map.put("CL1INVMB", CpuidFeature.CL1INVMB); + map.put("CLDEMOTE", CpuidFeature.CLDEMOTE); + map.put("CLFLUSHOPT", CpuidFeature.CLFLUSHOPT); + map.put("CLFSH", CpuidFeature.CLFSH); + map.put("CLWB", CpuidFeature.CLWB); + map.put("CLZERO", CpuidFeature.CLZERO); + map.put("CMOV", CpuidFeature.CMOV); + map.put("CMPXCHG16B", CpuidFeature.CMPXCHG16B); + map.put("CPUID", CpuidFeature.CPUID); + map.put("CX8", CpuidFeature.CX8); + map.put("D3NOW", CpuidFeature.D3NOW); + map.put("D3NOWEXT", CpuidFeature.D3NOWEXT); + map.put("OSS", CpuidFeature.OSS); + map.put("ENQCMD", CpuidFeature.ENQCMD); + map.put("F16C", CpuidFeature.F16C); + map.put("FMA", CpuidFeature.FMA); + map.put("FMA4", CpuidFeature.FMA4); + map.put("FPU", CpuidFeature.FPU); + map.put("FPU287", CpuidFeature.FPU287); + map.put("FPU287XL_ONLY", CpuidFeature.FPU287XL_ONLY); + map.put("FPU387", CpuidFeature.FPU387); + map.put("FPU387SL_ONLY", CpuidFeature.FPU387SL_ONLY); + map.put("FSGSBASE", CpuidFeature.FSGSBASE); + map.put("FXSR", CpuidFeature.FXSR); + map.put("CYRIX_D3NOW", CpuidFeature.CYRIX_D3NOW); + map.put("GFNI", CpuidFeature.GFNI); + map.put("HLE", CpuidFeature.HLE); + map.put("HLE_or_RTM", CpuidFeature.HLE_OR_RTM); + map.put("INVEPT", CpuidFeature.INVEPT); + map.put("INVPCID", CpuidFeature.INVPCID); + map.put("INVVPID", CpuidFeature.INVVPID); + map.put("LWP", CpuidFeature.LWP); + map.put("LZCNT", CpuidFeature.LZCNT); + map.put("MCOMMIT", CpuidFeature.MCOMMIT); + map.put("MMX", CpuidFeature.MMX); + map.put("MONITOR", CpuidFeature.MONITOR); + map.put("MONITORX", CpuidFeature.MONITORX); + map.put("MOVBE", CpuidFeature.MOVBE); + map.put("MOVDIR64B", CpuidFeature.MOVDIR64B); + map.put("MOVDIRI", CpuidFeature.MOVDIRI); + map.put("MPX", CpuidFeature.MPX); + map.put("MSR", CpuidFeature.MSR); + map.put("MULTIBYTENOP", CpuidFeature.MULTIBYTENOP); + map.put("PADLOCK_ACE", CpuidFeature.PADLOCK_ACE); + map.put("PADLOCK_PHE", CpuidFeature.PADLOCK_PHE); + map.put("PADLOCK_PMM", CpuidFeature.PADLOCK_PMM); + map.put("PADLOCK_RNG", CpuidFeature.PADLOCK_RNG); + map.put("PAUSE", CpuidFeature.PAUSE); + map.put("PCLMULQDQ", CpuidFeature.PCLMULQDQ); + map.put("PCOMMIT", CpuidFeature.PCOMMIT); + map.put("PCONFIG", CpuidFeature.PCONFIG); + map.put("PKU", CpuidFeature.PKU); + map.put("POPCNT", CpuidFeature.POPCNT); + map.put("PREFETCHW", CpuidFeature.PREFETCHW); + map.put("PREFETCHWT1", CpuidFeature.PREFETCHWT1); + map.put("PTWRITE", CpuidFeature.PTWRITE); + map.put("RDPID", CpuidFeature.RDPID); + map.put("RDPMC", CpuidFeature.RDPMC); + map.put("RDPRU", CpuidFeature.RDPRU); + map.put("RDRAND", CpuidFeature.RDRAND); + map.put("RDSEED", CpuidFeature.RDSEED); + map.put("RDTSCP", CpuidFeature.RDTSCP); + map.put("RTM", CpuidFeature.RTM); + map.put("SEP", CpuidFeature.SEP); + map.put("SGX1", CpuidFeature.SGX1); + map.put("SHA", CpuidFeature.SHA); + map.put("SKINIT", CpuidFeature.SKINIT); + map.put("SKINIT_or_SVM", CpuidFeature.SKINIT_OR_SVM); + map.put("SMAP", CpuidFeature.SMAP); + map.put("SMX", CpuidFeature.SMX); + map.put("SSE", CpuidFeature.SSE); + map.put("SSE2", CpuidFeature.SSE2); + map.put("SSE3", CpuidFeature.SSE3); + map.put("SSE4_1", CpuidFeature.SSE4_1); + map.put("SSE4_2", CpuidFeature.SSE4_2); + map.put("SSE4A", CpuidFeature.SSE4A); + map.put("SSSE3", CpuidFeature.SSSE3); + map.put("SVM", CpuidFeature.SVM); + map.put("SEV_ES", CpuidFeature.SEV_ES); + map.put("SYSCALL", CpuidFeature.SYSCALL); + map.put("TBM", CpuidFeature.TBM); + map.put("TSC", CpuidFeature.TSC); + map.put("VAES", CpuidFeature.VAES); + map.put("VMX", CpuidFeature.VMX); + map.put("VPCLMULQDQ", CpuidFeature.VPCLMULQDQ); + map.put("WAITPKG", CpuidFeature.WAITPKG); + map.put("WBNOINVD", CpuidFeature.WBNOINVD); + map.put("XOP", CpuidFeature.XOP); + map.put("XSAVE", CpuidFeature.XSAVE); + map.put("XSAVEC", CpuidFeature.XSAVEC); + map.put("XSAVEOPT", CpuidFeature.XSAVEOPT); + map.put("XSAVES", CpuidFeature.XSAVES); + map.put("SEV_SNP", CpuidFeature.SEV_SNP); + map.put("SERIALIZE", CpuidFeature.SERIALIZE); + map.put("TSXLDTRK", CpuidFeature.TSXLDTRK); + map.put("INVLPGB", CpuidFeature.INVLPGB); + map.put("AMX_BF16", CpuidFeature.AMX_BF16); + map.put("AMX_TILE", CpuidFeature.AMX_TILE); + map.put("AMX_INT8", CpuidFeature.AMX_INT8); + map.put("CYRIX_FPU", CpuidFeature.CYRIX_FPU); + map.put("CYRIX_SMM", CpuidFeature.CYRIX_SMM); + map.put("CYRIX_SMINT", CpuidFeature.CYRIX_SMINT); + map.put("CYRIX_SMINT_0F7E", CpuidFeature.CYRIX_SMINT_0F7E); + map.put("CYRIX_SHR", CpuidFeature.CYRIX_SHR); + map.put("CYRIX_DDI", CpuidFeature.CYRIX_DDI); + map.put("CYRIX_EMMI", CpuidFeature.CYRIX_EMMI); + map.put("CYRIX_DMI", CpuidFeature.CYRIX_DMI); + map.put("CENTAUR_AIS", CpuidFeature.CENTAUR_AIS); + map.put("MOV_TR", CpuidFeature.MOV_TR); + map.put("SMM", CpuidFeature.SMM); + map.put("TDX", CpuidFeature.TDX); + map.put("KL", CpuidFeature.KL); + map.put("AESKLE", CpuidFeature.AESKLE); + map.put("WIDE_KL", CpuidFeature.WIDE_KL); + map.put("UINTR", CpuidFeature.UINTR); + map.put("HRESET", CpuidFeature.HRESET); + map.put("AVX_VNNI", CpuidFeature.AVX_VNNI); + map.put("PADLOCK_GMI", CpuidFeature.PADLOCK_GMI); + map.put("FRED", CpuidFeature.FRED); + map.put("LKGS", CpuidFeature.LKGS); + map.put("AVX512_FP16", CpuidFeature.AVX512_FP16); + map.put("UDBG", CpuidFeature.UDBG); + map.put("KNC", CpuidFeature.KNC); + map.put("PADLOCK_UNDOC", CpuidFeature.PADLOCK_UNDOC); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToDecoderError.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToDecoderError.java new file mode 100644 index 000000000..f1ff204cc --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToDecoderError.java @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.dec.DecoderError; + +public final class ToDecoderError { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant DecoderError.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(3); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("None", DecoderError.NONE); + map.put("InvalidInstruction", DecoderError.INVALID_INSTRUCTION); + map.put("NoMoreBytes", DecoderError.NO_MORE_BYTES); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToDecoderOptions.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToDecoderOptions.java new file mode 100644 index 000000000..13b8c9c9a --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToDecoderOptions.java @@ -0,0 +1,77 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.dec.DecoderOptions; + +public final class ToDecoderOptions { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant DecoderOptions.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(26); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("None", DecoderOptions.NONE); + map.put("NoInvalidCheck", DecoderOptions.NO_INVALID_CHECK); + map.put("AMD", DecoderOptions.AMD); + map.put("ForceReservedNop", DecoderOptions.FORCE_RESERVED_NOP); + map.put("Umov", DecoderOptions.UMOV); + map.put("Xbts", DecoderOptions.XBTS); + map.put("Cmpxchg486A", DecoderOptions.CMPXCHG486A); + map.put("OldFpu", DecoderOptions.OLD_FPU); + map.put("Pcommit", DecoderOptions.PCOMMIT); + map.put("Loadall286", DecoderOptions.LOADALL286); + map.put("Loadall386", DecoderOptions.LOADALL386); + map.put("Cl1invmb", DecoderOptions.CL1INVMB); + map.put("MovTr", DecoderOptions.MOV_TR); + map.put("Jmpe", DecoderOptions.JMPE); + map.put("NoPause", DecoderOptions.NO_PAUSE); + map.put("NoWbnoinvd", DecoderOptions.NO_WBNOINVD); + map.put("Udbg", DecoderOptions.UDBG); + map.put("NoMPFX_0FBC", DecoderOptions.NO_MPFX_0FBC); + map.put("NoMPFX_0FBD", DecoderOptions.NO_MPFX_0FBD); + map.put("NoLahfSahf64", DecoderOptions.NO_LAHF_SAHF_64); + map.put("MPX", DecoderOptions.MPX); + map.put("Cyrix", DecoderOptions.CYRIX); + map.put("Cyrix_SMINT_0F7E", DecoderOptions.CYRIX_SMINT_0F7E); + map.put("Cyrix_DMI", DecoderOptions.CYRIX_DMI); + map.put("ALTINST", DecoderOptions.ALTINST); + map.put("KNC", DecoderOptions.KNC); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToEncodingKind.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToEncodingKind.java new file mode 100644 index 000000000..c68d05bb5 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToEncodingKind.java @@ -0,0 +1,55 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToEncodingKind { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant EncodingKind.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(6); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("Legacy", EncodingKind.LEGACY); + map.put("VEX", EncodingKind.VEX); + map.put("EVEX", EncodingKind.EVEX); + map.put("XOP", EncodingKind.XOP); + map.put("D3NOW", EncodingKind.D3NOW); + map.put("MVEX", EncodingKind.MVEX); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToFlowControl.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToFlowControl.java new file mode 100644 index 000000000..68faff893 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToFlowControl.java @@ -0,0 +1,59 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToFlowControl { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant FlowControl.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(10); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("Next", FlowControl.NEXT); + map.put("UnconditionalBranch", FlowControl.UNCONDITIONAL_BRANCH); + map.put("IndirectBranch", FlowControl.INDIRECT_BRANCH); + map.put("ConditionalBranch", FlowControl.CONDITIONAL_BRANCH); + map.put("Return", FlowControl.RETURN); + map.put("Call", FlowControl.CALL); + map.put("IndirectCall", FlowControl.INDIRECT_CALL); + map.put("Interrupt", FlowControl.INTERRUPT); + map.put("XbeginXabortXend", FlowControl.XBEGIN_XABORT_XEND); + map.put("Exception", FlowControl.EXCEPTION); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMemorySize.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMemorySize.java new file mode 100644 index 000000000..1bfa76426 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMemorySize.java @@ -0,0 +1,209 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToMemorySize { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant MemorySize.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(160); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("Unknown", MemorySize.UNKNOWN); + map.put("UInt8", MemorySize.UINT8); + map.put("UInt16", MemorySize.UINT16); + map.put("UInt32", MemorySize.UINT32); + map.put("UInt52", MemorySize.UINT52); + map.put("UInt64", MemorySize.UINT64); + map.put("UInt128", MemorySize.UINT128); + map.put("UInt256", MemorySize.UINT256); + map.put("UInt512", MemorySize.UINT512); + map.put("Int8", MemorySize.INT8); + map.put("Int16", MemorySize.INT16); + map.put("Int32", MemorySize.INT32); + map.put("Int64", MemorySize.INT64); + map.put("Int128", MemorySize.INT128); + map.put("Int256", MemorySize.INT256); + map.put("Int512", MemorySize.INT512); + map.put("SegPtr16", MemorySize.SEG_PTR16); + map.put("SegPtr32", MemorySize.SEG_PTR32); + map.put("SegPtr64", MemorySize.SEG_PTR64); + map.put("WordOffset", MemorySize.WORD_OFFSET); + map.put("DwordOffset", MemorySize.DWORD_OFFSET); + map.put("QwordOffset", MemorySize.QWORD_OFFSET); + map.put("Bound16_WordWord", MemorySize.BOUND16_WORD_WORD); + map.put("Bound32_DwordDword", MemorySize.BOUND32_DWORD_DWORD); + map.put("Bnd32", MemorySize.BND32); + map.put("Bnd64", MemorySize.BND64); + map.put("Fword6", MemorySize.FWORD6); + map.put("Fword10", MemorySize.FWORD10); + map.put("Float16", MemorySize.FLOAT16); + map.put("Float32", MemorySize.FLOAT32); + map.put("Float64", MemorySize.FLOAT64); + map.put("Float80", MemorySize.FLOAT80); + map.put("Float128", MemorySize.FLOAT128); + map.put("BFloat16", MemorySize.BFLOAT16); + map.put("FpuEnv14", MemorySize.FPU_ENV14); + map.put("FpuEnv28", MemorySize.FPU_ENV28); + map.put("FpuState94", MemorySize.FPU_STATE94); + map.put("FpuState108", MemorySize.FPU_STATE108); + map.put("Fxsave_512Byte", MemorySize.FXSAVE_512BYTE); + map.put("Fxsave64_512Byte", MemorySize.FXSAVE64_512BYTE); + map.put("Xsave", MemorySize.XSAVE); + map.put("Xsave64", MemorySize.XSAVE64); + map.put("Bcd", MemorySize.BCD); + map.put("Tilecfg", MemorySize.TILECFG); + map.put("Tile", MemorySize.TILE); + map.put("SegmentDescSelector", MemorySize.SEGMENT_DESC_SELECTOR); + map.put("KLHandleAes128", MemorySize.KLHANDLE_AES128); + map.put("KLHandleAes256", MemorySize.KLHANDLE_AES256); + map.put("Packed16_UInt8", MemorySize.PACKED16_UINT8); + map.put("Packed16_Int8", MemorySize.PACKED16_INT8); + map.put("Packed32_UInt8", MemorySize.PACKED32_UINT8); + map.put("Packed32_Int8", MemorySize.PACKED32_INT8); + map.put("Packed32_UInt16", MemorySize.PACKED32_UINT16); + map.put("Packed32_Int16", MemorySize.PACKED32_INT16); + map.put("Packed32_Float16", MemorySize.PACKED32_FLOAT16); + map.put("Packed32_BFloat16", MemorySize.PACKED32_BFLOAT16); + map.put("Packed64_UInt8", MemorySize.PACKED64_UINT8); + map.put("Packed64_Int8", MemorySize.PACKED64_INT8); + map.put("Packed64_UInt16", MemorySize.PACKED64_UINT16); + map.put("Packed64_Int16", MemorySize.PACKED64_INT16); + map.put("Packed64_UInt32", MemorySize.PACKED64_UINT32); + map.put("Packed64_Int32", MemorySize.PACKED64_INT32); + map.put("Packed64_Float16", MemorySize.PACKED64_FLOAT16); + map.put("Packed64_Float32", MemorySize.PACKED64_FLOAT32); + map.put("Packed128_UInt8", MemorySize.PACKED128_UINT8); + map.put("Packed128_Int8", MemorySize.PACKED128_INT8); + map.put("Packed128_UInt16", MemorySize.PACKED128_UINT16); + map.put("Packed128_Int16", MemorySize.PACKED128_INT16); + map.put("Packed128_UInt32", MemorySize.PACKED128_UINT32); + map.put("Packed128_Int32", MemorySize.PACKED128_INT32); + map.put("Packed128_UInt52", MemorySize.PACKED128_UINT52); + map.put("Packed128_UInt64", MemorySize.PACKED128_UINT64); + map.put("Packed128_Int64", MemorySize.PACKED128_INT64); + map.put("Packed128_Float16", MemorySize.PACKED128_FLOAT16); + map.put("Packed128_Float32", MemorySize.PACKED128_FLOAT32); + map.put("Packed128_Float64", MemorySize.PACKED128_FLOAT64); + map.put("Packed128_2xFloat16", MemorySize.PACKED128_2X_FLOAT16); + map.put("Packed128_2xBFloat16", MemorySize.PACKED128_2X_BFLOAT16); + map.put("Packed256_UInt8", MemorySize.PACKED256_UINT8); + map.put("Packed256_Int8", MemorySize.PACKED256_INT8); + map.put("Packed256_UInt16", MemorySize.PACKED256_UINT16); + map.put("Packed256_Int16", MemorySize.PACKED256_INT16); + map.put("Packed256_UInt32", MemorySize.PACKED256_UINT32); + map.put("Packed256_Int32", MemorySize.PACKED256_INT32); + map.put("Packed256_UInt52", MemorySize.PACKED256_UINT52); + map.put("Packed256_UInt64", MemorySize.PACKED256_UINT64); + map.put("Packed256_Int64", MemorySize.PACKED256_INT64); + map.put("Packed256_UInt128", MemorySize.PACKED256_UINT128); + map.put("Packed256_Int128", MemorySize.PACKED256_INT128); + map.put("Packed256_Float16", MemorySize.PACKED256_FLOAT16); + map.put("Packed256_Float32", MemorySize.PACKED256_FLOAT32); + map.put("Packed256_Float64", MemorySize.PACKED256_FLOAT64); + map.put("Packed256_Float128", MemorySize.PACKED256_FLOAT128); + map.put("Packed256_2xFloat16", MemorySize.PACKED256_2X_FLOAT16); + map.put("Packed256_2xBFloat16", MemorySize.PACKED256_2X_BFLOAT16); + map.put("Packed512_UInt8", MemorySize.PACKED512_UINT8); + map.put("Packed512_Int8", MemorySize.PACKED512_INT8); + map.put("Packed512_UInt16", MemorySize.PACKED512_UINT16); + map.put("Packed512_Int16", MemorySize.PACKED512_INT16); + map.put("Packed512_UInt32", MemorySize.PACKED512_UINT32); + map.put("Packed512_Int32", MemorySize.PACKED512_INT32); + map.put("Packed512_UInt52", MemorySize.PACKED512_UINT52); + map.put("Packed512_UInt64", MemorySize.PACKED512_UINT64); + map.put("Packed512_Int64", MemorySize.PACKED512_INT64); + map.put("Packed512_UInt128", MemorySize.PACKED512_UINT128); + map.put("Packed512_Float16", MemorySize.PACKED512_FLOAT16); + map.put("Packed512_Float32", MemorySize.PACKED512_FLOAT32); + map.put("Packed512_Float64", MemorySize.PACKED512_FLOAT64); + map.put("Packed512_2xFloat16", MemorySize.PACKED512_2X_FLOAT16); + map.put("Packed512_2xBFloat16", MemorySize.PACKED512_2X_BFLOAT16); + map.put("Broadcast32_Float16", MemorySize.BROADCAST32_FLOAT16); + map.put("Broadcast64_UInt32", MemorySize.BROADCAST64_UINT32); + map.put("Broadcast64_Int32", MemorySize.BROADCAST64_INT32); + map.put("Broadcast64_Float16", MemorySize.BROADCAST64_FLOAT16); + map.put("Broadcast64_Float32", MemorySize.BROADCAST64_FLOAT32); + map.put("Broadcast128_Int16", MemorySize.BROADCAST128_INT16); + map.put("Broadcast128_UInt16", MemorySize.BROADCAST128_UINT16); + map.put("Broadcast128_UInt32", MemorySize.BROADCAST128_UINT32); + map.put("Broadcast128_Int32", MemorySize.BROADCAST128_INT32); + map.put("Broadcast128_UInt52", MemorySize.BROADCAST128_UINT52); + map.put("Broadcast128_UInt64", MemorySize.BROADCAST128_UINT64); + map.put("Broadcast128_Int64", MemorySize.BROADCAST128_INT64); + map.put("Broadcast128_Float16", MemorySize.BROADCAST128_FLOAT16); + map.put("Broadcast128_Float32", MemorySize.BROADCAST128_FLOAT32); + map.put("Broadcast128_Float64", MemorySize.BROADCAST128_FLOAT64); + map.put("Broadcast128_2xInt16", MemorySize.BROADCAST128_2X_INT16); + map.put("Broadcast128_2xInt32", MemorySize.BROADCAST128_2X_INT32); + map.put("Broadcast128_2xUInt32", MemorySize.BROADCAST128_2X_UINT32); + map.put("Broadcast128_2xFloat16", MemorySize.BROADCAST128_2X_FLOAT16); + map.put("Broadcast128_2xBFloat16", MemorySize.BROADCAST128_2X_BFLOAT16); + map.put("Broadcast256_Int16", MemorySize.BROADCAST256_INT16); + map.put("Broadcast256_UInt16", MemorySize.BROADCAST256_UINT16); + map.put("Broadcast256_UInt32", MemorySize.BROADCAST256_UINT32); + map.put("Broadcast256_Int32", MemorySize.BROADCAST256_INT32); + map.put("Broadcast256_UInt52", MemorySize.BROADCAST256_UINT52); + map.put("Broadcast256_UInt64", MemorySize.BROADCAST256_UINT64); + map.put("Broadcast256_Int64", MemorySize.BROADCAST256_INT64); + map.put("Broadcast256_Float16", MemorySize.BROADCAST256_FLOAT16); + map.put("Broadcast256_Float32", MemorySize.BROADCAST256_FLOAT32); + map.put("Broadcast256_Float64", MemorySize.BROADCAST256_FLOAT64); + map.put("Broadcast256_2xInt16", MemorySize.BROADCAST256_2X_INT16); + map.put("Broadcast256_2xInt32", MemorySize.BROADCAST256_2X_INT32); + map.put("Broadcast256_2xUInt32", MemorySize.BROADCAST256_2X_UINT32); + map.put("Broadcast256_2xFloat16", MemorySize.BROADCAST256_2X_FLOAT16); + map.put("Broadcast256_2xBFloat16", MemorySize.BROADCAST256_2X_BFLOAT16); + map.put("Broadcast512_Int16", MemorySize.BROADCAST512_INT16); + map.put("Broadcast512_UInt16", MemorySize.BROADCAST512_UINT16); + map.put("Broadcast512_UInt32", MemorySize.BROADCAST512_UINT32); + map.put("Broadcast512_Int32", MemorySize.BROADCAST512_INT32); + map.put("Broadcast512_UInt52", MemorySize.BROADCAST512_UINT52); + map.put("Broadcast512_UInt64", MemorySize.BROADCAST512_UINT64); + map.put("Broadcast512_Int64", MemorySize.BROADCAST512_INT64); + map.put("Broadcast512_Float16", MemorySize.BROADCAST512_FLOAT16); + map.put("Broadcast512_Float32", MemorySize.BROADCAST512_FLOAT32); + map.put("Broadcast512_Float64", MemorySize.BROADCAST512_FLOAT64); + map.put("Broadcast512_2xFloat16", MemorySize.BROADCAST512_2X_FLOAT16); + map.put("Broadcast512_2xInt16", MemorySize.BROADCAST512_2X_INT16); + map.put("Broadcast512_2xUInt32", MemorySize.BROADCAST512_2X_UINT32); + map.put("Broadcast512_2xInt32", MemorySize.BROADCAST512_2X_INT32); + map.put("Broadcast512_2xBFloat16", MemorySize.BROADCAST512_2X_BFLOAT16); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMemorySizeOptions.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMemorySizeOptions.java new file mode 100644 index 000000000..d1274a16a --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMemorySizeOptions.java @@ -0,0 +1,55 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.MemorySizeOptions; + +public final class ToMemorySizeOptions { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant MemorySizeOptions.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(4); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("Default", MemorySizeOptions.DEFAULT); + map.put("Always", MemorySizeOptions.ALWAYS); + map.put("Minimal", MemorySizeOptions.MINIMAL); + map.put("Never", MemorySizeOptions.NEVER); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMnemonic.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMnemonic.java new file mode 100644 index 000000000..fd83e818e --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMnemonic.java @@ -0,0 +1,1899 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToMnemonic { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant Mnemonic.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(1838); + initMap0(map); + initMap1(map); + initMap2(map); + initMap3(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("INVALID", Mnemonic.INVALID); + map.put("Aaa", Mnemonic.AAA); + map.put("Aad", Mnemonic.AAD); + map.put("Aam", Mnemonic.AAM); + map.put("Aas", Mnemonic.AAS); + map.put("Adc", Mnemonic.ADC); + map.put("Adcx", Mnemonic.ADCX); + map.put("Add", Mnemonic.ADD); + map.put("Addpd", Mnemonic.ADDPD); + map.put("Addps", Mnemonic.ADDPS); + map.put("Addsd", Mnemonic.ADDSD); + map.put("Addss", Mnemonic.ADDSS); + map.put("Addsubpd", Mnemonic.ADDSUBPD); + map.put("Addsubps", Mnemonic.ADDSUBPS); + map.put("Adox", Mnemonic.ADOX); + map.put("Aesdec", Mnemonic.AESDEC); + map.put("Aesdeclast", Mnemonic.AESDECLAST); + map.put("Aesenc", Mnemonic.AESENC); + map.put("Aesenclast", Mnemonic.AESENCLAST); + map.put("Aesimc", Mnemonic.AESIMC); + map.put("Aeskeygenassist", Mnemonic.AESKEYGENASSIST); + map.put("And", Mnemonic.AND); + map.put("Andn", Mnemonic.ANDN); + map.put("Andnpd", Mnemonic.ANDNPD); + map.put("Andnps", Mnemonic.ANDNPS); + map.put("Andpd", Mnemonic.ANDPD); + map.put("Andps", Mnemonic.ANDPS); + map.put("Arpl", Mnemonic.ARPL); + map.put("Bextr", Mnemonic.BEXTR); + map.put("Blcfill", Mnemonic.BLCFILL); + map.put("Blci", Mnemonic.BLCI); + map.put("Blcic", Mnemonic.BLCIC); + map.put("Blcmsk", Mnemonic.BLCMSK); + map.put("Blcs", Mnemonic.BLCS); + map.put("Blendpd", Mnemonic.BLENDPD); + map.put("Blendps", Mnemonic.BLENDPS); + map.put("Blendvpd", Mnemonic.BLENDVPD); + map.put("Blendvps", Mnemonic.BLENDVPS); + map.put("Blsfill", Mnemonic.BLSFILL); + map.put("Blsi", Mnemonic.BLSI); + map.put("Blsic", Mnemonic.BLSIC); + map.put("Blsmsk", Mnemonic.BLSMSK); + map.put("Blsr", Mnemonic.BLSR); + map.put("Bndcl", Mnemonic.BNDCL); + map.put("Bndcn", Mnemonic.BNDCN); + map.put("Bndcu", Mnemonic.BNDCU); + map.put("Bndldx", Mnemonic.BNDLDX); + map.put("Bndmk", Mnemonic.BNDMK); + map.put("Bndmov", Mnemonic.BNDMOV); + map.put("Bndstx", Mnemonic.BNDSTX); + map.put("Bound", Mnemonic.BOUND); + map.put("Bsf", Mnemonic.BSF); + map.put("Bsr", Mnemonic.BSR); + map.put("Bswap", Mnemonic.BSWAP); + map.put("Bt", Mnemonic.BT); + map.put("Btc", Mnemonic.BTC); + map.put("Btr", Mnemonic.BTR); + map.put("Bts", Mnemonic.BTS); + map.put("Bzhi", Mnemonic.BZHI); + map.put("Call", Mnemonic.CALL); + map.put("Cbw", Mnemonic.CBW); + map.put("Cdq", Mnemonic.CDQ); + map.put("Cdqe", Mnemonic.CDQE); + map.put("Cl1invmb", Mnemonic.CL1INVMB); + map.put("Clac", Mnemonic.CLAC); + map.put("Clc", Mnemonic.CLC); + map.put("Cld", Mnemonic.CLD); + map.put("Cldemote", Mnemonic.CLDEMOTE); + map.put("Clflush", Mnemonic.CLFLUSH); + map.put("Clflushopt", Mnemonic.CLFLUSHOPT); + map.put("Clgi", Mnemonic.CLGI); + map.put("Cli", Mnemonic.CLI); + map.put("Clrssbsy", Mnemonic.CLRSSBSY); + map.put("Clts", Mnemonic.CLTS); + map.put("Clwb", Mnemonic.CLWB); + map.put("Clzero", Mnemonic.CLZERO); + map.put("Cmc", Mnemonic.CMC); + map.put("Cmova", Mnemonic.CMOVA); + map.put("Cmovae", Mnemonic.CMOVAE); + map.put("Cmovb", Mnemonic.CMOVB); + map.put("Cmovbe", Mnemonic.CMOVBE); + map.put("Cmove", Mnemonic.CMOVE); + map.put("Cmovg", Mnemonic.CMOVG); + map.put("Cmovge", Mnemonic.CMOVGE); + map.put("Cmovl", Mnemonic.CMOVL); + map.put("Cmovle", Mnemonic.CMOVLE); + map.put("Cmovne", Mnemonic.CMOVNE); + map.put("Cmovno", Mnemonic.CMOVNO); + map.put("Cmovnp", Mnemonic.CMOVNP); + map.put("Cmovns", Mnemonic.CMOVNS); + map.put("Cmovo", Mnemonic.CMOVO); + map.put("Cmovp", Mnemonic.CMOVP); + map.put("Cmovs", Mnemonic.CMOVS); + map.put("Cmp", Mnemonic.CMP); + map.put("Cmppd", Mnemonic.CMPPD); + map.put("Cmpps", Mnemonic.CMPPS); + map.put("Cmpsb", Mnemonic.CMPSB); + map.put("Cmpsd", Mnemonic.CMPSD); + map.put("Cmpsq", Mnemonic.CMPSQ); + map.put("Cmpss", Mnemonic.CMPSS); + map.put("Cmpsw", Mnemonic.CMPSW); + map.put("Cmpxchg", Mnemonic.CMPXCHG); + map.put("Cmpxchg16b", Mnemonic.CMPXCHG16B); + map.put("Cmpxchg8b", Mnemonic.CMPXCHG8B); + map.put("Comisd", Mnemonic.COMISD); + map.put("Comiss", Mnemonic.COMISS); + map.put("Cpuid", Mnemonic.CPUID); + map.put("Cqo", Mnemonic.CQO); + map.put("Crc32", Mnemonic.CRC32); + map.put("Cvtdq2pd", Mnemonic.CVTDQ2PD); + map.put("Cvtdq2ps", Mnemonic.CVTDQ2PS); + map.put("Cvtpd2dq", Mnemonic.CVTPD2DQ); + map.put("Cvtpd2pi", Mnemonic.CVTPD2PI); + map.put("Cvtpd2ps", Mnemonic.CVTPD2PS); + map.put("Cvtpi2pd", Mnemonic.CVTPI2PD); + map.put("Cvtpi2ps", Mnemonic.CVTPI2PS); + map.put("Cvtps2dq", Mnemonic.CVTPS2DQ); + map.put("Cvtps2pd", Mnemonic.CVTPS2PD); + map.put("Cvtps2pi", Mnemonic.CVTPS2PI); + map.put("Cvtsd2si", Mnemonic.CVTSD2SI); + map.put("Cvtsd2ss", Mnemonic.CVTSD2SS); + map.put("Cvtsi2sd", Mnemonic.CVTSI2SD); + map.put("Cvtsi2ss", Mnemonic.CVTSI2SS); + map.put("Cvtss2sd", Mnemonic.CVTSS2SD); + map.put("Cvtss2si", Mnemonic.CVTSS2SI); + map.put("Cvttpd2dq", Mnemonic.CVTTPD2DQ); + map.put("Cvttpd2pi", Mnemonic.CVTTPD2PI); + map.put("Cvttps2dq", Mnemonic.CVTTPS2DQ); + map.put("Cvttps2pi", Mnemonic.CVTTPS2PI); + map.put("Cvttsd2si", Mnemonic.CVTTSD2SI); + map.put("Cvttss2si", Mnemonic.CVTTSS2SI); + map.put("Cwd", Mnemonic.CWD); + map.put("Cwde", Mnemonic.CWDE); + map.put("Daa", Mnemonic.DAA); + map.put("Das", Mnemonic.DAS); + map.put("Db", Mnemonic.DB); + map.put("Dd", Mnemonic.DD); + map.put("Dec", Mnemonic.DEC); + map.put("Div", Mnemonic.DIV); + map.put("Divpd", Mnemonic.DIVPD); + map.put("Divps", Mnemonic.DIVPS); + map.put("Divsd", Mnemonic.DIVSD); + map.put("Divss", Mnemonic.DIVSS); + map.put("Dppd", Mnemonic.DPPD); + map.put("Dpps", Mnemonic.DPPS); + map.put("Dq", Mnemonic.DQ); + map.put("Dw", Mnemonic.DW); + map.put("Emms", Mnemonic.EMMS); + map.put("Encls", Mnemonic.ENCLS); + map.put("Enclu", Mnemonic.ENCLU); + map.put("Enclv", Mnemonic.ENCLV); + map.put("Endbr32", Mnemonic.ENDBR32); + map.put("Endbr64", Mnemonic.ENDBR64); + map.put("Enqcmd", Mnemonic.ENQCMD); + map.put("Enqcmds", Mnemonic.ENQCMDS); + map.put("Enter", Mnemonic.ENTER); + map.put("Extractps", Mnemonic.EXTRACTPS); + map.put("Extrq", Mnemonic.EXTRQ); + map.put("F2xm1", Mnemonic.F2XM1); + map.put("Fabs", Mnemonic.FABS); + map.put("Fadd", Mnemonic.FADD); + map.put("Faddp", Mnemonic.FADDP); + map.put("Fbld", Mnemonic.FBLD); + map.put("Fbstp", Mnemonic.FBSTP); + map.put("Fchs", Mnemonic.FCHS); + map.put("Fclex", Mnemonic.FCLEX); + map.put("Fcmovb", Mnemonic.FCMOVB); + map.put("Fcmovbe", Mnemonic.FCMOVBE); + map.put("Fcmove", Mnemonic.FCMOVE); + map.put("Fcmovnb", Mnemonic.FCMOVNB); + map.put("Fcmovnbe", Mnemonic.FCMOVNBE); + map.put("Fcmovne", Mnemonic.FCMOVNE); + map.put("Fcmovnu", Mnemonic.FCMOVNU); + map.put("Fcmovu", Mnemonic.FCMOVU); + map.put("Fcom", Mnemonic.FCOM); + map.put("Fcomi", Mnemonic.FCOMI); + map.put("Fcomip", Mnemonic.FCOMIP); + map.put("Fcomp", Mnemonic.FCOMP); + map.put("Fcompp", Mnemonic.FCOMPP); + map.put("Fcos", Mnemonic.FCOS); + map.put("Fdecstp", Mnemonic.FDECSTP); + map.put("Fdisi", Mnemonic.FDISI); + map.put("Fdiv", Mnemonic.FDIV); + map.put("Fdivp", Mnemonic.FDIVP); + map.put("Fdivr", Mnemonic.FDIVR); + map.put("Fdivrp", Mnemonic.FDIVRP); + map.put("Femms", Mnemonic.FEMMS); + map.put("Feni", Mnemonic.FENI); + map.put("Ffree", Mnemonic.FFREE); + map.put("Ffreep", Mnemonic.FFREEP); + map.put("Fiadd", Mnemonic.FIADD); + map.put("Ficom", Mnemonic.FICOM); + map.put("Ficomp", Mnemonic.FICOMP); + map.put("Fidiv", Mnemonic.FIDIV); + map.put("Fidivr", Mnemonic.FIDIVR); + map.put("Fild", Mnemonic.FILD); + map.put("Fimul", Mnemonic.FIMUL); + map.put("Fincstp", Mnemonic.FINCSTP); + map.put("Finit", Mnemonic.FINIT); + map.put("Fist", Mnemonic.FIST); + map.put("Fistp", Mnemonic.FISTP); + map.put("Fisttp", Mnemonic.FISTTP); + map.put("Fisub", Mnemonic.FISUB); + map.put("Fisubr", Mnemonic.FISUBR); + map.put("Fld", Mnemonic.FLD); + map.put("Fld1", Mnemonic.FLD1); + map.put("Fldcw", Mnemonic.FLDCW); + map.put("Fldenv", Mnemonic.FLDENV); + map.put("Fldl2e", Mnemonic.FLDL2E); + map.put("Fldl2t", Mnemonic.FLDL2T); + map.put("Fldlg2", Mnemonic.FLDLG2); + map.put("Fldln2", Mnemonic.FLDLN2); + map.put("Fldpi", Mnemonic.FLDPI); + map.put("Fldz", Mnemonic.FLDZ); + map.put("Fmul", Mnemonic.FMUL); + map.put("Fmulp", Mnemonic.FMULP); + map.put("Fnclex", Mnemonic.FNCLEX); + map.put("Fndisi", Mnemonic.FNDISI); + map.put("Fneni", Mnemonic.FNENI); + map.put("Fninit", Mnemonic.FNINIT); + map.put("Fnop", Mnemonic.FNOP); + map.put("Fnsave", Mnemonic.FNSAVE); + map.put("Fnsetpm", Mnemonic.FNSETPM); + map.put("Fnstcw", Mnemonic.FNSTCW); + map.put("Fnstenv", Mnemonic.FNSTENV); + map.put("Fnstsw", Mnemonic.FNSTSW); + map.put("Fpatan", Mnemonic.FPATAN); + map.put("Fprem", Mnemonic.FPREM); + map.put("Fprem1", Mnemonic.FPREM1); + map.put("Fptan", Mnemonic.FPTAN); + map.put("Frndint", Mnemonic.FRNDINT); + map.put("Frstor", Mnemonic.FRSTOR); + map.put("Frstpm", Mnemonic.FRSTPM); + map.put("Fsave", Mnemonic.FSAVE); + map.put("Fscale", Mnemonic.FSCALE); + map.put("Fsetpm", Mnemonic.FSETPM); + map.put("Fsin", Mnemonic.FSIN); + map.put("Fsincos", Mnemonic.FSINCOS); + map.put("Fsqrt", Mnemonic.FSQRT); + map.put("Fst", Mnemonic.FST); + map.put("Fstcw", Mnemonic.FSTCW); + map.put("Fstdw", Mnemonic.FSTDW); + map.put("Fstenv", Mnemonic.FSTENV); + map.put("Fstp", Mnemonic.FSTP); + map.put("Fstpnce", Mnemonic.FSTPNCE); + map.put("Fstsg", Mnemonic.FSTSG); + map.put("Fstsw", Mnemonic.FSTSW); + map.put("Fsub", Mnemonic.FSUB); + map.put("Fsubp", Mnemonic.FSUBP); + map.put("Fsubr", Mnemonic.FSUBR); + map.put("Fsubrp", Mnemonic.FSUBRP); + map.put("Ftst", Mnemonic.FTST); + map.put("Fucom", Mnemonic.FUCOM); + map.put("Fucomi", Mnemonic.FUCOMI); + map.put("Fucomip", Mnemonic.FUCOMIP); + map.put("Fucomp", Mnemonic.FUCOMP); + map.put("Fucompp", Mnemonic.FUCOMPP); + map.put("Fxam", Mnemonic.FXAM); + map.put("Fxch", Mnemonic.FXCH); + map.put("Fxrstor", Mnemonic.FXRSTOR); + map.put("Fxrstor64", Mnemonic.FXRSTOR64); + map.put("Fxsave", Mnemonic.FXSAVE); + map.put("Fxsave64", Mnemonic.FXSAVE64); + map.put("Fxtract", Mnemonic.FXTRACT); + map.put("Fyl2x", Mnemonic.FYL2X); + map.put("Fyl2xp1", Mnemonic.FYL2XP1); + map.put("Getsec", Mnemonic.GETSEC); + map.put("Gf2p8affineinvqb", Mnemonic.GF2P8AFFINEINVQB); + map.put("Gf2p8affineqb", Mnemonic.GF2P8AFFINEQB); + map.put("Gf2p8mulb", Mnemonic.GF2P8MULB); + map.put("Haddpd", Mnemonic.HADDPD); + map.put("Haddps", Mnemonic.HADDPS); + map.put("Hlt", Mnemonic.HLT); + map.put("Hsubpd", Mnemonic.HSUBPD); + map.put("Hsubps", Mnemonic.HSUBPS); + map.put("Ibts", Mnemonic.IBTS); + map.put("Idiv", Mnemonic.IDIV); + map.put("Imul", Mnemonic.IMUL); + map.put("In", Mnemonic.IN); + map.put("Inc", Mnemonic.INC); + map.put("Incsspd", Mnemonic.INCSSPD); + map.put("Incsspq", Mnemonic.INCSSPQ); + map.put("Insb", Mnemonic.INSB); + map.put("Insd", Mnemonic.INSD); + map.put("Insertps", Mnemonic.INSERTPS); + map.put("Insertq", Mnemonic.INSERTQ); + map.put("Insw", Mnemonic.INSW); + map.put("Int", Mnemonic.INT); + map.put("Int1", Mnemonic.INT1); + map.put("Into", Mnemonic.INTO); + map.put("Invd", Mnemonic.INVD); + map.put("Invept", Mnemonic.INVEPT); + map.put("Invlpg", Mnemonic.INVLPG); + map.put("Invlpga", Mnemonic.INVLPGA); + map.put("Invpcid", Mnemonic.INVPCID); + map.put("Invvpid", Mnemonic.INVVPID); + map.put("Iret", Mnemonic.IRET); + map.put("Ja", Mnemonic.JA); + map.put("Jae", Mnemonic.JAE); + map.put("Jb", Mnemonic.JB); + map.put("Jbe", Mnemonic.JBE); + map.put("Jcxz", Mnemonic.JCXZ); + map.put("Je", Mnemonic.JE); + map.put("Jecxz", Mnemonic.JECXZ); + map.put("Jg", Mnemonic.JG); + map.put("Jge", Mnemonic.JGE); + map.put("Jl", Mnemonic.JL); + map.put("Jle", Mnemonic.JLE); + map.put("Jmp", Mnemonic.JMP); + map.put("Jmpe", Mnemonic.JMPE); + map.put("Jne", Mnemonic.JNE); + map.put("Jno", Mnemonic.JNO); + map.put("Jnp", Mnemonic.JNP); + map.put("Jns", Mnemonic.JNS); + map.put("Jo", Mnemonic.JO); + map.put("Jp", Mnemonic.JP); + map.put("Jrcxz", Mnemonic.JRCXZ); + map.put("Js", Mnemonic.JS); + map.put("Kaddb", Mnemonic.KADDB); + map.put("Kaddd", Mnemonic.KADDD); + map.put("Kaddq", Mnemonic.KADDQ); + map.put("Kaddw", Mnemonic.KADDW); + map.put("Kandb", Mnemonic.KANDB); + map.put("Kandd", Mnemonic.KANDD); + map.put("Kandnb", Mnemonic.KANDNB); + map.put("Kandnd", Mnemonic.KANDND); + map.put("Kandnq", Mnemonic.KANDNQ); + map.put("Kandnw", Mnemonic.KANDNW); + map.put("Kandq", Mnemonic.KANDQ); + map.put("Kandw", Mnemonic.KANDW); + map.put("Kmovb", Mnemonic.KMOVB); + map.put("Kmovd", Mnemonic.KMOVD); + map.put("Kmovq", Mnemonic.KMOVQ); + map.put("Kmovw", Mnemonic.KMOVW); + map.put("Knotb", Mnemonic.KNOTB); + map.put("Knotd", Mnemonic.KNOTD); + map.put("Knotq", Mnemonic.KNOTQ); + map.put("Knotw", Mnemonic.KNOTW); + map.put("Korb", Mnemonic.KORB); + map.put("Kord", Mnemonic.KORD); + map.put("Korq", Mnemonic.KORQ); + map.put("Kortestb", Mnemonic.KORTESTB); + map.put("Kortestd", Mnemonic.KORTESTD); + map.put("Kortestq", Mnemonic.KORTESTQ); + map.put("Kortestw", Mnemonic.KORTESTW); + map.put("Korw", Mnemonic.KORW); + map.put("Kshiftlb", Mnemonic.KSHIFTLB); + map.put("Kshiftld", Mnemonic.KSHIFTLD); + map.put("Kshiftlq", Mnemonic.KSHIFTLQ); + map.put("Kshiftlw", Mnemonic.KSHIFTLW); + map.put("Kshiftrb", Mnemonic.KSHIFTRB); + map.put("Kshiftrd", Mnemonic.KSHIFTRD); + map.put("Kshiftrq", Mnemonic.KSHIFTRQ); + map.put("Kshiftrw", Mnemonic.KSHIFTRW); + map.put("Ktestb", Mnemonic.KTESTB); + map.put("Ktestd", Mnemonic.KTESTD); + map.put("Ktestq", Mnemonic.KTESTQ); + map.put("Ktestw", Mnemonic.KTESTW); + map.put("Kunpckbw", Mnemonic.KUNPCKBW); + map.put("Kunpckdq", Mnemonic.KUNPCKDQ); + map.put("Kunpckwd", Mnemonic.KUNPCKWD); + map.put("Kxnorb", Mnemonic.KXNORB); + map.put("Kxnord", Mnemonic.KXNORD); + map.put("Kxnorq", Mnemonic.KXNORQ); + map.put("Kxnorw", Mnemonic.KXNORW); + map.put("Kxorb", Mnemonic.KXORB); + map.put("Kxord", Mnemonic.KXORD); + map.put("Kxorq", Mnemonic.KXORQ); + map.put("Kxorw", Mnemonic.KXORW); + map.put("Lahf", Mnemonic.LAHF); + map.put("Lar", Mnemonic.LAR); + map.put("Lddqu", Mnemonic.LDDQU); + map.put("Ldmxcsr", Mnemonic.LDMXCSR); + map.put("Lds", Mnemonic.LDS); + map.put("Lea", Mnemonic.LEA); + map.put("Leave", Mnemonic.LEAVE); + map.put("Les", Mnemonic.LES); + map.put("Lfence", Mnemonic.LFENCE); + map.put("Lfs", Mnemonic.LFS); + map.put("Lgdt", Mnemonic.LGDT); + map.put("Lgs", Mnemonic.LGS); + map.put("Lidt", Mnemonic.LIDT); + map.put("Lldt", Mnemonic.LLDT); + map.put("Llwpcb", Mnemonic.LLWPCB); + map.put("Lmsw", Mnemonic.LMSW); + map.put("Loadall", Mnemonic.LOADALL); + map.put("Lodsb", Mnemonic.LODSB); + map.put("Lodsd", Mnemonic.LODSD); + map.put("Lodsq", Mnemonic.LODSQ); + map.put("Lodsw", Mnemonic.LODSW); + map.put("Loop", Mnemonic.LOOP); + map.put("Loope", Mnemonic.LOOPE); + map.put("Loopne", Mnemonic.LOOPNE); + map.put("Lsl", Mnemonic.LSL); + map.put("Lss", Mnemonic.LSS); + map.put("Ltr", Mnemonic.LTR); + map.put("Lwpins", Mnemonic.LWPINS); + map.put("Lwpval", Mnemonic.LWPVAL); + map.put("Lzcnt", Mnemonic.LZCNT); + map.put("Maskmovdqu", Mnemonic.MASKMOVDQU); + map.put("Maskmovq", Mnemonic.MASKMOVQ); + map.put("Maxpd", Mnemonic.MAXPD); + map.put("Maxps", Mnemonic.MAXPS); + map.put("Maxsd", Mnemonic.MAXSD); + map.put("Maxss", Mnemonic.MAXSS); + map.put("Mcommit", Mnemonic.MCOMMIT); + map.put("Mfence", Mnemonic.MFENCE); + map.put("Minpd", Mnemonic.MINPD); + map.put("Minps", Mnemonic.MINPS); + map.put("Minsd", Mnemonic.MINSD); + map.put("Minss", Mnemonic.MINSS); + map.put("Monitor", Mnemonic.MONITOR); + map.put("Monitorx", Mnemonic.MONITORX); + map.put("Montmul", Mnemonic.MONTMUL); + map.put("Mov", Mnemonic.MOV); + map.put("Movapd", Mnemonic.MOVAPD); + map.put("Movaps", Mnemonic.MOVAPS); + map.put("Movbe", Mnemonic.MOVBE); + map.put("Movd", Mnemonic.MOVD); + map.put("Movddup", Mnemonic.MOVDDUP); + map.put("Movdir64b", Mnemonic.MOVDIR64B); + map.put("Movdiri", Mnemonic.MOVDIRI); + map.put("Movdq2q", Mnemonic.MOVDQ2Q); + map.put("Movdqa", Mnemonic.MOVDQA); + map.put("Movdqu", Mnemonic.MOVDQU); + map.put("Movhlps", Mnemonic.MOVHLPS); + map.put("Movhpd", Mnemonic.MOVHPD); + map.put("Movhps", Mnemonic.MOVHPS); + map.put("Movlhps", Mnemonic.MOVLHPS); + map.put("Movlpd", Mnemonic.MOVLPD); + map.put("Movlps", Mnemonic.MOVLPS); + map.put("Movmskpd", Mnemonic.MOVMSKPD); + map.put("Movmskps", Mnemonic.MOVMSKPS); + map.put("Movntdq", Mnemonic.MOVNTDQ); + map.put("Movntdqa", Mnemonic.MOVNTDQA); + map.put("Movnti", Mnemonic.MOVNTI); + map.put("Movntpd", Mnemonic.MOVNTPD); + map.put("Movntps", Mnemonic.MOVNTPS); + map.put("Movntq", Mnemonic.MOVNTQ); + map.put("Movntsd", Mnemonic.MOVNTSD); + map.put("Movntss", Mnemonic.MOVNTSS); + map.put("Movq", Mnemonic.MOVQ); + map.put("Movq2dq", Mnemonic.MOVQ2DQ); + map.put("Movsb", Mnemonic.MOVSB); + map.put("Movsd", Mnemonic.MOVSD); + map.put("Movshdup", Mnemonic.MOVSHDUP); + map.put("Movsldup", Mnemonic.MOVSLDUP); + map.put("Movsq", Mnemonic.MOVSQ); + map.put("Movss", Mnemonic.MOVSS); + map.put("Movsw", Mnemonic.MOVSW); + map.put("Movsx", Mnemonic.MOVSX); + map.put("Movsxd", Mnemonic.MOVSXD); + map.put("Movupd", Mnemonic.MOVUPD); + map.put("Movups", Mnemonic.MOVUPS); + map.put("Movzx", Mnemonic.MOVZX); + map.put("Mpsadbw", Mnemonic.MPSADBW); + map.put("Mul", Mnemonic.MUL); + map.put("Mulpd", Mnemonic.MULPD); + map.put("Mulps", Mnemonic.MULPS); + map.put("Mulsd", Mnemonic.MULSD); + map.put("Mulss", Mnemonic.MULSS); + map.put("Mulx", Mnemonic.MULX); + map.put("Mwait", Mnemonic.MWAIT); + map.put("Mwaitx", Mnemonic.MWAITX); + map.put("Neg", Mnemonic.NEG); + map.put("Nop", Mnemonic.NOP); + map.put("Not", Mnemonic.NOT); + map.put("Or", Mnemonic.OR); + map.put("Orpd", Mnemonic.ORPD); + map.put("Orps", Mnemonic.ORPS); + map.put("Out", Mnemonic.OUT); + map.put("Outsb", Mnemonic.OUTSB); + map.put("Outsd", Mnemonic.OUTSD); + map.put("Outsw", Mnemonic.OUTSW); + map.put("Pabsb", Mnemonic.PABSB); + map.put("Pabsd", Mnemonic.PABSD); + map.put("Pabsw", Mnemonic.PABSW); + map.put("Packssdw", Mnemonic.PACKSSDW); + map.put("Packsswb", Mnemonic.PACKSSWB); + map.put("Packusdw", Mnemonic.PACKUSDW); + map.put("Packuswb", Mnemonic.PACKUSWB); + map.put("Paddb", Mnemonic.PADDB); + map.put("Paddd", Mnemonic.PADDD); + map.put("Paddq", Mnemonic.PADDQ); + map.put("Paddsb", Mnemonic.PADDSB); + map.put("Paddsw", Mnemonic.PADDSW); + map.put("Paddusb", Mnemonic.PADDUSB); + map.put("Paddusw", Mnemonic.PADDUSW); + map.put("Paddw", Mnemonic.PADDW); + map.put("Palignr", Mnemonic.PALIGNR); + map.put("Pand", Mnemonic.PAND); + map.put("Pandn", Mnemonic.PANDN); + map.put("Pause", Mnemonic.PAUSE); + map.put("Pavgb", Mnemonic.PAVGB); + map.put("Pavgusb", Mnemonic.PAVGUSB); + map.put("Pavgw", Mnemonic.PAVGW); + map.put("Pblendvb", Mnemonic.PBLENDVB); + map.put("Pblendw", Mnemonic.PBLENDW); + map.put("Pclmulqdq", Mnemonic.PCLMULQDQ); + map.put("Pcmpeqb", Mnemonic.PCMPEQB); + } + + private static void initMap1(HashMap map) { + map.put("Pcmpeqd", Mnemonic.PCMPEQD); + map.put("Pcmpeqq", Mnemonic.PCMPEQQ); + map.put("Pcmpeqw", Mnemonic.PCMPEQW); + map.put("Pcmpestri", Mnemonic.PCMPESTRI); + map.put("Pcmpestri64", Mnemonic.PCMPESTRI64); + map.put("Pcmpestrm", Mnemonic.PCMPESTRM); + map.put("Pcmpestrm64", Mnemonic.PCMPESTRM64); + map.put("Pcmpgtb", Mnemonic.PCMPGTB); + map.put("Pcmpgtd", Mnemonic.PCMPGTD); + map.put("Pcmpgtq", Mnemonic.PCMPGTQ); + map.put("Pcmpgtw", Mnemonic.PCMPGTW); + map.put("Pcmpistri", Mnemonic.PCMPISTRI); + map.put("Pcmpistrm", Mnemonic.PCMPISTRM); + map.put("Pcommit", Mnemonic.PCOMMIT); + map.put("Pconfig", Mnemonic.PCONFIG); + map.put("Pdep", Mnemonic.PDEP); + map.put("Pext", Mnemonic.PEXT); + map.put("Pextrb", Mnemonic.PEXTRB); + map.put("Pextrd", Mnemonic.PEXTRD); + map.put("Pextrq", Mnemonic.PEXTRQ); + map.put("Pextrw", Mnemonic.PEXTRW); + map.put("Pf2id", Mnemonic.PF2ID); + map.put("Pf2iw", Mnemonic.PF2IW); + map.put("Pfacc", Mnemonic.PFACC); + map.put("Pfadd", Mnemonic.PFADD); + map.put("Pfcmpeq", Mnemonic.PFCMPEQ); + map.put("Pfcmpge", Mnemonic.PFCMPGE); + map.put("Pfcmpgt", Mnemonic.PFCMPGT); + map.put("Pfmax", Mnemonic.PFMAX); + map.put("Pfmin", Mnemonic.PFMIN); + map.put("Pfmul", Mnemonic.PFMUL); + map.put("Pfnacc", Mnemonic.PFNACC); + map.put("Pfpnacc", Mnemonic.PFPNACC); + map.put("Pfrcp", Mnemonic.PFRCP); + map.put("Pfrcpit1", Mnemonic.PFRCPIT1); + map.put("Pfrcpit2", Mnemonic.PFRCPIT2); + map.put("Pfrcpv", Mnemonic.PFRCPV); + map.put("Pfrsqit1", Mnemonic.PFRSQIT1); + map.put("Pfrsqrt", Mnemonic.PFRSQRT); + map.put("Pfrsqrtv", Mnemonic.PFRSQRTV); + map.put("Pfsub", Mnemonic.PFSUB); + map.put("Pfsubr", Mnemonic.PFSUBR); + map.put("Phaddd", Mnemonic.PHADDD); + map.put("Phaddsw", Mnemonic.PHADDSW); + map.put("Phaddw", Mnemonic.PHADDW); + map.put("Phminposuw", Mnemonic.PHMINPOSUW); + map.put("Phsubd", Mnemonic.PHSUBD); + map.put("Phsubsw", Mnemonic.PHSUBSW); + map.put("Phsubw", Mnemonic.PHSUBW); + map.put("Pi2fd", Mnemonic.PI2FD); + map.put("Pi2fw", Mnemonic.PI2FW); + map.put("Pinsrb", Mnemonic.PINSRB); + map.put("Pinsrd", Mnemonic.PINSRD); + map.put("Pinsrq", Mnemonic.PINSRQ); + map.put("Pinsrw", Mnemonic.PINSRW); + map.put("Pmaddubsw", Mnemonic.PMADDUBSW); + map.put("Pmaddwd", Mnemonic.PMADDWD); + map.put("Pmaxsb", Mnemonic.PMAXSB); + map.put("Pmaxsd", Mnemonic.PMAXSD); + map.put("Pmaxsw", Mnemonic.PMAXSW); + map.put("Pmaxub", Mnemonic.PMAXUB); + map.put("Pmaxud", Mnemonic.PMAXUD); + map.put("Pmaxuw", Mnemonic.PMAXUW); + map.put("Pminsb", Mnemonic.PMINSB); + map.put("Pminsd", Mnemonic.PMINSD); + map.put("Pminsw", Mnemonic.PMINSW); + map.put("Pminub", Mnemonic.PMINUB); + map.put("Pminud", Mnemonic.PMINUD); + map.put("Pminuw", Mnemonic.PMINUW); + map.put("Pmovmskb", Mnemonic.PMOVMSKB); + map.put("Pmovsxbd", Mnemonic.PMOVSXBD); + map.put("Pmovsxbq", Mnemonic.PMOVSXBQ); + map.put("Pmovsxbw", Mnemonic.PMOVSXBW); + map.put("Pmovsxdq", Mnemonic.PMOVSXDQ); + map.put("Pmovsxwd", Mnemonic.PMOVSXWD); + map.put("Pmovsxwq", Mnemonic.PMOVSXWQ); + map.put("Pmovzxbd", Mnemonic.PMOVZXBD); + map.put("Pmovzxbq", Mnemonic.PMOVZXBQ); + map.put("Pmovzxbw", Mnemonic.PMOVZXBW); + map.put("Pmovzxdq", Mnemonic.PMOVZXDQ); + map.put("Pmovzxwd", Mnemonic.PMOVZXWD); + map.put("Pmovzxwq", Mnemonic.PMOVZXWQ); + map.put("Pmuldq", Mnemonic.PMULDQ); + map.put("Pmulhrsw", Mnemonic.PMULHRSW); + map.put("Pmulhrw", Mnemonic.PMULHRW); + map.put("Pmulhuw", Mnemonic.PMULHUW); + map.put("Pmulhw", Mnemonic.PMULHW); + map.put("Pmulld", Mnemonic.PMULLD); + map.put("Pmullw", Mnemonic.PMULLW); + map.put("Pmuludq", Mnemonic.PMULUDQ); + map.put("Pop", Mnemonic.POP); + map.put("Popa", Mnemonic.POPA); + map.put("Popcnt", Mnemonic.POPCNT); + map.put("Popf", Mnemonic.POPF); + map.put("Por", Mnemonic.POR); + map.put("Prefetch", Mnemonic.PREFETCH); + map.put("Prefetchnta", Mnemonic.PREFETCHNTA); + map.put("Prefetcht0", Mnemonic.PREFETCHT0); + map.put("Prefetcht1", Mnemonic.PREFETCHT1); + map.put("Prefetcht2", Mnemonic.PREFETCHT2); + map.put("Prefetchw", Mnemonic.PREFETCHW); + map.put("Prefetchwt1", Mnemonic.PREFETCHWT1); + map.put("Psadbw", Mnemonic.PSADBW); + map.put("Pshufb", Mnemonic.PSHUFB); + map.put("Pshufd", Mnemonic.PSHUFD); + map.put("Pshufhw", Mnemonic.PSHUFHW); + map.put("Pshuflw", Mnemonic.PSHUFLW); + map.put("Pshufw", Mnemonic.PSHUFW); + map.put("Psignb", Mnemonic.PSIGNB); + map.put("Psignd", Mnemonic.PSIGND); + map.put("Psignw", Mnemonic.PSIGNW); + map.put("Pslld", Mnemonic.PSLLD); + map.put("Pslldq", Mnemonic.PSLLDQ); + map.put("Psllq", Mnemonic.PSLLQ); + map.put("Psllw", Mnemonic.PSLLW); + map.put("Psrad", Mnemonic.PSRAD); + map.put("Psraw", Mnemonic.PSRAW); + map.put("Psrld", Mnemonic.PSRLD); + map.put("Psrldq", Mnemonic.PSRLDQ); + map.put("Psrlq", Mnemonic.PSRLQ); + map.put("Psrlw", Mnemonic.PSRLW); + map.put("Psubb", Mnemonic.PSUBB); + map.put("Psubd", Mnemonic.PSUBD); + map.put("Psubq", Mnemonic.PSUBQ); + map.put("Psubsb", Mnemonic.PSUBSB); + map.put("Psubsw", Mnemonic.PSUBSW); + map.put("Psubusb", Mnemonic.PSUBUSB); + map.put("Psubusw", Mnemonic.PSUBUSW); + map.put("Psubw", Mnemonic.PSUBW); + map.put("Pswapd", Mnemonic.PSWAPD); + map.put("Ptest", Mnemonic.PTEST); + map.put("Ptwrite", Mnemonic.PTWRITE); + map.put("Punpckhbw", Mnemonic.PUNPCKHBW); + map.put("Punpckhdq", Mnemonic.PUNPCKHDQ); + map.put("Punpckhqdq", Mnemonic.PUNPCKHQDQ); + map.put("Punpckhwd", Mnemonic.PUNPCKHWD); + map.put("Punpcklbw", Mnemonic.PUNPCKLBW); + map.put("Punpckldq", Mnemonic.PUNPCKLDQ); + map.put("Punpcklqdq", Mnemonic.PUNPCKLQDQ); + map.put("Punpcklwd", Mnemonic.PUNPCKLWD); + map.put("Push", Mnemonic.PUSH); + map.put("Pusha", Mnemonic.PUSHA); + map.put("Pushf", Mnemonic.PUSHF); + map.put("Pxor", Mnemonic.PXOR); + map.put("Rcl", Mnemonic.RCL); + map.put("Rcpps", Mnemonic.RCPPS); + map.put("Rcpss", Mnemonic.RCPSS); + map.put("Rcr", Mnemonic.RCR); + map.put("Rdfsbase", Mnemonic.RDFSBASE); + map.put("Rdgsbase", Mnemonic.RDGSBASE); + map.put("Rdmsr", Mnemonic.RDMSR); + map.put("Rdpid", Mnemonic.RDPID); + map.put("Rdpkru", Mnemonic.RDPKRU); + map.put("Rdpmc", Mnemonic.RDPMC); + map.put("Rdpru", Mnemonic.RDPRU); + map.put("Rdrand", Mnemonic.RDRAND); + map.put("Rdseed", Mnemonic.RDSEED); + map.put("Rdsspd", Mnemonic.RDSSPD); + map.put("Rdsspq", Mnemonic.RDSSPQ); + map.put("Rdtsc", Mnemonic.RDTSC); + map.put("Rdtscp", Mnemonic.RDTSCP); + map.put("Reservednop", Mnemonic.RESERVEDNOP); + map.put("Ret", Mnemonic.RET); + map.put("Retf", Mnemonic.RETF); + map.put("Rol", Mnemonic.ROL); + map.put("Ror", Mnemonic.ROR); + map.put("Rorx", Mnemonic.RORX); + map.put("Roundpd", Mnemonic.ROUNDPD); + map.put("Roundps", Mnemonic.ROUNDPS); + map.put("Roundsd", Mnemonic.ROUNDSD); + map.put("Roundss", Mnemonic.ROUNDSS); + map.put("Rsm", Mnemonic.RSM); + map.put("Rsqrtps", Mnemonic.RSQRTPS); + map.put("Rsqrtss", Mnemonic.RSQRTSS); + map.put("Rstorssp", Mnemonic.RSTORSSP); + map.put("Sahf", Mnemonic.SAHF); + map.put("Sal", Mnemonic.SAL); + map.put("Salc", Mnemonic.SALC); + map.put("Sar", Mnemonic.SAR); + map.put("Sarx", Mnemonic.SARX); + map.put("Saveprevssp", Mnemonic.SAVEPREVSSP); + map.put("Sbb", Mnemonic.SBB); + map.put("Scasb", Mnemonic.SCASB); + map.put("Scasd", Mnemonic.SCASD); + map.put("Scasq", Mnemonic.SCASQ); + map.put("Scasw", Mnemonic.SCASW); + map.put("Seta", Mnemonic.SETA); + map.put("Setae", Mnemonic.SETAE); + map.put("Setb", Mnemonic.SETB); + map.put("Setbe", Mnemonic.SETBE); + map.put("Sete", Mnemonic.SETE); + map.put("Setg", Mnemonic.SETG); + map.put("Setge", Mnemonic.SETGE); + map.put("Setl", Mnemonic.SETL); + map.put("Setle", Mnemonic.SETLE); + map.put("Setne", Mnemonic.SETNE); + map.put("Setno", Mnemonic.SETNO); + map.put("Setnp", Mnemonic.SETNP); + map.put("Setns", Mnemonic.SETNS); + map.put("Seto", Mnemonic.SETO); + map.put("Setp", Mnemonic.SETP); + map.put("Sets", Mnemonic.SETS); + map.put("Setssbsy", Mnemonic.SETSSBSY); + map.put("Sfence", Mnemonic.SFENCE); + map.put("Sgdt", Mnemonic.SGDT); + map.put("Sha1msg1", Mnemonic.SHA1MSG1); + map.put("Sha1msg2", Mnemonic.SHA1MSG2); + map.put("Sha1nexte", Mnemonic.SHA1NEXTE); + map.put("Sha1rnds4", Mnemonic.SHA1RNDS4); + map.put("Sha256msg1", Mnemonic.SHA256MSG1); + map.put("Sha256msg2", Mnemonic.SHA256MSG2); + map.put("Sha256rnds2", Mnemonic.SHA256RNDS2); + map.put("Shl", Mnemonic.SHL); + map.put("Shld", Mnemonic.SHLD); + map.put("Shlx", Mnemonic.SHLX); + map.put("Shr", Mnemonic.SHR); + map.put("Shrd", Mnemonic.SHRD); + map.put("Shrx", Mnemonic.SHRX); + map.put("Shufpd", Mnemonic.SHUFPD); + map.put("Shufps", Mnemonic.SHUFPS); + map.put("Sidt", Mnemonic.SIDT); + map.put("Skinit", Mnemonic.SKINIT); + map.put("Sldt", Mnemonic.SLDT); + map.put("Slwpcb", Mnemonic.SLWPCB); + map.put("Smsw", Mnemonic.SMSW); + map.put("Sqrtpd", Mnemonic.SQRTPD); + map.put("Sqrtps", Mnemonic.SQRTPS); + map.put("Sqrtsd", Mnemonic.SQRTSD); + map.put("Sqrtss", Mnemonic.SQRTSS); + map.put("Stac", Mnemonic.STAC); + map.put("Stc", Mnemonic.STC); + map.put("Std", Mnemonic.STD); + map.put("Stgi", Mnemonic.STGI); + map.put("Sti", Mnemonic.STI); + map.put("Stmxcsr", Mnemonic.STMXCSR); + map.put("Stosb", Mnemonic.STOSB); + map.put("Stosd", Mnemonic.STOSD); + map.put("Stosq", Mnemonic.STOSQ); + map.put("Stosw", Mnemonic.STOSW); + map.put("Str", Mnemonic.STR); + map.put("Sub", Mnemonic.SUB); + map.put("Subpd", Mnemonic.SUBPD); + map.put("Subps", Mnemonic.SUBPS); + map.put("Subsd", Mnemonic.SUBSD); + map.put("Subss", Mnemonic.SUBSS); + map.put("Swapgs", Mnemonic.SWAPGS); + map.put("Syscall", Mnemonic.SYSCALL); + map.put("Sysenter", Mnemonic.SYSENTER); + map.put("Sysexit", Mnemonic.SYSEXIT); + map.put("Sysret", Mnemonic.SYSRET); + map.put("T1mskc", Mnemonic.T1MSKC); + map.put("Test", Mnemonic.TEST); + map.put("Tpause", Mnemonic.TPAUSE); + map.put("Tzcnt", Mnemonic.TZCNT); + map.put("Tzmsk", Mnemonic.TZMSK); + map.put("Ucomisd", Mnemonic.UCOMISD); + map.put("Ucomiss", Mnemonic.UCOMISS); + map.put("Ud0", Mnemonic.UD0); + map.put("Ud1", Mnemonic.UD1); + map.put("Ud2", Mnemonic.UD2); + map.put("Umonitor", Mnemonic.UMONITOR); + map.put("Umov", Mnemonic.UMOV); + map.put("Umwait", Mnemonic.UMWAIT); + map.put("Unpckhpd", Mnemonic.UNPCKHPD); + map.put("Unpckhps", Mnemonic.UNPCKHPS); + map.put("Unpcklpd", Mnemonic.UNPCKLPD); + map.put("Unpcklps", Mnemonic.UNPCKLPS); + map.put("V4fmaddps", Mnemonic.V4FMADDPS); + map.put("V4fmaddss", Mnemonic.V4FMADDSS); + map.put("V4fnmaddps", Mnemonic.V4FNMADDPS); + map.put("V4fnmaddss", Mnemonic.V4FNMADDSS); + map.put("Vaddpd", Mnemonic.VADDPD); + map.put("Vaddps", Mnemonic.VADDPS); + map.put("Vaddsd", Mnemonic.VADDSD); + map.put("Vaddss", Mnemonic.VADDSS); + map.put("Vaddsubpd", Mnemonic.VADDSUBPD); + map.put("Vaddsubps", Mnemonic.VADDSUBPS); + map.put("Vaesdec", Mnemonic.VAESDEC); + map.put("Vaesdeclast", Mnemonic.VAESDECLAST); + map.put("Vaesenc", Mnemonic.VAESENC); + map.put("Vaesenclast", Mnemonic.VAESENCLAST); + map.put("Vaesimc", Mnemonic.VAESIMC); + map.put("Vaeskeygenassist", Mnemonic.VAESKEYGENASSIST); + map.put("Valignd", Mnemonic.VALIGND); + map.put("Valignq", Mnemonic.VALIGNQ); + map.put("Vandnpd", Mnemonic.VANDNPD); + map.put("Vandnps", Mnemonic.VANDNPS); + map.put("Vandpd", Mnemonic.VANDPD); + map.put("Vandps", Mnemonic.VANDPS); + map.put("Vblendmpd", Mnemonic.VBLENDMPD); + map.put("Vblendmps", Mnemonic.VBLENDMPS); + map.put("Vblendpd", Mnemonic.VBLENDPD); + map.put("Vblendps", Mnemonic.VBLENDPS); + map.put("Vblendvpd", Mnemonic.VBLENDVPD); + map.put("Vblendvps", Mnemonic.VBLENDVPS); + map.put("Vbroadcastf128", Mnemonic.VBROADCASTF128); + map.put("Vbroadcastf32x2", Mnemonic.VBROADCASTF32X2); + map.put("Vbroadcastf32x4", Mnemonic.VBROADCASTF32X4); + map.put("Vbroadcastf32x8", Mnemonic.VBROADCASTF32X8); + map.put("Vbroadcastf64x2", Mnemonic.VBROADCASTF64X2); + map.put("Vbroadcastf64x4", Mnemonic.VBROADCASTF64X4); + map.put("Vbroadcasti128", Mnemonic.VBROADCASTI128); + map.put("Vbroadcasti32x2", Mnemonic.VBROADCASTI32X2); + map.put("Vbroadcasti32x4", Mnemonic.VBROADCASTI32X4); + map.put("Vbroadcasti32x8", Mnemonic.VBROADCASTI32X8); + map.put("Vbroadcasti64x2", Mnemonic.VBROADCASTI64X2); + map.put("Vbroadcasti64x4", Mnemonic.VBROADCASTI64X4); + map.put("Vbroadcastsd", Mnemonic.VBROADCASTSD); + map.put("Vbroadcastss", Mnemonic.VBROADCASTSS); + map.put("Vcmppd", Mnemonic.VCMPPD); + map.put("Vcmpps", Mnemonic.VCMPPS); + map.put("Vcmpsd", Mnemonic.VCMPSD); + map.put("Vcmpss", Mnemonic.VCMPSS); + map.put("Vcomisd", Mnemonic.VCOMISD); + map.put("Vcomiss", Mnemonic.VCOMISS); + map.put("Vcompresspd", Mnemonic.VCOMPRESSPD); + map.put("Vcompressps", Mnemonic.VCOMPRESSPS); + map.put("Vcvtdq2pd", Mnemonic.VCVTDQ2PD); + map.put("Vcvtdq2ps", Mnemonic.VCVTDQ2PS); + map.put("Vcvtne2ps2bf16", Mnemonic.VCVTNE2PS2BF16); + map.put("Vcvtneps2bf16", Mnemonic.VCVTNEPS2BF16); + map.put("Vcvtpd2dq", Mnemonic.VCVTPD2DQ); + map.put("Vcvtpd2ps", Mnemonic.VCVTPD2PS); + map.put("Vcvtpd2qq", Mnemonic.VCVTPD2QQ); + map.put("Vcvtpd2udq", Mnemonic.VCVTPD2UDQ); + map.put("Vcvtpd2uqq", Mnemonic.VCVTPD2UQQ); + map.put("Vcvtph2ps", Mnemonic.VCVTPH2PS); + map.put("Vcvtps2dq", Mnemonic.VCVTPS2DQ); + map.put("Vcvtps2pd", Mnemonic.VCVTPS2PD); + map.put("Vcvtps2ph", Mnemonic.VCVTPS2PH); + map.put("Vcvtps2qq", Mnemonic.VCVTPS2QQ); + map.put("Vcvtps2udq", Mnemonic.VCVTPS2UDQ); + map.put("Vcvtps2uqq", Mnemonic.VCVTPS2UQQ); + map.put("Vcvtqq2pd", Mnemonic.VCVTQQ2PD); + map.put("Vcvtqq2ps", Mnemonic.VCVTQQ2PS); + map.put("Vcvtsd2si", Mnemonic.VCVTSD2SI); + map.put("Vcvtsd2ss", Mnemonic.VCVTSD2SS); + map.put("Vcvtsd2usi", Mnemonic.VCVTSD2USI); + map.put("Vcvtsi2sd", Mnemonic.VCVTSI2SD); + map.put("Vcvtsi2ss", Mnemonic.VCVTSI2SS); + map.put("Vcvtss2sd", Mnemonic.VCVTSS2SD); + map.put("Vcvtss2si", Mnemonic.VCVTSS2SI); + map.put("Vcvtss2usi", Mnemonic.VCVTSS2USI); + map.put("Vcvttpd2dq", Mnemonic.VCVTTPD2DQ); + map.put("Vcvttpd2qq", Mnemonic.VCVTTPD2QQ); + map.put("Vcvttpd2udq", Mnemonic.VCVTTPD2UDQ); + map.put("Vcvttpd2uqq", Mnemonic.VCVTTPD2UQQ); + map.put("Vcvttps2dq", Mnemonic.VCVTTPS2DQ); + map.put("Vcvttps2qq", Mnemonic.VCVTTPS2QQ); + map.put("Vcvttps2udq", Mnemonic.VCVTTPS2UDQ); + map.put("Vcvttps2uqq", Mnemonic.VCVTTPS2UQQ); + map.put("Vcvttsd2si", Mnemonic.VCVTTSD2SI); + map.put("Vcvttsd2usi", Mnemonic.VCVTTSD2USI); + map.put("Vcvttss2si", Mnemonic.VCVTTSS2SI); + map.put("Vcvttss2usi", Mnemonic.VCVTTSS2USI); + map.put("Vcvtudq2pd", Mnemonic.VCVTUDQ2PD); + map.put("Vcvtudq2ps", Mnemonic.VCVTUDQ2PS); + map.put("Vcvtuqq2pd", Mnemonic.VCVTUQQ2PD); + map.put("Vcvtuqq2ps", Mnemonic.VCVTUQQ2PS); + map.put("Vcvtusi2sd", Mnemonic.VCVTUSI2SD); + map.put("Vcvtusi2ss", Mnemonic.VCVTUSI2SS); + map.put("Vdbpsadbw", Mnemonic.VDBPSADBW); + map.put("Vdivpd", Mnemonic.VDIVPD); + map.put("Vdivps", Mnemonic.VDIVPS); + map.put("Vdivsd", Mnemonic.VDIVSD); + map.put("Vdivss", Mnemonic.VDIVSS); + map.put("Vdpbf16ps", Mnemonic.VDPBF16PS); + map.put("Vdppd", Mnemonic.VDPPD); + map.put("Vdpps", Mnemonic.VDPPS); + map.put("Verr", Mnemonic.VERR); + map.put("Verw", Mnemonic.VERW); + map.put("Vexp2pd", Mnemonic.VEXP2PD); + map.put("Vexp2ps", Mnemonic.VEXP2PS); + map.put("Vexpandpd", Mnemonic.VEXPANDPD); + map.put("Vexpandps", Mnemonic.VEXPANDPS); + map.put("Vextractf128", Mnemonic.VEXTRACTF128); + map.put("Vextractf32x4", Mnemonic.VEXTRACTF32X4); + map.put("Vextractf32x8", Mnemonic.VEXTRACTF32X8); + map.put("Vextractf64x2", Mnemonic.VEXTRACTF64X2); + map.put("Vextractf64x4", Mnemonic.VEXTRACTF64X4); + map.put("Vextracti128", Mnemonic.VEXTRACTI128); + map.put("Vextracti32x4", Mnemonic.VEXTRACTI32X4); + map.put("Vextracti32x8", Mnemonic.VEXTRACTI32X8); + map.put("Vextracti64x2", Mnemonic.VEXTRACTI64X2); + map.put("Vextracti64x4", Mnemonic.VEXTRACTI64X4); + map.put("Vextractps", Mnemonic.VEXTRACTPS); + map.put("Vfixupimmpd", Mnemonic.VFIXUPIMMPD); + map.put("Vfixupimmps", Mnemonic.VFIXUPIMMPS); + map.put("Vfixupimmsd", Mnemonic.VFIXUPIMMSD); + map.put("Vfixupimmss", Mnemonic.VFIXUPIMMSS); + map.put("Vfmadd132pd", Mnemonic.VFMADD132PD); + map.put("Vfmadd132ps", Mnemonic.VFMADD132PS); + map.put("Vfmadd132sd", Mnemonic.VFMADD132SD); + map.put("Vfmadd132ss", Mnemonic.VFMADD132SS); + map.put("Vfmadd213pd", Mnemonic.VFMADD213PD); + map.put("Vfmadd213ps", Mnemonic.VFMADD213PS); + map.put("Vfmadd213sd", Mnemonic.VFMADD213SD); + map.put("Vfmadd213ss", Mnemonic.VFMADD213SS); + map.put("Vfmadd231pd", Mnemonic.VFMADD231PD); + map.put("Vfmadd231ps", Mnemonic.VFMADD231PS); + map.put("Vfmadd231sd", Mnemonic.VFMADD231SD); + map.put("Vfmadd231ss", Mnemonic.VFMADD231SS); + map.put("Vfmaddpd", Mnemonic.VFMADDPD); + map.put("Vfmaddps", Mnemonic.VFMADDPS); + map.put("Vfmaddsd", Mnemonic.VFMADDSD); + map.put("Vfmaddss", Mnemonic.VFMADDSS); + map.put("Vfmaddsub132pd", Mnemonic.VFMADDSUB132PD); + map.put("Vfmaddsub132ps", Mnemonic.VFMADDSUB132PS); + map.put("Vfmaddsub213pd", Mnemonic.VFMADDSUB213PD); + map.put("Vfmaddsub213ps", Mnemonic.VFMADDSUB213PS); + map.put("Vfmaddsub231pd", Mnemonic.VFMADDSUB231PD); + map.put("Vfmaddsub231ps", Mnemonic.VFMADDSUB231PS); + map.put("Vfmaddsubpd", Mnemonic.VFMADDSUBPD); + map.put("Vfmaddsubps", Mnemonic.VFMADDSUBPS); + map.put("Vfmsub132pd", Mnemonic.VFMSUB132PD); + map.put("Vfmsub132ps", Mnemonic.VFMSUB132PS); + map.put("Vfmsub132sd", Mnemonic.VFMSUB132SD); + map.put("Vfmsub132ss", Mnemonic.VFMSUB132SS); + map.put("Vfmsub213pd", Mnemonic.VFMSUB213PD); + map.put("Vfmsub213ps", Mnemonic.VFMSUB213PS); + map.put("Vfmsub213sd", Mnemonic.VFMSUB213SD); + map.put("Vfmsub213ss", Mnemonic.VFMSUB213SS); + map.put("Vfmsub231pd", Mnemonic.VFMSUB231PD); + map.put("Vfmsub231ps", Mnemonic.VFMSUB231PS); + map.put("Vfmsub231sd", Mnemonic.VFMSUB231SD); + map.put("Vfmsub231ss", Mnemonic.VFMSUB231SS); + map.put("Vfmsubadd132pd", Mnemonic.VFMSUBADD132PD); + map.put("Vfmsubadd132ps", Mnemonic.VFMSUBADD132PS); + map.put("Vfmsubadd213pd", Mnemonic.VFMSUBADD213PD); + map.put("Vfmsubadd213ps", Mnemonic.VFMSUBADD213PS); + map.put("Vfmsubadd231pd", Mnemonic.VFMSUBADD231PD); + map.put("Vfmsubadd231ps", Mnemonic.VFMSUBADD231PS); + map.put("Vfmsubaddpd", Mnemonic.VFMSUBADDPD); + map.put("Vfmsubaddps", Mnemonic.VFMSUBADDPS); + map.put("Vfmsubpd", Mnemonic.VFMSUBPD); + map.put("Vfmsubps", Mnemonic.VFMSUBPS); + map.put("Vfmsubsd", Mnemonic.VFMSUBSD); + map.put("Vfmsubss", Mnemonic.VFMSUBSS); + map.put("Vfnmadd132pd", Mnemonic.VFNMADD132PD); + map.put("Vfnmadd132ps", Mnemonic.VFNMADD132PS); + map.put("Vfnmadd132sd", Mnemonic.VFNMADD132SD); + map.put("Vfnmadd132ss", Mnemonic.VFNMADD132SS); + map.put("Vfnmadd213pd", Mnemonic.VFNMADD213PD); + map.put("Vfnmadd213ps", Mnemonic.VFNMADD213PS); + map.put("Vfnmadd213sd", Mnemonic.VFNMADD213SD); + map.put("Vfnmadd213ss", Mnemonic.VFNMADD213SS); + map.put("Vfnmadd231pd", Mnemonic.VFNMADD231PD); + map.put("Vfnmadd231ps", Mnemonic.VFNMADD231PS); + map.put("Vfnmadd231sd", Mnemonic.VFNMADD231SD); + map.put("Vfnmadd231ss", Mnemonic.VFNMADD231SS); + map.put("Vfnmaddpd", Mnemonic.VFNMADDPD); + map.put("Vfnmaddps", Mnemonic.VFNMADDPS); + map.put("Vfnmaddsd", Mnemonic.VFNMADDSD); + map.put("Vfnmaddss", Mnemonic.VFNMADDSS); + map.put("Vfnmsub132pd", Mnemonic.VFNMSUB132PD); + map.put("Vfnmsub132ps", Mnemonic.VFNMSUB132PS); + map.put("Vfnmsub132sd", Mnemonic.VFNMSUB132SD); + map.put("Vfnmsub132ss", Mnemonic.VFNMSUB132SS); + map.put("Vfnmsub213pd", Mnemonic.VFNMSUB213PD); + map.put("Vfnmsub213ps", Mnemonic.VFNMSUB213PS); + map.put("Vfnmsub213sd", Mnemonic.VFNMSUB213SD); + map.put("Vfnmsub213ss", Mnemonic.VFNMSUB213SS); + map.put("Vfnmsub231pd", Mnemonic.VFNMSUB231PD); + map.put("Vfnmsub231ps", Mnemonic.VFNMSUB231PS); + map.put("Vfnmsub231sd", Mnemonic.VFNMSUB231SD); + map.put("Vfnmsub231ss", Mnemonic.VFNMSUB231SS); + map.put("Vfnmsubpd", Mnemonic.VFNMSUBPD); + map.put("Vfnmsubps", Mnemonic.VFNMSUBPS); + map.put("Vfnmsubsd", Mnemonic.VFNMSUBSD); + map.put("Vfnmsubss", Mnemonic.VFNMSUBSS); + map.put("Vfpclasspd", Mnemonic.VFPCLASSPD); + map.put("Vfpclassps", Mnemonic.VFPCLASSPS); + map.put("Vfpclasssd", Mnemonic.VFPCLASSSD); + map.put("Vfpclassss", Mnemonic.VFPCLASSSS); + map.put("Vfrczpd", Mnemonic.VFRCZPD); + map.put("Vfrczps", Mnemonic.VFRCZPS); + map.put("Vfrczsd", Mnemonic.VFRCZSD); + map.put("Vfrczss", Mnemonic.VFRCZSS); + map.put("Vgatherdpd", Mnemonic.VGATHERDPD); + map.put("Vgatherdps", Mnemonic.VGATHERDPS); + map.put("Vgatherpf0dpd", Mnemonic.VGATHERPF0DPD); + map.put("Vgatherpf0dps", Mnemonic.VGATHERPF0DPS); + map.put("Vgatherpf0qpd", Mnemonic.VGATHERPF0QPD); + map.put("Vgatherpf0qps", Mnemonic.VGATHERPF0QPS); + map.put("Vgatherpf1dpd", Mnemonic.VGATHERPF1DPD); + map.put("Vgatherpf1dps", Mnemonic.VGATHERPF1DPS); + map.put("Vgatherpf1qpd", Mnemonic.VGATHERPF1QPD); + map.put("Vgatherpf1qps", Mnemonic.VGATHERPF1QPS); + map.put("Vgatherqpd", Mnemonic.VGATHERQPD); + map.put("Vgatherqps", Mnemonic.VGATHERQPS); + map.put("Vgetexppd", Mnemonic.VGETEXPPD); + map.put("Vgetexpps", Mnemonic.VGETEXPPS); + map.put("Vgetexpsd", Mnemonic.VGETEXPSD); + map.put("Vgetexpss", Mnemonic.VGETEXPSS); + map.put("Vgetmantpd", Mnemonic.VGETMANTPD); + map.put("Vgetmantps", Mnemonic.VGETMANTPS); + map.put("Vgetmantsd", Mnemonic.VGETMANTSD); + map.put("Vgetmantss", Mnemonic.VGETMANTSS); + map.put("Vgf2p8affineinvqb", Mnemonic.VGF2P8AFFINEINVQB); + map.put("Vgf2p8affineqb", Mnemonic.VGF2P8AFFINEQB); + } + + private static void initMap2(HashMap map) { + map.put("Vgf2p8mulb", Mnemonic.VGF2P8MULB); + map.put("Vhaddpd", Mnemonic.VHADDPD); + map.put("Vhaddps", Mnemonic.VHADDPS); + map.put("Vhsubpd", Mnemonic.VHSUBPD); + map.put("Vhsubps", Mnemonic.VHSUBPS); + map.put("Vinsertf128", Mnemonic.VINSERTF128); + map.put("Vinsertf32x4", Mnemonic.VINSERTF32X4); + map.put("Vinsertf32x8", Mnemonic.VINSERTF32X8); + map.put("Vinsertf64x2", Mnemonic.VINSERTF64X2); + map.put("Vinsertf64x4", Mnemonic.VINSERTF64X4); + map.put("Vinserti128", Mnemonic.VINSERTI128); + map.put("Vinserti32x4", Mnemonic.VINSERTI32X4); + map.put("Vinserti32x8", Mnemonic.VINSERTI32X8); + map.put("Vinserti64x2", Mnemonic.VINSERTI64X2); + map.put("Vinserti64x4", Mnemonic.VINSERTI64X4); + map.put("Vinsertps", Mnemonic.VINSERTPS); + map.put("Vlddqu", Mnemonic.VLDDQU); + map.put("Vldmxcsr", Mnemonic.VLDMXCSR); + map.put("Vmaskmovdqu", Mnemonic.VMASKMOVDQU); + map.put("Vmaskmovpd", Mnemonic.VMASKMOVPD); + map.put("Vmaskmovps", Mnemonic.VMASKMOVPS); + map.put("Vmaxpd", Mnemonic.VMAXPD); + map.put("Vmaxps", Mnemonic.VMAXPS); + map.put("Vmaxsd", Mnemonic.VMAXSD); + map.put("Vmaxss", Mnemonic.VMAXSS); + map.put("Vmcall", Mnemonic.VMCALL); + map.put("Vmclear", Mnemonic.VMCLEAR); + map.put("Vmfunc", Mnemonic.VMFUNC); + map.put("Vminpd", Mnemonic.VMINPD); + map.put("Vminps", Mnemonic.VMINPS); + map.put("Vminsd", Mnemonic.VMINSD); + map.put("Vminss", Mnemonic.VMINSS); + map.put("Vmlaunch", Mnemonic.VMLAUNCH); + map.put("Vmload", Mnemonic.VMLOAD); + map.put("Vmmcall", Mnemonic.VMMCALL); + map.put("Vmovapd", Mnemonic.VMOVAPD); + map.put("Vmovaps", Mnemonic.VMOVAPS); + map.put("Vmovd", Mnemonic.VMOVD); + map.put("Vmovddup", Mnemonic.VMOVDDUP); + map.put("Vmovdqa", Mnemonic.VMOVDQA); + map.put("Vmovdqa32", Mnemonic.VMOVDQA32); + map.put("Vmovdqa64", Mnemonic.VMOVDQA64); + map.put("Vmovdqu", Mnemonic.VMOVDQU); + map.put("Vmovdqu16", Mnemonic.VMOVDQU16); + map.put("Vmovdqu32", Mnemonic.VMOVDQU32); + map.put("Vmovdqu64", Mnemonic.VMOVDQU64); + map.put("Vmovdqu8", Mnemonic.VMOVDQU8); + map.put("Vmovhlps", Mnemonic.VMOVHLPS); + map.put("Vmovhpd", Mnemonic.VMOVHPD); + map.put("Vmovhps", Mnemonic.VMOVHPS); + map.put("Vmovlhps", Mnemonic.VMOVLHPS); + map.put("Vmovlpd", Mnemonic.VMOVLPD); + map.put("Vmovlps", Mnemonic.VMOVLPS); + map.put("Vmovmskpd", Mnemonic.VMOVMSKPD); + map.put("Vmovmskps", Mnemonic.VMOVMSKPS); + map.put("Vmovntdq", Mnemonic.VMOVNTDQ); + map.put("Vmovntdqa", Mnemonic.VMOVNTDQA); + map.put("Vmovntpd", Mnemonic.VMOVNTPD); + map.put("Vmovntps", Mnemonic.VMOVNTPS); + map.put("Vmovq", Mnemonic.VMOVQ); + map.put("Vmovsd", Mnemonic.VMOVSD); + map.put("Vmovshdup", Mnemonic.VMOVSHDUP); + map.put("Vmovsldup", Mnemonic.VMOVSLDUP); + map.put("Vmovss", Mnemonic.VMOVSS); + map.put("Vmovupd", Mnemonic.VMOVUPD); + map.put("Vmovups", Mnemonic.VMOVUPS); + map.put("Vmpsadbw", Mnemonic.VMPSADBW); + map.put("Vmptrld", Mnemonic.VMPTRLD); + map.put("Vmptrst", Mnemonic.VMPTRST); + map.put("Vmread", Mnemonic.VMREAD); + map.put("Vmresume", Mnemonic.VMRESUME); + map.put("Vmrun", Mnemonic.VMRUN); + map.put("Vmsave", Mnemonic.VMSAVE); + map.put("Vmulpd", Mnemonic.VMULPD); + map.put("Vmulps", Mnemonic.VMULPS); + map.put("Vmulsd", Mnemonic.VMULSD); + map.put("Vmulss", Mnemonic.VMULSS); + map.put("Vmwrite", Mnemonic.VMWRITE); + map.put("Vmxoff", Mnemonic.VMXOFF); + map.put("Vmxon", Mnemonic.VMXON); + map.put("Vorpd", Mnemonic.VORPD); + map.put("Vorps", Mnemonic.VORPS); + map.put("Vp2intersectd", Mnemonic.VP2INTERSECTD); + map.put("Vp2intersectq", Mnemonic.VP2INTERSECTQ); + map.put("Vp4dpwssd", Mnemonic.VP4DPWSSD); + map.put("Vp4dpwssds", Mnemonic.VP4DPWSSDS); + map.put("Vpabsb", Mnemonic.VPABSB); + map.put("Vpabsd", Mnemonic.VPABSD); + map.put("Vpabsq", Mnemonic.VPABSQ); + map.put("Vpabsw", Mnemonic.VPABSW); + map.put("Vpackssdw", Mnemonic.VPACKSSDW); + map.put("Vpacksswb", Mnemonic.VPACKSSWB); + map.put("Vpackusdw", Mnemonic.VPACKUSDW); + map.put("Vpackuswb", Mnemonic.VPACKUSWB); + map.put("Vpaddb", Mnemonic.VPADDB); + map.put("Vpaddd", Mnemonic.VPADDD); + map.put("Vpaddq", Mnemonic.VPADDQ); + map.put("Vpaddsb", Mnemonic.VPADDSB); + map.put("Vpaddsw", Mnemonic.VPADDSW); + map.put("Vpaddusb", Mnemonic.VPADDUSB); + map.put("Vpaddusw", Mnemonic.VPADDUSW); + map.put("Vpaddw", Mnemonic.VPADDW); + map.put("Vpalignr", Mnemonic.VPALIGNR); + map.put("Vpand", Mnemonic.VPAND); + map.put("Vpandd", Mnemonic.VPANDD); + map.put("Vpandn", Mnemonic.VPANDN); + map.put("Vpandnd", Mnemonic.VPANDND); + map.put("Vpandnq", Mnemonic.VPANDNQ); + map.put("Vpandq", Mnemonic.VPANDQ); + map.put("Vpavgb", Mnemonic.VPAVGB); + map.put("Vpavgw", Mnemonic.VPAVGW); + map.put("Vpblendd", Mnemonic.VPBLENDD); + map.put("Vpblendmb", Mnemonic.VPBLENDMB); + map.put("Vpblendmd", Mnemonic.VPBLENDMD); + map.put("Vpblendmq", Mnemonic.VPBLENDMQ); + map.put("Vpblendmw", Mnemonic.VPBLENDMW); + map.put("Vpblendvb", Mnemonic.VPBLENDVB); + map.put("Vpblendw", Mnemonic.VPBLENDW); + map.put("Vpbroadcastb", Mnemonic.VPBROADCASTB); + map.put("Vpbroadcastd", Mnemonic.VPBROADCASTD); + map.put("Vpbroadcastmb2q", Mnemonic.VPBROADCASTMB2Q); + map.put("Vpbroadcastmw2d", Mnemonic.VPBROADCASTMW2D); + map.put("Vpbroadcastq", Mnemonic.VPBROADCASTQ); + map.put("Vpbroadcastw", Mnemonic.VPBROADCASTW); + map.put("Vpclmulqdq", Mnemonic.VPCLMULQDQ); + map.put("Vpcmov", Mnemonic.VPCMOV); + map.put("Vpcmpb", Mnemonic.VPCMPB); + map.put("Vpcmpd", Mnemonic.VPCMPD); + map.put("Vpcmpeqb", Mnemonic.VPCMPEQB); + map.put("Vpcmpeqd", Mnemonic.VPCMPEQD); + map.put("Vpcmpeqq", Mnemonic.VPCMPEQQ); + map.put("Vpcmpeqw", Mnemonic.VPCMPEQW); + map.put("Vpcmpestri", Mnemonic.VPCMPESTRI); + map.put("Vpcmpestri64", Mnemonic.VPCMPESTRI64); + map.put("Vpcmpestrm", Mnemonic.VPCMPESTRM); + map.put("Vpcmpestrm64", Mnemonic.VPCMPESTRM64); + map.put("Vpcmpgtb", Mnemonic.VPCMPGTB); + map.put("Vpcmpgtd", Mnemonic.VPCMPGTD); + map.put("Vpcmpgtq", Mnemonic.VPCMPGTQ); + map.put("Vpcmpgtw", Mnemonic.VPCMPGTW); + map.put("Vpcmpistri", Mnemonic.VPCMPISTRI); + map.put("Vpcmpistrm", Mnemonic.VPCMPISTRM); + map.put("Vpcmpq", Mnemonic.VPCMPQ); + map.put("Vpcmpub", Mnemonic.VPCMPUB); + map.put("Vpcmpud", Mnemonic.VPCMPUD); + map.put("Vpcmpuq", Mnemonic.VPCMPUQ); + map.put("Vpcmpuw", Mnemonic.VPCMPUW); + map.put("Vpcmpw", Mnemonic.VPCMPW); + map.put("Vpcomb", Mnemonic.VPCOMB); + map.put("Vpcomd", Mnemonic.VPCOMD); + map.put("Vpcompressb", Mnemonic.VPCOMPRESSB); + map.put("Vpcompressd", Mnemonic.VPCOMPRESSD); + map.put("Vpcompressq", Mnemonic.VPCOMPRESSQ); + map.put("Vpcompressw", Mnemonic.VPCOMPRESSW); + map.put("Vpcomq", Mnemonic.VPCOMQ); + map.put("Vpcomub", Mnemonic.VPCOMUB); + map.put("Vpcomud", Mnemonic.VPCOMUD); + map.put("Vpcomuq", Mnemonic.VPCOMUQ); + map.put("Vpcomuw", Mnemonic.VPCOMUW); + map.put("Vpcomw", Mnemonic.VPCOMW); + map.put("Vpconflictd", Mnemonic.VPCONFLICTD); + map.put("Vpconflictq", Mnemonic.VPCONFLICTQ); + map.put("Vpdpbusd", Mnemonic.VPDPBUSD); + map.put("Vpdpbusds", Mnemonic.VPDPBUSDS); + map.put("Vpdpwssd", Mnemonic.VPDPWSSD); + map.put("Vpdpwssds", Mnemonic.VPDPWSSDS); + map.put("Vperm2f128", Mnemonic.VPERM2F128); + map.put("Vperm2i128", Mnemonic.VPERM2I128); + map.put("Vpermb", Mnemonic.VPERMB); + map.put("Vpermd", Mnemonic.VPERMD); + map.put("Vpermi2b", Mnemonic.VPERMI2B); + map.put("Vpermi2d", Mnemonic.VPERMI2D); + map.put("Vpermi2pd", Mnemonic.VPERMI2PD); + map.put("Vpermi2ps", Mnemonic.VPERMI2PS); + map.put("Vpermi2q", Mnemonic.VPERMI2Q); + map.put("Vpermi2w", Mnemonic.VPERMI2W); + map.put("Vpermil2pd", Mnemonic.VPERMIL2PD); + map.put("Vpermil2ps", Mnemonic.VPERMIL2PS); + map.put("Vpermilpd", Mnemonic.VPERMILPD); + map.put("Vpermilps", Mnemonic.VPERMILPS); + map.put("Vpermpd", Mnemonic.VPERMPD); + map.put("Vpermps", Mnemonic.VPERMPS); + map.put("Vpermq", Mnemonic.VPERMQ); + map.put("Vpermt2b", Mnemonic.VPERMT2B); + map.put("Vpermt2d", Mnemonic.VPERMT2D); + map.put("Vpermt2pd", Mnemonic.VPERMT2PD); + map.put("Vpermt2ps", Mnemonic.VPERMT2PS); + map.put("Vpermt2q", Mnemonic.VPERMT2Q); + map.put("Vpermt2w", Mnemonic.VPERMT2W); + map.put("Vpermw", Mnemonic.VPERMW); + map.put("Vpexpandb", Mnemonic.VPEXPANDB); + map.put("Vpexpandd", Mnemonic.VPEXPANDD); + map.put("Vpexpandq", Mnemonic.VPEXPANDQ); + map.put("Vpexpandw", Mnemonic.VPEXPANDW); + map.put("Vpextrb", Mnemonic.VPEXTRB); + map.put("Vpextrd", Mnemonic.VPEXTRD); + map.put("Vpextrq", Mnemonic.VPEXTRQ); + map.put("Vpextrw", Mnemonic.VPEXTRW); + map.put("Vpgatherdd", Mnemonic.VPGATHERDD); + map.put("Vpgatherdq", Mnemonic.VPGATHERDQ); + map.put("Vpgatherqd", Mnemonic.VPGATHERQD); + map.put("Vpgatherqq", Mnemonic.VPGATHERQQ); + map.put("Vphaddbd", Mnemonic.VPHADDBD); + map.put("Vphaddbq", Mnemonic.VPHADDBQ); + map.put("Vphaddbw", Mnemonic.VPHADDBW); + map.put("Vphaddd", Mnemonic.VPHADDD); + map.put("Vphadddq", Mnemonic.VPHADDDQ); + map.put("Vphaddsw", Mnemonic.VPHADDSW); + map.put("Vphaddubd", Mnemonic.VPHADDUBD); + map.put("Vphaddubq", Mnemonic.VPHADDUBQ); + map.put("Vphaddubw", Mnemonic.VPHADDUBW); + map.put("Vphaddudq", Mnemonic.VPHADDUDQ); + map.put("Vphadduwd", Mnemonic.VPHADDUWD); + map.put("Vphadduwq", Mnemonic.VPHADDUWQ); + map.put("Vphaddw", Mnemonic.VPHADDW); + map.put("Vphaddwd", Mnemonic.VPHADDWD); + map.put("Vphaddwq", Mnemonic.VPHADDWQ); + map.put("Vphminposuw", Mnemonic.VPHMINPOSUW); + map.put("Vphsubbw", Mnemonic.VPHSUBBW); + map.put("Vphsubd", Mnemonic.VPHSUBD); + map.put("Vphsubdq", Mnemonic.VPHSUBDQ); + map.put("Vphsubsw", Mnemonic.VPHSUBSW); + map.put("Vphsubw", Mnemonic.VPHSUBW); + map.put("Vphsubwd", Mnemonic.VPHSUBWD); + map.put("Vpinsrb", Mnemonic.VPINSRB); + map.put("Vpinsrd", Mnemonic.VPINSRD); + map.put("Vpinsrq", Mnemonic.VPINSRQ); + map.put("Vpinsrw", Mnemonic.VPINSRW); + map.put("Vplzcntd", Mnemonic.VPLZCNTD); + map.put("Vplzcntq", Mnemonic.VPLZCNTQ); + map.put("Vpmacsdd", Mnemonic.VPMACSDD); + map.put("Vpmacsdqh", Mnemonic.VPMACSDQH); + map.put("Vpmacsdql", Mnemonic.VPMACSDQL); + map.put("Vpmacssdd", Mnemonic.VPMACSSDD); + map.put("Vpmacssdqh", Mnemonic.VPMACSSDQH); + map.put("Vpmacssdql", Mnemonic.VPMACSSDQL); + map.put("Vpmacsswd", Mnemonic.VPMACSSWD); + map.put("Vpmacssww", Mnemonic.VPMACSSWW); + map.put("Vpmacswd", Mnemonic.VPMACSWD); + map.put("Vpmacsww", Mnemonic.VPMACSWW); + map.put("Vpmadcsswd", Mnemonic.VPMADCSSWD); + map.put("Vpmadcswd", Mnemonic.VPMADCSWD); + map.put("Vpmadd52huq", Mnemonic.VPMADD52HUQ); + map.put("Vpmadd52luq", Mnemonic.VPMADD52LUQ); + map.put("Vpmaddubsw", Mnemonic.VPMADDUBSW); + map.put("Vpmaddwd", Mnemonic.VPMADDWD); + map.put("Vpmaskmovd", Mnemonic.VPMASKMOVD); + map.put("Vpmaskmovq", Mnemonic.VPMASKMOVQ); + map.put("Vpmaxsb", Mnemonic.VPMAXSB); + map.put("Vpmaxsd", Mnemonic.VPMAXSD); + map.put("Vpmaxsq", Mnemonic.VPMAXSQ); + map.put("Vpmaxsw", Mnemonic.VPMAXSW); + map.put("Vpmaxub", Mnemonic.VPMAXUB); + map.put("Vpmaxud", Mnemonic.VPMAXUD); + map.put("Vpmaxuq", Mnemonic.VPMAXUQ); + map.put("Vpmaxuw", Mnemonic.VPMAXUW); + map.put("Vpminsb", Mnemonic.VPMINSB); + map.put("Vpminsd", Mnemonic.VPMINSD); + map.put("Vpminsq", Mnemonic.VPMINSQ); + map.put("Vpminsw", Mnemonic.VPMINSW); + map.put("Vpminub", Mnemonic.VPMINUB); + map.put("Vpminud", Mnemonic.VPMINUD); + map.put("Vpminuq", Mnemonic.VPMINUQ); + map.put("Vpminuw", Mnemonic.VPMINUW); + map.put("Vpmovb2m", Mnemonic.VPMOVB2M); + map.put("Vpmovd2m", Mnemonic.VPMOVD2M); + map.put("Vpmovdb", Mnemonic.VPMOVDB); + map.put("Vpmovdw", Mnemonic.VPMOVDW); + map.put("Vpmovm2b", Mnemonic.VPMOVM2B); + map.put("Vpmovm2d", Mnemonic.VPMOVM2D); + map.put("Vpmovm2q", Mnemonic.VPMOVM2Q); + map.put("Vpmovm2w", Mnemonic.VPMOVM2W); + map.put("Vpmovmskb", Mnemonic.VPMOVMSKB); + map.put("Vpmovq2m", Mnemonic.VPMOVQ2M); + map.put("Vpmovqb", Mnemonic.VPMOVQB); + map.put("Vpmovqd", Mnemonic.VPMOVQD); + map.put("Vpmovqw", Mnemonic.VPMOVQW); + map.put("Vpmovsdb", Mnemonic.VPMOVSDB); + map.put("Vpmovsdw", Mnemonic.VPMOVSDW); + map.put("Vpmovsqb", Mnemonic.VPMOVSQB); + map.put("Vpmovsqd", Mnemonic.VPMOVSQD); + map.put("Vpmovsqw", Mnemonic.VPMOVSQW); + map.put("Vpmovswb", Mnemonic.VPMOVSWB); + map.put("Vpmovsxbd", Mnemonic.VPMOVSXBD); + map.put("Vpmovsxbq", Mnemonic.VPMOVSXBQ); + map.put("Vpmovsxbw", Mnemonic.VPMOVSXBW); + map.put("Vpmovsxdq", Mnemonic.VPMOVSXDQ); + map.put("Vpmovsxwd", Mnemonic.VPMOVSXWD); + map.put("Vpmovsxwq", Mnemonic.VPMOVSXWQ); + map.put("Vpmovusdb", Mnemonic.VPMOVUSDB); + map.put("Vpmovusdw", Mnemonic.VPMOVUSDW); + map.put("Vpmovusqb", Mnemonic.VPMOVUSQB); + map.put("Vpmovusqd", Mnemonic.VPMOVUSQD); + map.put("Vpmovusqw", Mnemonic.VPMOVUSQW); + map.put("Vpmovuswb", Mnemonic.VPMOVUSWB); + map.put("Vpmovw2m", Mnemonic.VPMOVW2M); + map.put("Vpmovwb", Mnemonic.VPMOVWB); + map.put("Vpmovzxbd", Mnemonic.VPMOVZXBD); + map.put("Vpmovzxbq", Mnemonic.VPMOVZXBQ); + map.put("Vpmovzxbw", Mnemonic.VPMOVZXBW); + map.put("Vpmovzxdq", Mnemonic.VPMOVZXDQ); + map.put("Vpmovzxwd", Mnemonic.VPMOVZXWD); + map.put("Vpmovzxwq", Mnemonic.VPMOVZXWQ); + map.put("Vpmuldq", Mnemonic.VPMULDQ); + map.put("Vpmulhrsw", Mnemonic.VPMULHRSW); + map.put("Vpmulhuw", Mnemonic.VPMULHUW); + map.put("Vpmulhw", Mnemonic.VPMULHW); + map.put("Vpmulld", Mnemonic.VPMULLD); + map.put("Vpmullq", Mnemonic.VPMULLQ); + map.put("Vpmullw", Mnemonic.VPMULLW); + map.put("Vpmultishiftqb", Mnemonic.VPMULTISHIFTQB); + map.put("Vpmuludq", Mnemonic.VPMULUDQ); + map.put("Vpopcntb", Mnemonic.VPOPCNTB); + map.put("Vpopcntd", Mnemonic.VPOPCNTD); + map.put("Vpopcntq", Mnemonic.VPOPCNTQ); + map.put("Vpopcntw", Mnemonic.VPOPCNTW); + map.put("Vpor", Mnemonic.VPOR); + map.put("Vpord", Mnemonic.VPORD); + map.put("Vporq", Mnemonic.VPORQ); + map.put("Vpperm", Mnemonic.VPPERM); + map.put("Vprold", Mnemonic.VPROLD); + map.put("Vprolq", Mnemonic.VPROLQ); + map.put("Vprolvd", Mnemonic.VPROLVD); + map.put("Vprolvq", Mnemonic.VPROLVQ); + map.put("Vprord", Mnemonic.VPRORD); + map.put("Vprorq", Mnemonic.VPRORQ); + map.put("Vprorvd", Mnemonic.VPRORVD); + map.put("Vprorvq", Mnemonic.VPRORVQ); + map.put("Vprotb", Mnemonic.VPROTB); + map.put("Vprotd", Mnemonic.VPROTD); + map.put("Vprotq", Mnemonic.VPROTQ); + map.put("Vprotw", Mnemonic.VPROTW); + map.put("Vpsadbw", Mnemonic.VPSADBW); + map.put("Vpscatterdd", Mnemonic.VPSCATTERDD); + map.put("Vpscatterdq", Mnemonic.VPSCATTERDQ); + map.put("Vpscatterqd", Mnemonic.VPSCATTERQD); + map.put("Vpscatterqq", Mnemonic.VPSCATTERQQ); + map.put("Vpshab", Mnemonic.VPSHAB); + map.put("Vpshad", Mnemonic.VPSHAD); + map.put("Vpshaq", Mnemonic.VPSHAQ); + map.put("Vpshaw", Mnemonic.VPSHAW); + map.put("Vpshlb", Mnemonic.VPSHLB); + map.put("Vpshld", Mnemonic.VPSHLD); + map.put("Vpshldd", Mnemonic.VPSHLDD); + map.put("Vpshldq", Mnemonic.VPSHLDQ); + map.put("Vpshldvd", Mnemonic.VPSHLDVD); + map.put("Vpshldvq", Mnemonic.VPSHLDVQ); + map.put("Vpshldvw", Mnemonic.VPSHLDVW); + map.put("Vpshldw", Mnemonic.VPSHLDW); + map.put("Vpshlq", Mnemonic.VPSHLQ); + map.put("Vpshlw", Mnemonic.VPSHLW); + map.put("Vpshrdd", Mnemonic.VPSHRDD); + map.put("Vpshrdq", Mnemonic.VPSHRDQ); + map.put("Vpshrdvd", Mnemonic.VPSHRDVD); + map.put("Vpshrdvq", Mnemonic.VPSHRDVQ); + map.put("Vpshrdvw", Mnemonic.VPSHRDVW); + map.put("Vpshrdw", Mnemonic.VPSHRDW); + map.put("Vpshufb", Mnemonic.VPSHUFB); + map.put("Vpshufbitqmb", Mnemonic.VPSHUFBITQMB); + map.put("Vpshufd", Mnemonic.VPSHUFD); + map.put("Vpshufhw", Mnemonic.VPSHUFHW); + map.put("Vpshuflw", Mnemonic.VPSHUFLW); + map.put("Vpsignb", Mnemonic.VPSIGNB); + map.put("Vpsignd", Mnemonic.VPSIGND); + map.put("Vpsignw", Mnemonic.VPSIGNW); + map.put("Vpslld", Mnemonic.VPSLLD); + map.put("Vpslldq", Mnemonic.VPSLLDQ); + map.put("Vpsllq", Mnemonic.VPSLLQ); + map.put("Vpsllvd", Mnemonic.VPSLLVD); + map.put("Vpsllvq", Mnemonic.VPSLLVQ); + map.put("Vpsllvw", Mnemonic.VPSLLVW); + map.put("Vpsllw", Mnemonic.VPSLLW); + map.put("Vpsrad", Mnemonic.VPSRAD); + map.put("Vpsraq", Mnemonic.VPSRAQ); + map.put("Vpsravd", Mnemonic.VPSRAVD); + map.put("Vpsravq", Mnemonic.VPSRAVQ); + map.put("Vpsravw", Mnemonic.VPSRAVW); + map.put("Vpsraw", Mnemonic.VPSRAW); + map.put("Vpsrld", Mnemonic.VPSRLD); + map.put("Vpsrldq", Mnemonic.VPSRLDQ); + map.put("Vpsrlq", Mnemonic.VPSRLQ); + map.put("Vpsrlvd", Mnemonic.VPSRLVD); + map.put("Vpsrlvq", Mnemonic.VPSRLVQ); + map.put("Vpsrlvw", Mnemonic.VPSRLVW); + map.put("Vpsrlw", Mnemonic.VPSRLW); + map.put("Vpsubb", Mnemonic.VPSUBB); + map.put("Vpsubd", Mnemonic.VPSUBD); + map.put("Vpsubq", Mnemonic.VPSUBQ); + map.put("Vpsubsb", Mnemonic.VPSUBSB); + map.put("Vpsubsw", Mnemonic.VPSUBSW); + map.put("Vpsubusb", Mnemonic.VPSUBUSB); + map.put("Vpsubusw", Mnemonic.VPSUBUSW); + map.put("Vpsubw", Mnemonic.VPSUBW); + map.put("Vpternlogd", Mnemonic.VPTERNLOGD); + map.put("Vpternlogq", Mnemonic.VPTERNLOGQ); + map.put("Vptest", Mnemonic.VPTEST); + map.put("Vptestmb", Mnemonic.VPTESTMB); + map.put("Vptestmd", Mnemonic.VPTESTMD); + map.put("Vptestmq", Mnemonic.VPTESTMQ); + map.put("Vptestmw", Mnemonic.VPTESTMW); + map.put("Vptestnmb", Mnemonic.VPTESTNMB); + map.put("Vptestnmd", Mnemonic.VPTESTNMD); + map.put("Vptestnmq", Mnemonic.VPTESTNMQ); + map.put("Vptestnmw", Mnemonic.VPTESTNMW); + map.put("Vpunpckhbw", Mnemonic.VPUNPCKHBW); + map.put("Vpunpckhdq", Mnemonic.VPUNPCKHDQ); + map.put("Vpunpckhqdq", Mnemonic.VPUNPCKHQDQ); + map.put("Vpunpckhwd", Mnemonic.VPUNPCKHWD); + map.put("Vpunpcklbw", Mnemonic.VPUNPCKLBW); + map.put("Vpunpckldq", Mnemonic.VPUNPCKLDQ); + map.put("Vpunpcklqdq", Mnemonic.VPUNPCKLQDQ); + map.put("Vpunpcklwd", Mnemonic.VPUNPCKLWD); + map.put("Vpxor", Mnemonic.VPXOR); + map.put("Vpxord", Mnemonic.VPXORD); + map.put("Vpxorq", Mnemonic.VPXORQ); + map.put("Vrangepd", Mnemonic.VRANGEPD); + map.put("Vrangeps", Mnemonic.VRANGEPS); + map.put("Vrangesd", Mnemonic.VRANGESD); + map.put("Vrangess", Mnemonic.VRANGESS); + map.put("Vrcp14pd", Mnemonic.VRCP14PD); + map.put("Vrcp14ps", Mnemonic.VRCP14PS); + map.put("Vrcp14sd", Mnemonic.VRCP14SD); + map.put("Vrcp14ss", Mnemonic.VRCP14SS); + map.put("Vrcp28pd", Mnemonic.VRCP28PD); + map.put("Vrcp28ps", Mnemonic.VRCP28PS); + map.put("Vrcp28sd", Mnemonic.VRCP28SD); + map.put("Vrcp28ss", Mnemonic.VRCP28SS); + map.put("Vrcpps", Mnemonic.VRCPPS); + map.put("Vrcpss", Mnemonic.VRCPSS); + map.put("Vreducepd", Mnemonic.VREDUCEPD); + map.put("Vreduceps", Mnemonic.VREDUCEPS); + map.put("Vreducesd", Mnemonic.VREDUCESD); + map.put("Vreducess", Mnemonic.VREDUCESS); + map.put("Vrndscalepd", Mnemonic.VRNDSCALEPD); + map.put("Vrndscaleps", Mnemonic.VRNDSCALEPS); + map.put("Vrndscalesd", Mnemonic.VRNDSCALESD); + map.put("Vrndscaless", Mnemonic.VRNDSCALESS); + map.put("Vroundpd", Mnemonic.VROUNDPD); + map.put("Vroundps", Mnemonic.VROUNDPS); + map.put("Vroundsd", Mnemonic.VROUNDSD); + map.put("Vroundss", Mnemonic.VROUNDSS); + map.put("Vrsqrt14pd", Mnemonic.VRSQRT14PD); + map.put("Vrsqrt14ps", Mnemonic.VRSQRT14PS); + map.put("Vrsqrt14sd", Mnemonic.VRSQRT14SD); + map.put("Vrsqrt14ss", Mnemonic.VRSQRT14SS); + map.put("Vrsqrt28pd", Mnemonic.VRSQRT28PD); + map.put("Vrsqrt28ps", Mnemonic.VRSQRT28PS); + map.put("Vrsqrt28sd", Mnemonic.VRSQRT28SD); + map.put("Vrsqrt28ss", Mnemonic.VRSQRT28SS); + map.put("Vrsqrtps", Mnemonic.VRSQRTPS); + map.put("Vrsqrtss", Mnemonic.VRSQRTSS); + map.put("Vscalefpd", Mnemonic.VSCALEFPD); + map.put("Vscalefps", Mnemonic.VSCALEFPS); + map.put("Vscalefsd", Mnemonic.VSCALEFSD); + map.put("Vscalefss", Mnemonic.VSCALEFSS); + map.put("Vscatterdpd", Mnemonic.VSCATTERDPD); + map.put("Vscatterdps", Mnemonic.VSCATTERDPS); + map.put("Vscatterpf0dpd", Mnemonic.VSCATTERPF0DPD); + map.put("Vscatterpf0dps", Mnemonic.VSCATTERPF0DPS); + map.put("Vscatterpf0qpd", Mnemonic.VSCATTERPF0QPD); + map.put("Vscatterpf0qps", Mnemonic.VSCATTERPF0QPS); + map.put("Vscatterpf1dpd", Mnemonic.VSCATTERPF1DPD); + map.put("Vscatterpf1dps", Mnemonic.VSCATTERPF1DPS); + map.put("Vscatterpf1qpd", Mnemonic.VSCATTERPF1QPD); + map.put("Vscatterpf1qps", Mnemonic.VSCATTERPF1QPS); + map.put("Vscatterqpd", Mnemonic.VSCATTERQPD); + map.put("Vscatterqps", Mnemonic.VSCATTERQPS); + map.put("Vshuff32x4", Mnemonic.VSHUFF32X4); + map.put("Vshuff64x2", Mnemonic.VSHUFF64X2); + map.put("Vshufi32x4", Mnemonic.VSHUFI32X4); + map.put("Vshufi64x2", Mnemonic.VSHUFI64X2); + map.put("Vshufpd", Mnemonic.VSHUFPD); + map.put("Vshufps", Mnemonic.VSHUFPS); + map.put("Vsqrtpd", Mnemonic.VSQRTPD); + map.put("Vsqrtps", Mnemonic.VSQRTPS); + map.put("Vsqrtsd", Mnemonic.VSQRTSD); + map.put("Vsqrtss", Mnemonic.VSQRTSS); + map.put("Vstmxcsr", Mnemonic.VSTMXCSR); + map.put("Vsubpd", Mnemonic.VSUBPD); + map.put("Vsubps", Mnemonic.VSUBPS); + map.put("Vsubsd", Mnemonic.VSUBSD); + map.put("Vsubss", Mnemonic.VSUBSS); + map.put("Vtestpd", Mnemonic.VTESTPD); + map.put("Vtestps", Mnemonic.VTESTPS); + map.put("Vucomisd", Mnemonic.VUCOMISD); + map.put("Vucomiss", Mnemonic.VUCOMISS); + map.put("Vunpckhpd", Mnemonic.VUNPCKHPD); + map.put("Vunpckhps", Mnemonic.VUNPCKHPS); + map.put("Vunpcklpd", Mnemonic.VUNPCKLPD); + map.put("Vunpcklps", Mnemonic.VUNPCKLPS); + map.put("Vxorpd", Mnemonic.VXORPD); + map.put("Vxorps", Mnemonic.VXORPS); + map.put("Vzeroall", Mnemonic.VZEROALL); + map.put("Vzeroupper", Mnemonic.VZEROUPPER); + map.put("Wait", Mnemonic.WAIT); + map.put("Wbinvd", Mnemonic.WBINVD); + map.put("Wbnoinvd", Mnemonic.WBNOINVD); + map.put("Wrfsbase", Mnemonic.WRFSBASE); + map.put("Wrgsbase", Mnemonic.WRGSBASE); + map.put("Wrmsr", Mnemonic.WRMSR); + } + + private static void initMap3(HashMap map) { + map.put("Wrpkru", Mnemonic.WRPKRU); + map.put("Wrssd", Mnemonic.WRSSD); + map.put("Wrssq", Mnemonic.WRSSQ); + map.put("Wrussd", Mnemonic.WRUSSD); + map.put("Wrussq", Mnemonic.WRUSSQ); + map.put("Xabort", Mnemonic.XABORT); + map.put("Xadd", Mnemonic.XADD); + map.put("Xbegin", Mnemonic.XBEGIN); + map.put("Xbts", Mnemonic.XBTS); + map.put("Xchg", Mnemonic.XCHG); + map.put("Xcryptcbc", Mnemonic.XCRYPTCBC); + map.put("Xcryptcfb", Mnemonic.XCRYPTCFB); + map.put("Xcryptctr", Mnemonic.XCRYPTCTR); + map.put("Xcryptecb", Mnemonic.XCRYPTECB); + map.put("Xcryptofb", Mnemonic.XCRYPTOFB); + map.put("Xend", Mnemonic.XEND); + map.put("Xgetbv", Mnemonic.XGETBV); + map.put("Xlatb", Mnemonic.XLATB); + map.put("Xor", Mnemonic.XOR); + map.put("Xorpd", Mnemonic.XORPD); + map.put("Xorps", Mnemonic.XORPS); + map.put("Xrstor", Mnemonic.XRSTOR); + map.put("Xrstor64", Mnemonic.XRSTOR64); + map.put("Xrstors", Mnemonic.XRSTORS); + map.put("Xrstors64", Mnemonic.XRSTORS64); + map.put("Xsave", Mnemonic.XSAVE); + map.put("Xsave64", Mnemonic.XSAVE64); + map.put("Xsavec", Mnemonic.XSAVEC); + map.put("Xsavec64", Mnemonic.XSAVEC64); + map.put("Xsaveopt", Mnemonic.XSAVEOPT); + map.put("Xsaveopt64", Mnemonic.XSAVEOPT64); + map.put("Xsaves", Mnemonic.XSAVES); + map.put("Xsaves64", Mnemonic.XSAVES64); + map.put("Xsetbv", Mnemonic.XSETBV); + map.put("Xsha1", Mnemonic.XSHA1); + map.put("Xsha256", Mnemonic.XSHA256); + map.put("Xstore", Mnemonic.XSTORE); + map.put("Xtest", Mnemonic.XTEST); + map.put("Rmpadjust", Mnemonic.RMPADJUST); + map.put("Rmpupdate", Mnemonic.RMPUPDATE); + map.put("Psmash", Mnemonic.PSMASH); + map.put("Pvalidate", Mnemonic.PVALIDATE); + map.put("Serialize", Mnemonic.SERIALIZE); + map.put("Xsusldtrk", Mnemonic.XSUSLDTRK); + map.put("Xresldtrk", Mnemonic.XRESLDTRK); + map.put("Invlpgb", Mnemonic.INVLPGB); + map.put("Tlbsync", Mnemonic.TLBSYNC); + map.put("Vmgexit", Mnemonic.VMGEXIT); + map.put("Getsecq", Mnemonic.GETSECQ); + map.put("Sysexitq", Mnemonic.SYSEXITQ); + map.put("Ldtilecfg", Mnemonic.LDTILECFG); + map.put("Tilerelease", Mnemonic.TILERELEASE); + map.put("Sttilecfg", Mnemonic.STTILECFG); + map.put("Tilezero", Mnemonic.TILEZERO); + map.put("Tileloaddt1", Mnemonic.TILELOADDT1); + map.put("Tilestored", Mnemonic.TILESTORED); + map.put("Tileloadd", Mnemonic.TILELOADD); + map.put("Tdpbf16ps", Mnemonic.TDPBF16PS); + map.put("Tdpbuud", Mnemonic.TDPBUUD); + map.put("Tdpbusd", Mnemonic.TDPBUSD); + map.put("Tdpbsud", Mnemonic.TDPBSUD); + map.put("Tdpbssd", Mnemonic.TDPBSSD); + map.put("Sysretq", Mnemonic.SYSRETQ); + map.put("Fnstdw", Mnemonic.FNSTDW); + map.put("Fnstsg", Mnemonic.FNSTSG); + map.put("Rdshr", Mnemonic.RDSHR); + map.put("Wrshr", Mnemonic.WRSHR); + map.put("Smint", Mnemonic.SMINT); + map.put("Dmint", Mnemonic.DMINT); + map.put("Rdm", Mnemonic.RDM); + map.put("Svdc", Mnemonic.SVDC); + map.put("Rsdc", Mnemonic.RSDC); + map.put("Svldt", Mnemonic.SVLDT); + map.put("Rsldt", Mnemonic.RSLDT); + map.put("Svts", Mnemonic.SVTS); + map.put("Rsts", Mnemonic.RSTS); + map.put("Bb0_reset", Mnemonic.BB0_RESET); + map.put("Bb1_reset", Mnemonic.BB1_RESET); + map.put("Cpu_write", Mnemonic.CPU_WRITE); + map.put("Cpu_read", Mnemonic.CPU_READ); + map.put("Altinst", Mnemonic.ALTINST); + map.put("Paveb", Mnemonic.PAVEB); + map.put("Paddsiw", Mnemonic.PADDSIW); + map.put("Pmagw", Mnemonic.PMAGW); + map.put("Pdistib", Mnemonic.PDISTIB); + map.put("Psubsiw", Mnemonic.PSUBSIW); + map.put("Pmvzb", Mnemonic.PMVZB); + map.put("Pmvnzb", Mnemonic.PMVNZB); + map.put("Pmvlzb", Mnemonic.PMVLZB); + map.put("Pmvgezb", Mnemonic.PMVGEZB); + map.put("Pmulhriw", Mnemonic.PMULHRIW); + map.put("Pmachriw", Mnemonic.PMACHRIW); + map.put("Ftstp", Mnemonic.FTSTP); + map.put("Frint2", Mnemonic.FRINT2); + map.put("Frichop", Mnemonic.FRICHOP); + map.put("Frinear", Mnemonic.FRINEAR); + map.put("Undoc", Mnemonic.UNDOC); + map.put("Tdcall", Mnemonic.TDCALL); + map.put("Seamret", Mnemonic.SEAMRET); + map.put("Seamops", Mnemonic.SEAMOPS); + map.put("Seamcall", Mnemonic.SEAMCALL); + map.put("Aesencwide128kl", Mnemonic.AESENCWIDE128KL); + map.put("Aesdecwide128kl", Mnemonic.AESDECWIDE128KL); + map.put("Aesencwide256kl", Mnemonic.AESENCWIDE256KL); + map.put("Aesdecwide256kl", Mnemonic.AESDECWIDE256KL); + map.put("Loadiwkey", Mnemonic.LOADIWKEY); + map.put("Aesenc128kl", Mnemonic.AESENC128KL); + map.put("Aesdec128kl", Mnemonic.AESDEC128KL); + map.put("Aesenc256kl", Mnemonic.AESENC256KL); + map.put("Aesdec256kl", Mnemonic.AESDEC256KL); + map.put("Encodekey128", Mnemonic.ENCODEKEY128); + map.put("Encodekey256", Mnemonic.ENCODEKEY256); + map.put("Pushad", Mnemonic.PUSHAD); + map.put("Popad", Mnemonic.POPAD); + map.put("Pushfd", Mnemonic.PUSHFD); + map.put("Pushfq", Mnemonic.PUSHFQ); + map.put("Popfd", Mnemonic.POPFD); + map.put("Popfq", Mnemonic.POPFQ); + map.put("Iretd", Mnemonic.IRETD); + map.put("Iretq", Mnemonic.IRETQ); + map.put("Int3", Mnemonic.INT3); + map.put("Uiret", Mnemonic.UIRET); + map.put("Testui", Mnemonic.TESTUI); + map.put("Clui", Mnemonic.CLUI); + map.put("Stui", Mnemonic.STUI); + map.put("Senduipi", Mnemonic.SENDUIPI); + map.put("Hreset", Mnemonic.HRESET); + map.put("Ccs_hash", Mnemonic.CCS_HASH); + map.put("Ccs_encrypt", Mnemonic.CCS_ENCRYPT); + map.put("Lkgs", Mnemonic.LKGS); + map.put("Eretu", Mnemonic.ERETU); + map.put("Erets", Mnemonic.ERETS); + map.put("Storeall", Mnemonic.STOREALL); + map.put("Vaddph", Mnemonic.VADDPH); + map.put("Vaddsh", Mnemonic.VADDSH); + map.put("Vcmpph", Mnemonic.VCMPPH); + map.put("Vcmpsh", Mnemonic.VCMPSH); + map.put("Vcomish", Mnemonic.VCOMISH); + map.put("Vcvtdq2ph", Mnemonic.VCVTDQ2PH); + map.put("Vcvtpd2ph", Mnemonic.VCVTPD2PH); + map.put("Vcvtph2dq", Mnemonic.VCVTPH2DQ); + map.put("Vcvtph2pd", Mnemonic.VCVTPH2PD); + map.put("Vcvtph2psx", Mnemonic.VCVTPH2PSX); + map.put("Vcvtph2qq", Mnemonic.VCVTPH2QQ); + map.put("Vcvtph2udq", Mnemonic.VCVTPH2UDQ); + map.put("Vcvtph2uqq", Mnemonic.VCVTPH2UQQ); + map.put("Vcvtph2uw", Mnemonic.VCVTPH2UW); + map.put("Vcvtph2w", Mnemonic.VCVTPH2W); + map.put("Vcvtps2phx", Mnemonic.VCVTPS2PHX); + map.put("Vcvtqq2ph", Mnemonic.VCVTQQ2PH); + map.put("Vcvtsd2sh", Mnemonic.VCVTSD2SH); + map.put("Vcvtsh2sd", Mnemonic.VCVTSH2SD); + map.put("Vcvtsh2si", Mnemonic.VCVTSH2SI); + map.put("Vcvtsh2ss", Mnemonic.VCVTSH2SS); + map.put("Vcvtsh2usi", Mnemonic.VCVTSH2USI); + map.put("Vcvtsi2sh", Mnemonic.VCVTSI2SH); + map.put("Vcvtss2sh", Mnemonic.VCVTSS2SH); + map.put("Vcvttph2dq", Mnemonic.VCVTTPH2DQ); + map.put("Vcvttph2qq", Mnemonic.VCVTTPH2QQ); + map.put("Vcvttph2udq", Mnemonic.VCVTTPH2UDQ); + map.put("Vcvttph2uqq", Mnemonic.VCVTTPH2UQQ); + map.put("Vcvttph2uw", Mnemonic.VCVTTPH2UW); + map.put("Vcvttph2w", Mnemonic.VCVTTPH2W); + map.put("Vcvttsh2si", Mnemonic.VCVTTSH2SI); + map.put("Vcvttsh2usi", Mnemonic.VCVTTSH2USI); + map.put("Vcvtudq2ph", Mnemonic.VCVTUDQ2PH); + map.put("Vcvtuqq2ph", Mnemonic.VCVTUQQ2PH); + map.put("Vcvtusi2sh", Mnemonic.VCVTUSI2SH); + map.put("Vcvtuw2ph", Mnemonic.VCVTUW2PH); + map.put("Vcvtw2ph", Mnemonic.VCVTW2PH); + map.put("Vdivph", Mnemonic.VDIVPH); + map.put("Vdivsh", Mnemonic.VDIVSH); + map.put("Vfcmaddcph", Mnemonic.VFCMADDCPH); + map.put("Vfmaddcph", Mnemonic.VFMADDCPH); + map.put("Vfcmaddcsh", Mnemonic.VFCMADDCSH); + map.put("Vfmaddcsh", Mnemonic.VFMADDCSH); + map.put("Vfcmulcph", Mnemonic.VFCMULCPH); + map.put("Vfmulcph", Mnemonic.VFMULCPH); + map.put("Vfcmulcsh", Mnemonic.VFCMULCSH); + map.put("Vfmulcsh", Mnemonic.VFMULCSH); + map.put("Vfmaddsub132ph", Mnemonic.VFMADDSUB132PH); + map.put("Vfmaddsub213ph", Mnemonic.VFMADDSUB213PH); + map.put("Vfmaddsub231ph", Mnemonic.VFMADDSUB231PH); + map.put("Vfmsubadd132ph", Mnemonic.VFMSUBADD132PH); + map.put("Vfmsubadd213ph", Mnemonic.VFMSUBADD213PH); + map.put("Vfmsubadd231ph", Mnemonic.VFMSUBADD231PH); + map.put("Vfmadd132ph", Mnemonic.VFMADD132PH); + map.put("Vfmadd213ph", Mnemonic.VFMADD213PH); + map.put("Vfmadd231ph", Mnemonic.VFMADD231PH); + map.put("Vfnmadd132ph", Mnemonic.VFNMADD132PH); + map.put("Vfnmadd213ph", Mnemonic.VFNMADD213PH); + map.put("Vfnmadd231ph", Mnemonic.VFNMADD231PH); + map.put("Vfmadd132sh", Mnemonic.VFMADD132SH); + map.put("Vfmadd213sh", Mnemonic.VFMADD213SH); + map.put("Vfmadd231sh", Mnemonic.VFMADD231SH); + map.put("Vfnmadd132sh", Mnemonic.VFNMADD132SH); + map.put("Vfnmadd213sh", Mnemonic.VFNMADD213SH); + map.put("Vfnmadd231sh", Mnemonic.VFNMADD231SH); + map.put("Vfmsub132ph", Mnemonic.VFMSUB132PH); + map.put("Vfmsub213ph", Mnemonic.VFMSUB213PH); + map.put("Vfmsub231ph", Mnemonic.VFMSUB231PH); + map.put("Vfnmsub132ph", Mnemonic.VFNMSUB132PH); + map.put("Vfnmsub213ph", Mnemonic.VFNMSUB213PH); + map.put("Vfnmsub231ph", Mnemonic.VFNMSUB231PH); + map.put("Vfmsub132sh", Mnemonic.VFMSUB132SH); + map.put("Vfmsub213sh", Mnemonic.VFMSUB213SH); + map.put("Vfmsub231sh", Mnemonic.VFMSUB231SH); + map.put("Vfnmsub132sh", Mnemonic.VFNMSUB132SH); + map.put("Vfnmsub213sh", Mnemonic.VFNMSUB213SH); + map.put("Vfnmsub231sh", Mnemonic.VFNMSUB231SH); + map.put("Vfpclassph", Mnemonic.VFPCLASSPH); + map.put("Vfpclasssh", Mnemonic.VFPCLASSSH); + map.put("Vgetexpph", Mnemonic.VGETEXPPH); + map.put("Vgetexpsh", Mnemonic.VGETEXPSH); + map.put("Vgetmantph", Mnemonic.VGETMANTPH); + map.put("Vgetmantsh", Mnemonic.VGETMANTSH); + map.put("Vmaxph", Mnemonic.VMAXPH); + map.put("Vmaxsh", Mnemonic.VMAXSH); + map.put("Vminph", Mnemonic.VMINPH); + map.put("Vminsh", Mnemonic.VMINSH); + map.put("Vmovsh", Mnemonic.VMOVSH); + map.put("Vmovw", Mnemonic.VMOVW); + map.put("Vmulph", Mnemonic.VMULPH); + map.put("Vmulsh", Mnemonic.VMULSH); + map.put("Vrcpph", Mnemonic.VRCPPH); + map.put("Vrcpsh", Mnemonic.VRCPSH); + map.put("Vreduceph", Mnemonic.VREDUCEPH); + map.put("Vreducesh", Mnemonic.VREDUCESH); + map.put("Vrndscaleph", Mnemonic.VRNDSCALEPH); + map.put("Vrndscalesh", Mnemonic.VRNDSCALESH); + map.put("Vrsqrtph", Mnemonic.VRSQRTPH); + map.put("Vrsqrtsh", Mnemonic.VRSQRTSH); + map.put("Vscalefph", Mnemonic.VSCALEFPH); + map.put("Vscalefsh", Mnemonic.VSCALEFSH); + map.put("Vsqrtph", Mnemonic.VSQRTPH); + map.put("Vsqrtsh", Mnemonic.VSQRTSH); + map.put("Vsubph", Mnemonic.VSUBPH); + map.put("Vsubsh", Mnemonic.VSUBSH); + map.put("Vucomish", Mnemonic.VUCOMISH); + map.put("Rdudbg", Mnemonic.RDUDBG); + map.put("Wrudbg", Mnemonic.WRUDBG); + map.put("Clevict0", Mnemonic.CLEVICT0); + map.put("Clevict1", Mnemonic.CLEVICT1); + map.put("Delay", Mnemonic.DELAY); + map.put("Jknzd", Mnemonic.JKNZD); + map.put("Jkzd", Mnemonic.JKZD); + map.put("Kand", Mnemonic.KAND); + map.put("Kandn", Mnemonic.KANDN); + map.put("Kandnr", Mnemonic.KANDNR); + map.put("Kconcath", Mnemonic.KCONCATH); + map.put("Kconcatl", Mnemonic.KCONCATL); + map.put("Kextract", Mnemonic.KEXTRACT); + map.put("Kmerge2l1h", Mnemonic.KMERGE2L1H); + map.put("Kmerge2l1l", Mnemonic.KMERGE2L1L); + map.put("Kmov", Mnemonic.KMOV); + map.put("Knot", Mnemonic.KNOT); + map.put("Kor", Mnemonic.KOR); + map.put("Kortest", Mnemonic.KORTEST); + map.put("Kxnor", Mnemonic.KXNOR); + map.put("Kxor", Mnemonic.KXOR); + map.put("Spflt", Mnemonic.SPFLT); + map.put("Tzcnti", Mnemonic.TZCNTI); + map.put("Vaddnpd", Mnemonic.VADDNPD); + map.put("Vaddnps", Mnemonic.VADDNPS); + map.put("Vaddsetsps", Mnemonic.VADDSETSPS); + map.put("Vcvtfxpntdq2ps", Mnemonic.VCVTFXPNTDQ2PS); + map.put("Vcvtfxpntpd2dq", Mnemonic.VCVTFXPNTPD2DQ); + map.put("Vcvtfxpntpd2udq", Mnemonic.VCVTFXPNTPD2UDQ); + map.put("Vcvtfxpntps2dq", Mnemonic.VCVTFXPNTPS2DQ); + map.put("Vcvtfxpntps2udq", Mnemonic.VCVTFXPNTPS2UDQ); + map.put("Vcvtfxpntudq2ps", Mnemonic.VCVTFXPNTUDQ2PS); + map.put("Vexp223ps", Mnemonic.VEXP223PS); + map.put("Vfixupnanpd", Mnemonic.VFIXUPNANPD); + map.put("Vfixupnanps", Mnemonic.VFIXUPNANPS); + map.put("Vfmadd233ps", Mnemonic.VFMADD233PS); + map.put("Vgatherpf0hintdpd", Mnemonic.VGATHERPF0HINTDPD); + map.put("Vgatherpf0hintdps", Mnemonic.VGATHERPF0HINTDPS); + map.put("Vgmaxabsps", Mnemonic.VGMAXABSPS); + map.put("Vgmaxpd", Mnemonic.VGMAXPD); + map.put("Vgmaxps", Mnemonic.VGMAXPS); + map.put("Vgminpd", Mnemonic.VGMINPD); + map.put("Vgminps", Mnemonic.VGMINPS); + map.put("Vloadunpackhd", Mnemonic.VLOADUNPACKHD); + map.put("Vloadunpackhpd", Mnemonic.VLOADUNPACKHPD); + map.put("Vloadunpackhps", Mnemonic.VLOADUNPACKHPS); + map.put("Vloadunpackhq", Mnemonic.VLOADUNPACKHQ); + map.put("Vloadunpackld", Mnemonic.VLOADUNPACKLD); + map.put("Vloadunpacklpd", Mnemonic.VLOADUNPACKLPD); + map.put("Vloadunpacklps", Mnemonic.VLOADUNPACKLPS); + map.put("Vloadunpacklq", Mnemonic.VLOADUNPACKLQ); + map.put("Vlog2ps", Mnemonic.VLOG2PS); + map.put("Vmovnrapd", Mnemonic.VMOVNRAPD); + map.put("Vmovnraps", Mnemonic.VMOVNRAPS); + map.put("Vmovnrngoapd", Mnemonic.VMOVNRNGOAPD); + map.put("Vmovnrngoaps", Mnemonic.VMOVNRNGOAPS); + map.put("Vpackstorehd", Mnemonic.VPACKSTOREHD); + map.put("Vpackstorehpd", Mnemonic.VPACKSTOREHPD); + map.put("Vpackstorehps", Mnemonic.VPACKSTOREHPS); + map.put("Vpackstorehq", Mnemonic.VPACKSTOREHQ); + map.put("Vpackstoreld", Mnemonic.VPACKSTORELD); + map.put("Vpackstorelpd", Mnemonic.VPACKSTORELPD); + map.put("Vpackstorelps", Mnemonic.VPACKSTORELPS); + map.put("Vpackstorelq", Mnemonic.VPACKSTORELQ); + map.put("Vpadcd", Mnemonic.VPADCD); + map.put("Vpaddsetcd", Mnemonic.VPADDSETCD); + map.put("Vpaddsetsd", Mnemonic.VPADDSETSD); + map.put("Vpcmpltd", Mnemonic.VPCMPLTD); + map.put("Vpermf32x4", Mnemonic.VPERMF32X4); + map.put("Vpmadd231d", Mnemonic.VPMADD231D); + map.put("Vpmadd233d", Mnemonic.VPMADD233D); + map.put("Vpmulhd", Mnemonic.VPMULHD); + map.put("Vpmulhud", Mnemonic.VPMULHUD); + map.put("Vprefetch0", Mnemonic.VPREFETCH0); + map.put("Vprefetch1", Mnemonic.VPREFETCH1); + map.put("Vprefetch2", Mnemonic.VPREFETCH2); + map.put("Vprefetche0", Mnemonic.VPREFETCHE0); + map.put("Vprefetche1", Mnemonic.VPREFETCHE1); + map.put("Vprefetche2", Mnemonic.VPREFETCHE2); + map.put("Vprefetchenta", Mnemonic.VPREFETCHENTA); + map.put("Vprefetchnta", Mnemonic.VPREFETCHNTA); + map.put("Vpsbbd", Mnemonic.VPSBBD); + map.put("Vpsbbrd", Mnemonic.VPSBBRD); + map.put("Vpsubrd", Mnemonic.VPSUBRD); + map.put("Vpsubrsetbd", Mnemonic.VPSUBRSETBD); + map.put("Vpsubsetbd", Mnemonic.VPSUBSETBD); + map.put("Vrcp23ps", Mnemonic.VRCP23PS); + map.put("Vrndfxpntpd", Mnemonic.VRNDFXPNTPD); + map.put("Vrndfxpntps", Mnemonic.VRNDFXPNTPS); + map.put("Vrsqrt23ps", Mnemonic.VRSQRT23PS); + map.put("Vscaleps", Mnemonic.VSCALEPS); + map.put("Vscatterpf0hintdpd", Mnemonic.VSCATTERPF0HINTDPD); + map.put("Vscatterpf0hintdps", Mnemonic.VSCATTERPF0HINTDPS); + map.put("Vsubrpd", Mnemonic.VSUBRPD); + map.put("Vsubrps", Mnemonic.VSUBRPS); + map.put("Xsha512", Mnemonic.XSHA512); + map.put("Xstore_alt", Mnemonic.XSTORE_ALT); + map.put("Xsha512_alt", Mnemonic.XSHA512_ALT); + map.put("Zero_bytes", Mnemonic.ZERO_BYTES); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMvexConvFn.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMvexConvFn.java new file mode 100644 index 000000000..c843d728b --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMvexConvFn.java @@ -0,0 +1,62 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToMvexConvFn { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant MvexConvFn.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(13); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("None", MvexConvFn.NONE); + map.put("Sf32", MvexConvFn.SF32); + map.put("Sf64", MvexConvFn.SF64); + map.put("Si32", MvexConvFn.SI32); + map.put("Si64", MvexConvFn.SI64); + map.put("Uf32", MvexConvFn.UF32); + map.put("Uf64", MvexConvFn.UF64); + map.put("Ui32", MvexConvFn.UI32); + map.put("Ui64", MvexConvFn.UI64); + map.put("Df32", MvexConvFn.DF32); + map.put("Df64", MvexConvFn.DF64); + map.put("Di32", MvexConvFn.DI32); + map.put("Di64", MvexConvFn.DI64); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMvexTupleTypeLutKind.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMvexTupleTypeLutKind.java new file mode 100644 index 000000000..ef92b2030 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToMvexTupleTypeLutKind.java @@ -0,0 +1,63 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToMvexTupleTypeLutKind { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant MvexTupleTypeLutKind.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(14); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("Int32", MvexTupleTypeLutKind.INT32); + map.put("Int32_Half", MvexTupleTypeLutKind.INT32_HALF); + map.put("Int32_4to16", MvexTupleTypeLutKind.INT32_4TO16); + map.put("Int32_1to16_or_elem", MvexTupleTypeLutKind.INT32_1TO16_OR_ELEM); + map.put("Int64", MvexTupleTypeLutKind.INT64); + map.put("Int64_4to8", MvexTupleTypeLutKind.INT64_4TO8); + map.put("Int64_1to8_or_elem", MvexTupleTypeLutKind.INT64_1TO8_OR_ELEM); + map.put("Float32", MvexTupleTypeLutKind.FLOAT32); + map.put("Float32_Half", MvexTupleTypeLutKind.FLOAT32_HALF); + map.put("Float32_4to16", MvexTupleTypeLutKind.FLOAT32_4TO16); + map.put("Float32_1to16_or_elem", MvexTupleTypeLutKind.FLOAT32_1TO16_OR_ELEM); + map.put("Float64", MvexTupleTypeLutKind.FLOAT64); + map.put("Float64_4to8", MvexTupleTypeLutKind.FLOAT64_4TO8); + map.put("Float64_1to8_or_elem", MvexTupleTypeLutKind.FLOAT64_1TO8_OR_ELEM); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToNumberBase.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToNumberBase.java new file mode 100644 index 000000000..fc29b8d03 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToNumberBase.java @@ -0,0 +1,55 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.NumberBase; + +public final class ToNumberBase { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant NumberBase.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(4); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("Hexadecimal", NumberBase.HEXADECIMAL); + map.put("Decimal", NumberBase.DECIMAL); + map.put("Octal", NumberBase.OCTAL); + map.put("Binary", NumberBase.BINARY); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToOpCodeOperandKind.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToOpCodeOperandKind.java new file mode 100644 index 000000000..0ce6c2a8e --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToOpCodeOperandKind.java @@ -0,0 +1,160 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.info.OpCodeOperandKind; + +public final class ToOpCodeOperandKind { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant OpCodeOperandKind.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(109); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("None", OpCodeOperandKind.NONE); + map.put("farbr2_2", OpCodeOperandKind.FARBR2_2); + map.put("farbr4_2", OpCodeOperandKind.FARBR4_2); + map.put("mem_offs", OpCodeOperandKind.MEM_OFFS); + map.put("mem", OpCodeOperandKind.MEM); + map.put("mem_mpx", OpCodeOperandKind.MEM_MPX); + map.put("mem_mib", OpCodeOperandKind.MEM_MIB); + map.put("mem_vsib32x", OpCodeOperandKind.MEM_VSIB32X); + map.put("mem_vsib64x", OpCodeOperandKind.MEM_VSIB64X); + map.put("mem_vsib32y", OpCodeOperandKind.MEM_VSIB32Y); + map.put("mem_vsib64y", OpCodeOperandKind.MEM_VSIB64Y); + map.put("mem_vsib32z", OpCodeOperandKind.MEM_VSIB32Z); + map.put("mem_vsib64z", OpCodeOperandKind.MEM_VSIB64Z); + map.put("r8_or_mem", OpCodeOperandKind.R8_OR_MEM); + map.put("r16_or_mem", OpCodeOperandKind.R16_OR_MEM); + map.put("r32_or_mem", OpCodeOperandKind.R32_OR_MEM); + map.put("r32_or_mem_mpx", OpCodeOperandKind.R32_OR_MEM_MPX); + map.put("r64_or_mem", OpCodeOperandKind.R64_OR_MEM); + map.put("r64_or_mem_mpx", OpCodeOperandKind.R64_OR_MEM_MPX); + map.put("mm_or_mem", OpCodeOperandKind.MM_OR_MEM); + map.put("xmm_or_mem", OpCodeOperandKind.XMM_OR_MEM); + map.put("ymm_or_mem", OpCodeOperandKind.YMM_OR_MEM); + map.put("zmm_or_mem", OpCodeOperandKind.ZMM_OR_MEM); + map.put("bnd_or_mem_mpx", OpCodeOperandKind.BND_OR_MEM_MPX); + map.put("k_or_mem", OpCodeOperandKind.K_OR_MEM); + map.put("r8_reg", OpCodeOperandKind.R8_REG); + map.put("r8_opcode", OpCodeOperandKind.R8_OPCODE); + map.put("r16_reg", OpCodeOperandKind.R16_REG); + map.put("r16_reg_mem", OpCodeOperandKind.R16_REG_MEM); + map.put("r16_rm", OpCodeOperandKind.R16_RM); + map.put("r16_opcode", OpCodeOperandKind.R16_OPCODE); + map.put("r32_reg", OpCodeOperandKind.R32_REG); + map.put("r32_reg_mem", OpCodeOperandKind.R32_REG_MEM); + map.put("r32_rm", OpCodeOperandKind.R32_RM); + map.put("r32_opcode", OpCodeOperandKind.R32_OPCODE); + map.put("r32_vvvv", OpCodeOperandKind.R32_VVVV); + map.put("r64_reg", OpCodeOperandKind.R64_REG); + map.put("r64_reg_mem", OpCodeOperandKind.R64_REG_MEM); + map.put("r64_rm", OpCodeOperandKind.R64_RM); + map.put("r64_opcode", OpCodeOperandKind.R64_OPCODE); + map.put("r64_vvvv", OpCodeOperandKind.R64_VVVV); + map.put("seg_reg", OpCodeOperandKind.SEG_REG); + map.put("k_reg", OpCodeOperandKind.K_REG); + map.put("kp1_reg", OpCodeOperandKind.KP1_REG); + map.put("k_rm", OpCodeOperandKind.K_RM); + map.put("k_vvvv", OpCodeOperandKind.K_VVVV); + map.put("mm_reg", OpCodeOperandKind.MM_REG); + map.put("mm_rm", OpCodeOperandKind.MM_RM); + map.put("xmm_reg", OpCodeOperandKind.XMM_REG); + map.put("xmm_rm", OpCodeOperandKind.XMM_RM); + map.put("xmm_vvvv", OpCodeOperandKind.XMM_VVVV); + map.put("xmmp3_vvvv", OpCodeOperandKind.XMMP3_VVVV); + map.put("xmm_is4", OpCodeOperandKind.XMM_IS4); + map.put("xmm_is5", OpCodeOperandKind.XMM_IS5); + map.put("ymm_reg", OpCodeOperandKind.YMM_REG); + map.put("ymm_rm", OpCodeOperandKind.YMM_RM); + map.put("ymm_vvvv", OpCodeOperandKind.YMM_VVVV); + map.put("ymm_is4", OpCodeOperandKind.YMM_IS4); + map.put("ymm_is5", OpCodeOperandKind.YMM_IS5); + map.put("zmm_reg", OpCodeOperandKind.ZMM_REG); + map.put("zmm_rm", OpCodeOperandKind.ZMM_RM); + map.put("zmm_vvvv", OpCodeOperandKind.ZMM_VVVV); + map.put("zmmp3_vvvv", OpCodeOperandKind.ZMMP3_VVVV); + map.put("cr_reg", OpCodeOperandKind.CR_REG); + map.put("dr_reg", OpCodeOperandKind.DR_REG); + map.put("tr_reg", OpCodeOperandKind.TR_REG); + map.put("bnd_reg", OpCodeOperandKind.BND_REG); + map.put("es", OpCodeOperandKind.ES); + map.put("cs", OpCodeOperandKind.CS); + map.put("ss", OpCodeOperandKind.SS); + map.put("ds", OpCodeOperandKind.DS); + map.put("fs", OpCodeOperandKind.FS); + map.put("gs", OpCodeOperandKind.GS); + map.put("al", OpCodeOperandKind.AL); + map.put("cl", OpCodeOperandKind.CL); + map.put("ax", OpCodeOperandKind.AX); + map.put("dx", OpCodeOperandKind.DX); + map.put("eax", OpCodeOperandKind.EAX); + map.put("rax", OpCodeOperandKind.RAX); + map.put("st0", OpCodeOperandKind.ST0); + map.put("sti_opcode", OpCodeOperandKind.STI_OPCODE); + map.put("imm4_m2z", OpCodeOperandKind.IMM4_M2Z); + map.put("imm8", OpCodeOperandKind.IMM8); + map.put("imm8_const_1", OpCodeOperandKind.IMM8_CONST_1); + map.put("imm8sex16", OpCodeOperandKind.IMM8SEX16); + map.put("imm8sex32", OpCodeOperandKind.IMM8SEX32); + map.put("imm8sex64", OpCodeOperandKind.IMM8SEX64); + map.put("imm16", OpCodeOperandKind.IMM16); + map.put("imm32", OpCodeOperandKind.IMM32); + map.put("imm32sex64", OpCodeOperandKind.IMM32SEX64); + map.put("imm64", OpCodeOperandKind.IMM64); + map.put("seg_rSI", OpCodeOperandKind.SEG_RSI); + map.put("es_rDI", OpCodeOperandKind.ES_RDI); + map.put("seg_rDI", OpCodeOperandKind.SEG_RDI); + map.put("seg_rBX_al", OpCodeOperandKind.SEG_RBX_AL); + map.put("br16_1", OpCodeOperandKind.BR16_1); + map.put("br32_1", OpCodeOperandKind.BR32_1); + map.put("br64_1", OpCodeOperandKind.BR64_1); + map.put("br16_2", OpCodeOperandKind.BR16_2); + map.put("br32_4", OpCodeOperandKind.BR32_4); + map.put("br64_4", OpCodeOperandKind.BR64_4); + map.put("xbegin_2", OpCodeOperandKind.XBEGIN_2); + map.put("xbegin_4", OpCodeOperandKind.XBEGIN_4); + map.put("brdisp_2", OpCodeOperandKind.BRDISP_2); + map.put("brdisp_4", OpCodeOperandKind.BRDISP_4); + map.put("sibmem", OpCodeOperandKind.SIBMEM); + map.put("tmm_reg", OpCodeOperandKind.TMM_REG); + map.put("tmm_rm", OpCodeOperandKind.TMM_RM); + map.put("tmm_vvvv", OpCodeOperandKind.TMM_VVVV); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToOptionsProps.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToOptionsProps.java new file mode 100644 index 000000000..b4f25fb68 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToOptionsProps.java @@ -0,0 +1,115 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +import com.github.icedland.iced.x86.fmt.OptionsProps; + +public final class ToOptionsProps { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant OptionsProps.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(64); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("AddLeadingZeroToHexNumbers", OptionsProps.ADD_LEADING_ZERO_TO_HEX_NUMBERS); + map.put("AlwaysShowScale", OptionsProps.ALWAYS_SHOW_SCALE); + map.put("AlwaysShowSegmentRegister", OptionsProps.ALWAYS_SHOW_SEGMENT_REGISTER); + map.put("BinaryDigitGroupSize", OptionsProps.BINARY_DIGIT_GROUP_SIZE); + map.put("BinaryPrefix", OptionsProps.BINARY_PREFIX); + map.put("BinarySuffix", OptionsProps.BINARY_SUFFIX); + map.put("BranchLeadingZeros", OptionsProps.BRANCH_LEADING_ZEROS); + map.put("DecimalDigitGroupSize", OptionsProps.DECIMAL_DIGIT_GROUP_SIZE); + map.put("DecimalPrefix", OptionsProps.DECIMAL_PREFIX); + map.put("DecimalSuffix", OptionsProps.DECIMAL_SUFFIX); + map.put("DigitSeparator", OptionsProps.DIGIT_SEPARATOR); + map.put("DisplacementLeadingZeros", OptionsProps.DISPLACEMENT_LEADING_ZEROS); + map.put("FirstOperandCharIndex", OptionsProps.FIRST_OPERAND_CHAR_INDEX); + map.put("GasNakedRegisters", OptionsProps.GAS_NAKED_REGISTERS); + map.put("GasShowMnemonicSizeSuffix", OptionsProps.GAS_SHOW_MNEMONIC_SIZE_SUFFIX); + map.put("GasSpaceAfterMemoryOperandComma", OptionsProps.GAS_SPACE_AFTER_MEMORY_OPERAND_COMMA); + map.put("HexDigitGroupSize", OptionsProps.HEX_DIGIT_GROUP_SIZE); + map.put("HexPrefix", OptionsProps.HEX_PREFIX); + map.put("HexSuffix", OptionsProps.HEX_SUFFIX); + map.put("IP", OptionsProps.IP); + map.put("LeadingZeros", OptionsProps.LEADING_ZEROS); + map.put("MasmAddDsPrefix32", OptionsProps.MASM_ADD_DS_PREFIX32); + map.put("MemorySizeOptions", OptionsProps.MEMORY_SIZE_OPTIONS); + map.put("NasmShowSignExtendedImmediateSize", OptionsProps.NASM_SHOW_SIGN_EXTENDED_IMMEDIATE_SIZE); + map.put("NumberBase", OptionsProps.NUMBER_BASE); + map.put("OctalDigitGroupSize", OptionsProps.OCTAL_DIGIT_GROUP_SIZE); + map.put("OctalPrefix", OptionsProps.OCTAL_PREFIX); + map.put("OctalSuffix", OptionsProps.OCTAL_SUFFIX); + map.put("PreferST0", OptionsProps.PREFER_ST0); + map.put("RipRelativeAddresses", OptionsProps.RIP_RELATIVE_ADDRESSES); + map.put("ScaleBeforeIndex", OptionsProps.SCALE_BEFORE_INDEX); + map.put("ShowBranchSize", OptionsProps.SHOW_BRANCH_SIZE); + map.put("ShowSymbolAddress", OptionsProps.SHOW_SYMBOL_ADDRESS); + map.put("ShowZeroDisplacements", OptionsProps.SHOW_ZERO_DISPLACEMENTS); + map.put("SignedImmediateOperands", OptionsProps.SIGNED_IMMEDIATE_OPERANDS); + map.put("SignedMemoryDisplacements", OptionsProps.SIGNED_MEMORY_DISPLACEMENTS); + map.put("SmallHexNumbersInDecimal", OptionsProps.SMALL_HEX_NUMBERS_IN_DECIMAL); + map.put("SpaceAfterMemoryBracket", OptionsProps.SPACE_AFTER_MEMORY_BRACKET); + map.put("SpaceAfterOperandSeparator", OptionsProps.SPACE_AFTER_OPERAND_SEPARATOR); + map.put("SpaceBetweenMemoryAddOperators", OptionsProps.SPACE_BETWEEN_MEMORY_ADD_OPERATORS); + map.put("SpaceBetweenMemoryMulOperators", OptionsProps.SPACE_BETWEEN_MEMORY_MUL_OPERATORS); + map.put("TabSize", OptionsProps.TAB_SIZE); + map.put("UppercaseAll", OptionsProps.UPPERCASE_ALL); + map.put("UppercaseDecorators", OptionsProps.UPPERCASE_DECORATORS); + map.put("UppercaseHex", OptionsProps.UPPERCASE_HEX); + map.put("UppercaseKeywords", OptionsProps.UPPERCASE_KEYWORDS); + map.put("UppercaseMnemonics", OptionsProps.UPPERCASE_MNEMONICS); + map.put("UppercasePrefixes", OptionsProps.UPPERCASE_PREFIXES); + map.put("UppercaseRegisters", OptionsProps.UPPERCASE_REGISTERS); + map.put("UsePseudoOps", OptionsProps.USE_PSEUDO_OPS); + map.put("CC_b", OptionsProps.CC_B); + map.put("CC_ae", OptionsProps.CC_AE); + map.put("CC_e", OptionsProps.CC_E); + map.put("CC_ne", OptionsProps.CC_NE); + map.put("CC_be", OptionsProps.CC_BE); + map.put("CC_a", OptionsProps.CC_A); + map.put("CC_p", OptionsProps.CC_P); + map.put("CC_np", OptionsProps.CC_NP); + map.put("CC_l", OptionsProps.CC_L); + map.put("CC_ge", OptionsProps.CC_GE); + map.put("CC_le", OptionsProps.CC_LE); + map.put("CC_g", OptionsProps.CC_G); + map.put("DecoderOptions", OptionsProps.DECODER_OPTIONS); + map.put("ShowUselessPrefixes", OptionsProps.SHOW_USELESS_PREFIXES); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToRegister.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToRegister.java new file mode 100644 index 000000000..4b2dc9dd0 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToRegister.java @@ -0,0 +1,306 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToRegister { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant Register.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(256); + initMap0(map); + return map; + } + + @SuppressWarnings("deprecation") + private static void initMap0(HashMap map) { + map.put("none", Register.NONE); + map.put("al", Register.AL); + map.put("cl", Register.CL); + map.put("dl", Register.DL); + map.put("bl", Register.BL); + map.put("ah", Register.AH); + map.put("ch", Register.CH); + map.put("dh", Register.DH); + map.put("bh", Register.BH); + map.put("spl", Register.SPL); + map.put("bpl", Register.BPL); + map.put("sil", Register.SIL); + map.put("dil", Register.DIL); + map.put("r8l", Register.R8L); + map.put("r9l", Register.R9L); + map.put("r10l", Register.R10L); + map.put("r11l", Register.R11L); + map.put("r12l", Register.R12L); + map.put("r13l", Register.R13L); + map.put("r14l", Register.R14L); + map.put("r15l", Register.R15L); + map.put("ax", Register.AX); + map.put("cx", Register.CX); + map.put("dx", Register.DX); + map.put("bx", Register.BX); + map.put("sp", Register.SP); + map.put("bp", Register.BP); + map.put("si", Register.SI); + map.put("di", Register.DI); + map.put("r8w", Register.R8W); + map.put("r9w", Register.R9W); + map.put("r10w", Register.R10W); + map.put("r11w", Register.R11W); + map.put("r12w", Register.R12W); + map.put("r13w", Register.R13W); + map.put("r14w", Register.R14W); + map.put("r15w", Register.R15W); + map.put("eax", Register.EAX); + map.put("ecx", Register.ECX); + map.put("edx", Register.EDX); + map.put("ebx", Register.EBX); + map.put("esp", Register.ESP); + map.put("ebp", Register.EBP); + map.put("esi", Register.ESI); + map.put("edi", Register.EDI); + map.put("r8d", Register.R8D); + map.put("r9d", Register.R9D); + map.put("r10d", Register.R10D); + map.put("r11d", Register.R11D); + map.put("r12d", Register.R12D); + map.put("r13d", Register.R13D); + map.put("r14d", Register.R14D); + map.put("r15d", Register.R15D); + map.put("rax", Register.RAX); + map.put("rcx", Register.RCX); + map.put("rdx", Register.RDX); + map.put("rbx", Register.RBX); + map.put("rsp", Register.RSP); + map.put("rbp", Register.RBP); + map.put("rsi", Register.RSI); + map.put("rdi", Register.RDI); + map.put("r8", Register.R8); + map.put("r9", Register.R9); + map.put("r10", Register.R10); + map.put("r11", Register.R11); + map.put("r12", Register.R12); + map.put("r13", Register.R13); + map.put("r14", Register.R14); + map.put("r15", Register.R15); + map.put("eip", Register.EIP); + map.put("rip", Register.RIP); + map.put("es", Register.ES); + map.put("cs", Register.CS); + map.put("ss", Register.SS); + map.put("ds", Register.DS); + map.put("fs", Register.FS); + map.put("gs", Register.GS); + map.put("xmm0", Register.XMM0); + map.put("xmm1", Register.XMM1); + map.put("xmm2", Register.XMM2); + map.put("xmm3", Register.XMM3); + map.put("xmm4", Register.XMM4); + map.put("xmm5", Register.XMM5); + map.put("xmm6", Register.XMM6); + map.put("xmm7", Register.XMM7); + map.put("xmm8", Register.XMM8); + map.put("xmm9", Register.XMM9); + map.put("xmm10", Register.XMM10); + map.put("xmm11", Register.XMM11); + map.put("xmm12", Register.XMM12); + map.put("xmm13", Register.XMM13); + map.put("xmm14", Register.XMM14); + map.put("xmm15", Register.XMM15); + map.put("xmm16", Register.XMM16); + map.put("xmm17", Register.XMM17); + map.put("xmm18", Register.XMM18); + map.put("xmm19", Register.XMM19); + map.put("xmm20", Register.XMM20); + map.put("xmm21", Register.XMM21); + map.put("xmm22", Register.XMM22); + map.put("xmm23", Register.XMM23); + map.put("xmm24", Register.XMM24); + map.put("xmm25", Register.XMM25); + map.put("xmm26", Register.XMM26); + map.put("xmm27", Register.XMM27); + map.put("xmm28", Register.XMM28); + map.put("xmm29", Register.XMM29); + map.put("xmm30", Register.XMM30); + map.put("xmm31", Register.XMM31); + map.put("ymm0", Register.YMM0); + map.put("ymm1", Register.YMM1); + map.put("ymm2", Register.YMM2); + map.put("ymm3", Register.YMM3); + map.put("ymm4", Register.YMM4); + map.put("ymm5", Register.YMM5); + map.put("ymm6", Register.YMM6); + map.put("ymm7", Register.YMM7); + map.put("ymm8", Register.YMM8); + map.put("ymm9", Register.YMM9); + map.put("ymm10", Register.YMM10); + map.put("ymm11", Register.YMM11); + map.put("ymm12", Register.YMM12); + map.put("ymm13", Register.YMM13); + map.put("ymm14", Register.YMM14); + map.put("ymm15", Register.YMM15); + map.put("ymm16", Register.YMM16); + map.put("ymm17", Register.YMM17); + map.put("ymm18", Register.YMM18); + map.put("ymm19", Register.YMM19); + map.put("ymm20", Register.YMM20); + map.put("ymm21", Register.YMM21); + map.put("ymm22", Register.YMM22); + map.put("ymm23", Register.YMM23); + map.put("ymm24", Register.YMM24); + map.put("ymm25", Register.YMM25); + map.put("ymm26", Register.YMM26); + map.put("ymm27", Register.YMM27); + map.put("ymm28", Register.YMM28); + map.put("ymm29", Register.YMM29); + map.put("ymm30", Register.YMM30); + map.put("ymm31", Register.YMM31); + map.put("zmm0", Register.ZMM0); + map.put("zmm1", Register.ZMM1); + map.put("zmm2", Register.ZMM2); + map.put("zmm3", Register.ZMM3); + map.put("zmm4", Register.ZMM4); + map.put("zmm5", Register.ZMM5); + map.put("zmm6", Register.ZMM6); + map.put("zmm7", Register.ZMM7); + map.put("zmm8", Register.ZMM8); + map.put("zmm9", Register.ZMM9); + map.put("zmm10", Register.ZMM10); + map.put("zmm11", Register.ZMM11); + map.put("zmm12", Register.ZMM12); + map.put("zmm13", Register.ZMM13); + map.put("zmm14", Register.ZMM14); + map.put("zmm15", Register.ZMM15); + map.put("zmm16", Register.ZMM16); + map.put("zmm17", Register.ZMM17); + map.put("zmm18", Register.ZMM18); + map.put("zmm19", Register.ZMM19); + map.put("zmm20", Register.ZMM20); + map.put("zmm21", Register.ZMM21); + map.put("zmm22", Register.ZMM22); + map.put("zmm23", Register.ZMM23); + map.put("zmm24", Register.ZMM24); + map.put("zmm25", Register.ZMM25); + map.put("zmm26", Register.ZMM26); + map.put("zmm27", Register.ZMM27); + map.put("zmm28", Register.ZMM28); + map.put("zmm29", Register.ZMM29); + map.put("zmm30", Register.ZMM30); + map.put("zmm31", Register.ZMM31); + map.put("k0", Register.K0); + map.put("k1", Register.K1); + map.put("k2", Register.K2); + map.put("k3", Register.K3); + map.put("k4", Register.K4); + map.put("k5", Register.K5); + map.put("k6", Register.K6); + map.put("k7", Register.K7); + map.put("bnd0", Register.BND0); + map.put("bnd1", Register.BND1); + map.put("bnd2", Register.BND2); + map.put("bnd3", Register.BND3); + map.put("cr0", Register.CR0); + map.put("cr1", Register.CR1); + map.put("cr2", Register.CR2); + map.put("cr3", Register.CR3); + map.put("cr4", Register.CR4); + map.put("cr5", Register.CR5); + map.put("cr6", Register.CR6); + map.put("cr7", Register.CR7); + map.put("cr8", Register.CR8); + map.put("cr9", Register.CR9); + map.put("cr10", Register.CR10); + map.put("cr11", Register.CR11); + map.put("cr12", Register.CR12); + map.put("cr13", Register.CR13); + map.put("cr14", Register.CR14); + map.put("cr15", Register.CR15); + map.put("dr0", Register.DR0); + map.put("dr1", Register.DR1); + map.put("dr2", Register.DR2); + map.put("dr3", Register.DR3); + map.put("dr4", Register.DR4); + map.put("dr5", Register.DR5); + map.put("dr6", Register.DR6); + map.put("dr7", Register.DR7); + map.put("dr8", Register.DR8); + map.put("dr9", Register.DR9); + map.put("dr10", Register.DR10); + map.put("dr11", Register.DR11); + map.put("dr12", Register.DR12); + map.put("dr13", Register.DR13); + map.put("dr14", Register.DR14); + map.put("dr15", Register.DR15); + map.put("st0", Register.ST0); + map.put("st1", Register.ST1); + map.put("st2", Register.ST2); + map.put("st3", Register.ST3); + map.put("st4", Register.ST4); + map.put("st5", Register.ST5); + map.put("st6", Register.ST6); + map.put("st7", Register.ST7); + map.put("mm0", Register.MM0); + map.put("mm1", Register.MM1); + map.put("mm2", Register.MM2); + map.put("mm3", Register.MM3); + map.put("mm4", Register.MM4); + map.put("mm5", Register.MM5); + map.put("mm6", Register.MM6); + map.put("mm7", Register.MM7); + map.put("tr0", Register.TR0); + map.put("tr1", Register.TR1); + map.put("tr2", Register.TR2); + map.put("tr3", Register.TR3); + map.put("tr4", Register.TR4); + map.put("tr5", Register.TR5); + map.put("tr6", Register.TR6); + map.put("tr7", Register.TR7); + map.put("tmm0", Register.TMM0); + map.put("tmm1", Register.TMM1); + map.put("tmm2", Register.TMM2); + map.put("tmm3", Register.TMM3); + map.put("tmm4", Register.TMM4); + map.put("tmm5", Register.TMM5); + map.put("tmm6", Register.TMM6); + map.put("tmm7", Register.TMM7); + map.put("dontuse0", Register.DONTUSE0); + map.put("dontusefa", Register.DONTUSEFA); + map.put("dontusefb", Register.DONTUSEFB); + map.put("dontusefc", Register.DONTUSEFC); + map.put("dontusefd", Register.DONTUSEFD); + map.put("dontusefe", Register.DONTUSEFE); + map.put("dontuseff", Register.DONTUSEFF); + } +} diff --git a/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToTupleType.java b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToTupleType.java new file mode 100644 index 000000000..4ac041359 --- /dev/null +++ b/src/java/iced-x86/src/test/java/com/github/icedland/iced/x86/ToTupleType.java @@ -0,0 +1,68 @@ +// SPDX-License-Identifier: MIT +// Copyright (C) 2018-present iced project and contributors + +// ⚠️This file was generated by GENERATOR!🦹‍♂️ + +package com.github.icedland.iced.x86; + +import java.util.HashMap; +import java.util.Iterator; + +public final class ToTupleType { + static Integer tryGet(String key) { + return map.get(key); + } + + static Integer get(String key) { + Integer value = tryGet(key); + if (value == null) + throw new UnsupportedOperationException(String.format("Couldn't find enum variant TupleType.%s", key)); + return value; + } + + static Iterator names() { + return map.keySet().iterator(); + } + + static Iterator values() { + return map.values().iterator(); + } + + static int size() { + return map.size(); + } + + static HashMap copy() { + return new HashMap(map); + } + + private static final HashMap map = getMap(); + + private static HashMap getMap() { + HashMap map = new HashMap(19); + initMap0(map); + return map; + } + + private static void initMap0(HashMap map) { + map.put("N1", TupleType.N1); + map.put("N2", TupleType.N2); + map.put("N4", TupleType.N4); + map.put("N8", TupleType.N8); + map.put("N16", TupleType.N16); + map.put("N32", TupleType.N32); + map.put("N64", TupleType.N64); + map.put("N8b4", TupleType.N8B4); + map.put("N16b4", TupleType.N16B4); + map.put("N32b4", TupleType.N32B4); + map.put("N64b4", TupleType.N64B4); + map.put("N16b8", TupleType.N16B8); + map.put("N32b8", TupleType.N32B8); + map.put("N64b8", TupleType.N64B8); + map.put("N4b2", TupleType.N4B2); + map.put("N8b2", TupleType.N8B2); + map.put("N16b2", TupleType.N16B2); + map.put("N32b2", TupleType.N32B2); + map.put("N64b2", TupleType.N64B2); + } +}