Support APX CCMP and CTEST

CCMP and CTEST are two new sets of instructions for conditional CMP
and TEST, SCC and OSZC flags are given as suffixes of CCMP or CTEST
in the instruction mnemonic, e.g.:

ccmp<cc> { dfv=sf , cf , of } %eax, %ecx

also add

{evex} cmp/test %eax, %ecx

as an alias for ccmpt.

For the encoder part, add function check_Scc_OszcOperation to parse
'{ dfv=of , sf, sf, cf}', store scc in the lower 4 bits of base_opcode,
and adjust base_opcode to its normal meaning in install_template.

For the decoder part, add 'SC' and 'DF' macros to add scc and oszc flags
suffixes.

gas/ChangeLog:

        * config/tc-i386.c (OSZC_CF): New.
        (OSZC_ZF): Ditto.
        (OSZC_SF): Ditto.
        (OSZC_OF): Ditto.
        (set_oszc_flags): Set oszc flags and report error for using the same oszc flags twice.
        (check_Scc_OszcOperations): Handle SCC OSZC flags.
        (install_template): Add scc and oszc_flags.
        (build_apx_evex_prefix): Encode SCC and oszc flags bits.
        (parse_insn): Handle check_Scc_OszcOperations.
        * testsuite/gas/i386/x86-64-apx-evex-promoted-bad.d: Add ivalid test case.
        * testsuite/gas/i386/x86-64-apx-evex-promoted-bad.s: Ditto.
        * testsuite/gas/i386/x86-64.exp: Add test for ccmp and ctest.
        * testsuite/gas/i386/x86-64-apx-ccmp-ctest-intel.d: New test.
        * testsuite/gas/i386/x86-64-apx-ccmp-ctest-inval.l: Ditto.
        * testsuite/gas/i386/x86-64-apx-ccmp-ctest-inval.s: Ditto.
        * testsuite/gas/i386/x86-64-apx-ccmp-ctest.d: Ditto.
        * testsuite/gas/i386/x86-64-apx-ccmp-ctest.s: Ditto.

opcodes/ChangeLog:

        * i386-dis-evex-reg.h: Add ccmp and ctest.
        * i386-dis-evex.h: Ditto.
        * i386-dis.c (struct instr_info): add scc.
        (struct dis386): Add new micro 'NE','SC' and'DF'.
        (get_valid_dis386): Get scc value and move MAP4 invalid check to print_insn.
        (putop): Handle %NE, %SC and %DF.
        * i386-opc.h (SCC): New.
        * i386-opc.tbl: Add ccmp/ctest and evex format for cmp/test.
        * i386-mnem.h: Regenerated.
        * i386-tbl.h: Ditto.

diff --git a/gas/config/tc-i386.c b/gas/config/tc-i386.c
index e0c69640e01828ffd7c026765f44d862ca53131b..b8fc3c438196c7d16c67b858bda0ef114247c22a 100644 (file)
--- a/gas/config/tc-i386.c
+++ b/gas/config/tc-i386.c
@@ -416,6 +416,16 @@ struct _i386_insn
     /* Compressed disp8*N attribute.  */
     unsigned int memshift;
 
+    /* SCC = EVEX.[SC3,SC2,SC1,SC0].  */
+    unsigned int scc;
+
+    /* Store 4 bits of EVEX.[OF,SF,ZF,CF].  */
+#define OSZC_CF 1
+#define OSZC_ZF 2
+#define OSZC_SF 4
+#define OSZC_OF 8
+    unsigned int oszc_flags;
+
     /* Prefer load or store in encoding.  */
     enum
       {
@@ -1929,6 +1939,110 @@ static INLINE bool need_evex_encoding (const insn_template *t)
 #define CPU_FLAGS_PERFECT_MATCH \
   (CPU_FLAGS_ARCH_MATCH | CPU_FLAGS_64BIT_MATCH)
 
+static INLINE bool set_oszc_flags (unsigned int oszc_shift)
+{
+  if (i.oszc_flags & oszc_shift)
+    {
+      as_bad (_("same oszc flag used twice"));
+      return false;
+    }
+  i.oszc_flags |= oszc_shift;
+  return true;
+}
+
+/* Handle SCC OSZC flags.  */
+
+static int
+check_Scc_OszcOperations (const char *l)
+{
+  const char *suffix_string = l;
+
+  while (is_space_char (*suffix_string))
+    suffix_string++;
+
+  /* If {oszc flags} is absent, just return.  */
+  if (*suffix_string != '{')
+    return 0;
+
+  /* Skip '{'.  */
+  suffix_string++;
+
+  /* Parse 'dfv='.  */
+  while (is_space_char (*suffix_string))
+    suffix_string++;
+
+  if (strncasecmp (suffix_string, "dfv", 3) == 0)
+    suffix_string += 3;
+  else
+    {
+      as_bad (_("unrecognized pseudo-suffix"));
+      return -1;
+    }
+
+  while (is_space_char (*suffix_string))
+    suffix_string++;
+
+  if (*suffix_string == '=')
+    suffix_string++;
+  else
+    {
+      as_bad (_("unrecognized pseudo-suffix"));
+      return -1;
+    }
+
+  /* Parse 'of, sf, zf, cf}'.  */
+  while (*suffix_string)
+    {
+      while (is_space_char (*suffix_string))
+       suffix_string++;
+
+      /* Return for '{dfv=}'.  */
+      if (*suffix_string == '}')
+       return suffix_string + 1 - l;
+
+      if (strncasecmp (suffix_string, "of", 2) == 0)
+       {
+         if (!set_oszc_flags (OSZC_OF))
+           return -1;
+       }
+      else if (strncasecmp (suffix_string, "sf", 2) == 0)
+       {
+         if (!set_oszc_flags (OSZC_SF))
+           return -1;
+       }
+      else if (strncasecmp (suffix_string, "zf", 2) == 0)
+       {
+         if (!set_oszc_flags (OSZC_ZF))
+           return -1;
+       }
+      else if (strncasecmp (suffix_string, "cf", 2) == 0)
+       {
+         if (!set_oszc_flags (OSZC_CF))
+           return -1;
+       }
+      else
+       {
+         as_bad (_("unrecognized oszc flags or illegal `,' in pseudo-suffix"));
+         return -1;
+       }
+
+      suffix_string += 2;
+
+      while (is_space_char (*suffix_string))
+       suffix_string++;
+
+      if (*suffix_string == '}')
+       return ++suffix_string - l;
+
+      if (*suffix_string != ',')
+       break;
+      suffix_string ++;
+    }
+
+  as_bad (_("missing `}' or `,' in pseudo-suffix"));
+  return -1;
+}
+
 /* Return CPU flags match bits. */
 
 static int
@@ -3793,10 +3907,19 @@ install_template (const insn_template *t)
        }
     }
 
+  /* For CCMP and CTEST the template has EVEX.SCC in base_opcode. Move it out of
+     there, to then adjust base_opcode to obtain its normal meaning.  */
+  if (i.tm.opcode_modifier.operandconstraint == SCC)
+    {
+      /* Get EVEX.SCC value from the lower 4 bits of base_opcode.  */
+      i.scc = i.tm.base_opcode & 0xf;
+      i.tm.base_opcode >>= 8;
+    }
+
   /* Note that for pseudo prefixes this produces a length of 1. But for them
      the length isn't interesting at all.  */
   for (l = 1; l < 4; ++l)
-    if (!(t->base_opcode >> (8 * l)))
+    if (!(i.tm.base_opcode >> (8 * l)))
       break;
 
   i.opcode_length = l;
@@ -4290,6 +4413,18 @@ build_apx_evex_prefix (void)
       || i.tm.opcode_modifier.operandconstraint == ZERO_UPPER)
     i.vex.bytes[3] |= 0x10;
 
+  /* Encode SCC and oszc flags bits.  */
+  if (i.tm.opcode_modifier.operandconstraint == SCC)
+    {
+      /* The default value of vvvv is 1111 and needs to be cleared.  */
+      i.vex.bytes[2] &= ~0x78;
+      i.vex.bytes[2] |= (i.oszc_flags << 3);
+      /* ND and aaa bits shold be 0.  */
+      know (!(i.vex.bytes[3] & 0x17));
+      /* The default value of V' is 1 and needs to be cleared.  */
+      i.vex.bytes[3] = (i.vex.bytes[3] & ~0x08) | i.scc;
+    }
+
   /* Encode the NF bit.  */
   if (i.has_nf)
     i.vex.bytes[3] |= 0x04;
@@ -7428,6 +7563,15 @@ parse_insn (const char *line, char *mnemonic, bool prefix_only)
        }
     }
 
+  /* Handle SCC OSZC flgs.  */
+  if (current_templates.start->opcode_modifier.operandconstraint == SCC)
+    {
+      int length = check_Scc_OszcOperations (l);
+      if (length < 0)
+       return NULL;
+      l += length;
+    }
+
   if (current_templates.start->opcode_modifier.jump == JUMP
       || current_templates.start->opcode_modifier.jump == JUMP_BYTE)
     {

diff --git a/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest-intel.d b/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest-intel.d
new file mode 100644 (file)
index 0000000..c9ab3e9
--- /dev/null
+++ b/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest-intel.d
@@ -0,0 +1,222 @@
+#as:
+#objdump: -dw -Mintel
+#name: x86_64 APX_F CCMP and CTEST insns (Intel disassembly)
+#source: x86-64-apx-ccmp-ctest.s
+
+.*: +file format .*
+
+Disassembly of section \.text:
+
+0+ <_start>:
+[      ]*[a-f0-9]+:[   ]*62 d4 8c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=cf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 0d 02 39 f8[    ]+ccmpb \{dfv=cf\} ax,r15w
+[      ]*[a-f0-9]+:[   ]*62 54 0c 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=cf\} r15d,DWORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 4d 02 83 ff 7b[         ]+ccmpb \{dfv=of, cf\} r15w,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 4c 02 80 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, cf\} BYTE PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 6d 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, sf, cf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 ec 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf, cf\} QWORD PTR \[r8\+rax\*4\+0x123\],r15
+[      ]*[a-f0-9]+:[   ]*62 d4 7d 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, sf, zf, cf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 fc 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, sf, zf, cf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 74 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, sf, zf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 f4 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf, zf\} QWORD PTR \[r8\+rax\*4\+0x123\],r15
+[      ]*[a-f0-9]+:[   ]*62 d4 e4 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, sf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 64 02 3a 84 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf\} r8b,BYTE PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 5c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, zf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 5c 02 38 84 80 23 01 00 00[     ]+ccmpb \{dfv=of, zf, cf\} BYTE PTR \[r8\+rax\*4\+0x123\],r8b
+[      ]*[a-f0-9]+:[   ]*62 d4 55 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, zf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 54 02 38 c2[    ]+ccmpb \{dfv=of, zf\} dl,r8b
+[      ]*[a-f0-9]+:[   ]*62 74 44 02 39 fa[    ]+ccmpb \{dfv=of\} edx,r15d
+[      ]*[a-f0-9]+:[   ]*62 54 45 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=of\} r15w,WORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 2c 02 80 f8 7b[         ]+ccmpb \{dfv=sf, cf\} r8b,0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 2c 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],r15d
+[      ]*[a-f0-9]+:[   ]*62 54 ac 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, cf\} r15,QWORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 3c 02 83 ff 7b[         ]+ccmpb \{dfv=sf, zf, cf\} r15d,0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 3d 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, zf, cf\} r15w,WORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 34 02 83 ff 7b[         ]+ccmpb \{dfv=sf, zf\} r15d,0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 34 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, zf\} DWORD PTR \[r8\+rax\*4\+0x123\],r15d
+[      ]*[a-f0-9]+:[   ]*62 d4 a4 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=sf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 a4 02 39 ff[    ]+ccmpb \{dfv=sf\} r15,r15
+[      ]*[a-f0-9]+:[   ]*62 54 a4 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf\} r15,QWORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 9c 02 83 ff 7b[         ]+ccmpb \{dfv=zf, cf\} r15,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 1c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=zf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 1d 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=zf, cf\} WORD PTR \[r8\+rax\*4\+0x123\],r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 94 02 83 ff 7b[         ]+ccmpb \{dfv=zf\} r15,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 15 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=zf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 15 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=zf\} WORD PTR \[r8\+rax\*4\+0x123\],r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 05 02 83 ff 7b[         ]+ccmpb \{dfv=\} r15w,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 04 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 04 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=\} r15d,DWORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 fc c4 00 83 f8 7b[         ]+ccmpo \{dfv=of\} r16,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 01 83 f9 7b[         ]+ccmpno \{dfv=of\} r17,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 02 83 fa 7b[         ]+ccmpb \{dfv=of\} r18,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 03 83 fb 7b[         ]+ccmpae \{dfv=of\} r19,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 04 83 fc 7b[         ]+ccmpe \{dfv=of\} r20,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 05 83 fd 7b[         ]+ccmpne \{dfv=of\} r21,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 06 83 fe 7b[         ]+ccmpbe \{dfv=of\} r22,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 07 83 ff 7b[         ]+ccmpa \{dfv=of\} r23,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 08 83 f8 7b[         ]+ccmps \{dfv=of\} r24,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 09 83 f9 7b[         ]+ccmpns \{dfv=of\} r25,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0a 83 fa 7b[         ]+ccmpt \{dfv=of\} r26,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0b 83 fb 7b[         ]+ccmpf \{dfv=of\} r27,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0c 83 fc 7b[         ]+ccmpl \{dfv=of\} r28,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0d 83 fd 7b[         ]+ccmpge \{dfv=of\} r29,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0e 83 fe 7b[         ]+ccmple \{dfv=of\} r30,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f 83 ff 7b[         ]+ccmpg \{dfv=of\} r31,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 8c 02 f7 c7 7b 00 00 00[        ]+ctestb \{dfv=cf\} r15,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 0d 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestb \{dfv=cf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 4c 02 f6 84 80 23 01 00 00 7b[  ]+ctestb \{dfv=of, cf\} BYTE PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 cc 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, cf\} QWORD PTR \[r8\+rax\*4\+0x123\],r15
+[      ]*[a-f0-9]+:[   ]*62 d4 ec 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=of, sf, cf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 7c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=of, sf, zf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 75 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestb \{dfv=of, sf, zf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 64 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=of, sf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 65 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, sf\} WORD PTR \[r8\+rax\*4\+0x123\],r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 5d 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestb \{dfv=of, zf, cf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 5d 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, zf, cf\} WORD PTR \[r8\+rax\*4\+0x123\],r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 54 02 f6 84 80 23 01 00 00 7b[  ]+ctestb \{dfv=of, zf\} BYTE PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 d4 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, zf\} QWORD PTR \[r8\+rax\*4\+0x123\],r15
+[      ]*[a-f0-9]+:[   ]*62 54 44 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of\} DWORD PTR \[r8\+rax\*4\+0x123\],r15d
+[      ]*[a-f0-9]+:[   ]*62 54 44 02 84 84 80 23 01 00 00[     ]+ctestb \{dfv=of\} BYTE PTR \[r8\+rax\*4\+0x123\],r8b
+[      ]*[a-f0-9]+:[   ]*62 d4 2c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=sf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 2c 02 85 fa[    ]+ctestb \{dfv=sf, cf\} edx,r15d
+[      ]*[a-f0-9]+:[   ]*62 54 3c 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=sf, zf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],r15d
+[      ]*[a-f0-9]+:[   ]*62 74 3c 02 84 c2[    ]+ctestb \{dfv=sf, zf, cf\} dl,r8b
+[      ]*[a-f0-9]+:[   ]*62 d4 35 02 f7 c7 7b 00[      ]+ctestb \{dfv=sf, zf\} r15w,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 b4 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=sf, zf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 24 02 f7 c7 7b 00 00 00[        ]+ctestb \{dfv=sf\} r15d,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 25 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestb \{dfv=sf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 1c 02 f6 c0 7b[         ]+ctestb \{dfv=zf, cf\} r8b,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 9c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=zf, cf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 14 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=zf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 94 02 85 ff[    ]+ctestb \{dfv=zf\} r15,r15
+[      ]*[a-f0-9]+:[   ]*62 d4 84 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 05 02 85 f8[    ]+ctestb \{dfv=\} ax,r15w
+[      ]*[a-f0-9]+:[   ]*62 fc c4 00 f7 c0 7b 00 00 00[        ]+ctesto \{dfv=of\} r16,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 01 f7 c1 7b 00 00 00[        ]+ctestno \{dfv=of\} r17,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 02 f7 c2 7b 00 00 00[        ]+ctestb \{dfv=of\} r18,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 03 f7 c3 7b 00 00 00[        ]+ctestae \{dfv=of\} r19,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 04 f7 c4 7b 00 00 00[        ]+cteste \{dfv=of\} r20,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 05 f7 c5 7b 00 00 00[        ]+ctestne \{dfv=of\} r21,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 06 f7 c6 7b 00 00 00[        ]+ctestbe \{dfv=of\} r22,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 07 f7 c7 7b 00 00 00[        ]+ctesta \{dfv=of\} r23,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 08 f7 c0 7b 00 00 00[        ]+ctests \{dfv=of\} r24,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 09 f7 c1 7b 00 00 00[        ]+ctestns \{dfv=of\} r25,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0a f7 c2 7b 00 00 00[        ]+ctestt \{dfv=of\} r26,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0b f7 c3 7b 00 00 00[        ]+ctestf \{dfv=of\} r27,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0c f7 c4 7b 00 00 00[        ]+ctestl \{dfv=of\} r28,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0d f7 c5 7b 00 00 00[        ]+ctestge \{dfv=of\} r29,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0e f7 c6 7b 00 00 00[        ]+ctestle \{dfv=of\} r30,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f f7 c7 7b 00 00 00[        ]+ctestg \{dfv=of\} r31,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f f7 c7 7b 00 00 00[        ]+ctestg \{dfv=of\} r31,0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 04 0a 39 fa[    ]+ccmpt \{dfv=\} edx,r15d
+[      ]*[a-f0-9]+:[   ]*62 fc 84 0a 83 fa 7b[         ]+ccmpt \{dfv=\} r18,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc 04 0a 80 fa 7b[         ]+ccmpt \{dfv=\} r18b,0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 04 0a 85 fa[    ]+ctestt \{dfv=\} edx,r15d
+[      ]*[a-f0-9]+:[   ]*62 fc 84 0a f7 c2 7b 00 00 00[        ]+ctestt \{dfv=\} r18,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc 04 0a f6 c2 7b[         ]+ctestt \{dfv=\} r18b,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 8c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=cf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 0d 02 39 f8[    ]+ccmpb \{dfv=cf\} ax,r15w
+[      ]*[a-f0-9]+:[   ]*62 54 0c 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=cf\} r15d,DWORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 4d 02 83 ff 7b[         ]+ccmpb \{dfv=of, cf\} r15w,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 4c 02 80 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, cf\} BYTE PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 6d 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, sf, cf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 ec 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf, cf\} QWORD PTR \[r8\+rax\*4\+0x123\],r15
+[      ]*[a-f0-9]+:[   ]*62 d4 7d 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, sf, zf, cf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 fc 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, sf, zf, cf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 74 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, sf, zf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 f4 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf, zf\} QWORD PTR \[r8\+rax\*4\+0x123\],r15
+[      ]*[a-f0-9]+:[   ]*62 d4 e4 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, sf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 64 02 3a 84 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf\} r8b,BYTE PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 5c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, zf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 5c 02 38 84 80 23 01 00 00[     ]+ccmpb \{dfv=of, zf, cf\} BYTE PTR \[r8\+rax\*4\+0x123\],r8b
+[      ]*[a-f0-9]+:[   ]*62 d4 55 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=of, zf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 54 02 38 c2[    ]+ccmpb \{dfv=of, zf\} dl,r8b
+[      ]*[a-f0-9]+:[   ]*62 74 44 02 39 fa[    ]+ccmpb \{dfv=of\} edx,r15d
+[      ]*[a-f0-9]+:[   ]*62 54 45 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=of\} r15w,WORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 2c 02 80 f8 7b[         ]+ccmpb \{dfv=sf, cf\} r8b,0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 2c 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],r15d
+[      ]*[a-f0-9]+:[   ]*62 54 ac 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, cf\} r15,QWORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 3c 02 83 ff 7b[         ]+ccmpb \{dfv=sf, zf, cf\} r15d,0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 3d 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, zf, cf\} r15w,WORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 34 02 83 ff 7b[         ]+ccmpb \{dfv=sf, zf\} r15d,0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 34 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, zf\} DWORD PTR \[r8\+rax\*4\+0x123\],r15d
+[      ]*[a-f0-9]+:[   ]*62 d4 a4 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=sf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 a4 02 39 ff[    ]+ccmpb \{dfv=sf\} r15,r15
+[      ]*[a-f0-9]+:[   ]*62 54 a4 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf\} r15,QWORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 d4 9c 02 83 ff 7b[         ]+ccmpb \{dfv=zf, cf\} r15,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 1c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=zf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 1d 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=zf, cf\} WORD PTR \[r8\+rax\*4\+0x123\],r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 94 02 83 ff 7b[         ]+ccmpb \{dfv=zf\} r15,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 15 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=zf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 15 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=zf\} WORD PTR \[r8\+rax\*4\+0x123\],r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 05 02 83 ff 7b[         ]+ccmpb \{dfv=\} r15w,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 04 02 83 bc 80 23 01 00 00 7b[  ]+ccmpb \{dfv=\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 04 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=\} r15d,DWORD PTR \[r8\+rax\*4\+0x123\]
+[      ]*[a-f0-9]+:[   ]*62 fc c4 00 83 f8 7b[         ]+ccmpo \{dfv=of\} r16,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 01 83 f9 7b[         ]+ccmpno \{dfv=of\} r17,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 02 83 fa 7b[         ]+ccmpb \{dfv=of\} r18,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 03 83 fb 7b[         ]+ccmpae \{dfv=of\} r19,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 04 83 fc 7b[         ]+ccmpe \{dfv=of\} r20,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 05 83 fd 7b[         ]+ccmpne \{dfv=of\} r21,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 06 83 fe 7b[         ]+ccmpbe \{dfv=of\} r22,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 07 83 ff 7b[         ]+ccmpa \{dfv=of\} r23,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 08 83 f8 7b[         ]+ccmps \{dfv=of\} r24,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 09 83 f9 7b[         ]+ccmpns \{dfv=of\} r25,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0a 83 fa 7b[         ]+ccmpt \{dfv=of\} r26,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0b 83 fb 7b[         ]+ccmpf \{dfv=of\} r27,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0c 83 fc 7b[         ]+ccmpl \{dfv=of\} r28,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0d 83 fd 7b[         ]+ccmpge \{dfv=of\} r29,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0e 83 fe 7b[         ]+ccmple \{dfv=of\} r30,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f 83 ff 7b[         ]+ccmpg \{dfv=of\} r31,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 8c 02 f7 c7 7b 00 00 00[        ]+ctestb \{dfv=cf\} r15,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 0d 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestb \{dfv=cf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 4c 02 f6 84 80 23 01 00 00 7b[  ]+ctestb \{dfv=of, cf\} BYTE PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 cc 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, cf\} QWORD PTR \[r8\+rax\*4\+0x123\],r15
+[      ]*[a-f0-9]+:[   ]*62 d4 ec 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=of, sf, cf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 7c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=of, sf, zf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 75 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestb \{dfv=of, sf, zf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 64 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=of, sf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 65 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, sf\} WORD PTR \[r8\+rax\*4\+0x123\],r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 5d 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestb \{dfv=of, zf, cf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 5d 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, zf, cf\} WORD PTR \[r8\+rax\*4\+0x123\],r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 54 02 f6 84 80 23 01 00 00 7b[  ]+ctestb \{dfv=of, zf\} BYTE PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 d4 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, zf\} QWORD PTR \[r8\+rax\*4\+0x123\],r15
+[      ]*[a-f0-9]+:[   ]*62 54 44 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of\} DWORD PTR \[r8\+rax\*4\+0x123\],r15d
+[      ]*[a-f0-9]+:[   ]*62 54 44 02 84 84 80 23 01 00 00[     ]+ctestb \{dfv=of\} BYTE PTR \[r8\+rax\*4\+0x123\],r8b
+[      ]*[a-f0-9]+:[   ]*62 d4 2c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=sf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 2c 02 85 fa[    ]+ctestb \{dfv=sf, cf\} edx,r15d
+[      ]*[a-f0-9]+:[   ]*62 54 3c 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=sf, zf, cf\} DWORD PTR \[r8\+rax\*4\+0x123\],r15d
+[      ]*[a-f0-9]+:[   ]*62 74 3c 02 84 c2[    ]+ctestb \{dfv=sf, zf, cf\} dl,r8b
+[      ]*[a-f0-9]+:[   ]*62 d4 35 02 f7 c7 7b 00[      ]+ctestb \{dfv=sf, zf\} r15w,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 b4 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=sf, zf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 24 02 f7 c7 7b 00 00 00[        ]+ctestb \{dfv=sf\} r15d,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 25 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestb \{dfv=sf\} WORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 1c 02 f6 c0 7b[         ]+ctestb \{dfv=zf, cf\} r8b,0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 9c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=zf, cf\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 d4 14 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=zf\} DWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 54 94 02 85 ff[    ]+ctestb \{dfv=zf\} r15,r15
+[      ]*[a-f0-9]+:[   ]*62 d4 84 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestb \{dfv=\} QWORD PTR \[r8\+rax\*4\+0x123\],0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 05 02 85 f8[    ]+ctestb \{dfv=\} ax,r15w
+[      ]*[a-f0-9]+:[   ]*62 fc c4 00 f7 c0 7b 00 00 00[        ]+ctesto \{dfv=of\} r16,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 01 f7 c1 7b 00 00 00[        ]+ctestno \{dfv=of\} r17,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 02 f7 c2 7b 00 00 00[        ]+ctestb \{dfv=of\} r18,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 03 f7 c3 7b 00 00 00[        ]+ctestae \{dfv=of\} r19,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 04 f7 c4 7b 00 00 00[        ]+cteste \{dfv=of\} r20,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 05 f7 c5 7b 00 00 00[        ]+ctestne \{dfv=of\} r21,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 06 f7 c6 7b 00 00 00[        ]+ctestbe \{dfv=of\} r22,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc c4 07 f7 c7 7b 00 00 00[        ]+ctesta \{dfv=of\} r23,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 08 f7 c0 7b 00 00 00[        ]+ctests \{dfv=of\} r24,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 09 f7 c1 7b 00 00 00[        ]+ctestns \{dfv=of\} r25,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0a f7 c2 7b 00 00 00[        ]+ctestt \{dfv=of\} r26,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0b f7 c3 7b 00 00 00[        ]+ctestf \{dfv=of\} r27,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0c f7 c4 7b 00 00 00[        ]+ctestl \{dfv=of\} r28,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0d f7 c5 7b 00 00 00[        ]+ctestge \{dfv=of\} r29,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0e f7 c6 7b 00 00 00[        ]+ctestle \{dfv=of\} r30,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f f7 c7 7b 00 00 00[        ]+ctestg \{dfv=of\} r31,0x7b
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f f7 c7 7b 00 00 00[        ]+ctestg \{dfv=of\} r31,0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 04 0a 39 fa[    ]+ccmpt \{dfv=\} edx,r15d
+[      ]*[a-f0-9]+:[   ]*62 fc 84 0a 83 fa 7b[         ]+ccmpt \{dfv=\} r18,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc 04 0a 80 fa 7b[         ]+ccmpt \{dfv=\} r18b,0x7b
+[      ]*[a-f0-9]+:[   ]*62 74 04 0a 85 fa[    ]+ctestt \{dfv=\} edx,r15d
+[      ]*[a-f0-9]+:[   ]*62 fc 84 0a f7 c2 7b 00 00 00[        ]+ctestt \{dfv=\} r18,0x7b
+[      ]*[a-f0-9]+:[   ]*62 fc 04 0a f6 c2 7b[         ]+ctestt \{dfv=\} r18b,0x7b

diff --git a/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest-inval.l b/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest-inval.l
new file mode 100644 (file)
index 0000000..44ed710
--- /dev/null
+++ b/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest-inval.l
@@ -0,0 +1,17 @@
+.* Assembler messages:
+.*:[0-9]+: Error: unrecognized oszc flags or illegal `,' in pseudo-suffix
+.*:[0-9]+: Error: unrecognized oszc flags or illegal `,' in pseudo-suffix
+.*:[0-9]+: Error: missing `}' or `,' in pseudo-suffix
+.*:[0-9]+: Error: missing `}' or `,' in pseudo-suffix
+.*:[0-9]+: Error: same oszc flag used twice
+.*:[0-9]+: Error: unrecognized pseudo-suffix
+.*:[0-9]+: Error: unrecognized oszc flags or illegal `,' in pseudo-suffix
+.*:[0-9]+: Error: unrecognized oszc flags or illegal `,' in pseudo-suffix
+.*:[0-9]+: Error: unrecognized oszc flags or illegal `,' in pseudo-suffix
+.*:[0-9]+: Error: no such instruction.*
+.*:[0-9]+: Error: no such instruction.*
+.*:[0-9]+: Error: no such instruction.*
+.*:[0-9]+: Error: no such instruction.*
+.*:[0-9]+: Error: no such instruction.*
+.*:[0-9]+: Error: no such instruction.*
+#pass

diff --git a/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest-inval.s b/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest-inval.s
new file mode 100644 (file)
index 0000000..fd1be34
--- /dev/null
+++ b/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest-inval.s
@@ -0,0 +1,20 @@
+# Check APX_F ccmp ctest instructions with illegal instructions.
+
+       .text
+       ccmpb {dfv=ct} $0x7b,%r18
+       ctestb {dfv=sae} $0x7b,%r18
+       ccmpb {dfv=of $0x7b,%r18
+       ccmpb {dfv=of
+       ccmpb {dfv=cf, cf, of, of} $0x7b,%r18
+       ccmpb {dfv dfv=cf} $0x7b,%r18
+       ccmpb {dfv=cf, ,cf} $0x7b,%r18
+       ccmpb {dfv=cf,,} $0x7b,%r18
+       ccmpb {dfv=,cf} $0x7b,%r18
+       /* SCC insns don't support p/pe and np/po cc.  */
+       ccmpp {dfv=cf} %r15w,%ax
+       ccmppe {dfv=cf} %r15w,%ax
+       ctestnp {dfv=cf} %r15w,%ax
+       ctestpo {dfv=cf} %r15w,%ax
+       /* Normal CC insns don't support t and f.  */
+       sett %r8b
+       setf %r8b

diff --git a/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest.d b/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest.d
new file mode 100644 (file)
index 0000000..0f100f0
--- /dev/null
+++ b/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest.d
@@ -0,0 +1,222 @@
+#as:
+#objdump: -dw
+#name: x86_64 APX_F CCMP and CTEST insns
+#source: x86-64-apx-ccmp-ctest.s
+
+.*: +file format .*
+
+Disassembly of section \.text:
+
+0+ <_start>:
+[      ]*[a-f0-9]+:[   ]*62 d4 8c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbq \{dfv=cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 74 0d 02 39 f8[    ]+ccmpb \{dfv=cf\} %r15w,%ax
+[      ]*[a-f0-9]+:[   ]*62 54 0c 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=cf\}\s+0x123\(%r8,%rax,4\),%r15d
+[      ]*[a-f0-9]+:[   ]*62 d4 4d 02 83 ff 7b[         ]+ccmpb \{dfv=of, cf\}\s+\$0x7b,%r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 4c 02 80 bc 80 23 01 00 00 7b[  ]+ccmpbb \{dfv=of, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 6d 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbw \{dfv=of, sf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 ec 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf, cf\} %r15,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 7d 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbw \{dfv=of, sf, zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 fc 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbq \{dfv=of, sf, zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 74 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbl \{dfv=of, sf, zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 f4 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf, zf\} %r15,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 e4 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbq \{dfv=of, sf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 64 02 3a 84 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf\}\s+0x123\(%r8,%rax,4\),%r8b
+[      ]*[a-f0-9]+:[   ]*62 d4 5c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbl \{dfv=of, zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 5c 02 38 84 80 23 01 00 00[     ]+ccmpb \{dfv=of, zf, cf\} %r8b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 55 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbw \{dfv=of, zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 74 54 02 38 c2[    ]+ccmpb \{dfv=of, zf\} %r8b,%dl
+[      ]*[a-f0-9]+:[   ]*62 74 44 02 39 fa[    ]+ccmpb \{dfv=of\} %r15d,%edx
+[      ]*[a-f0-9]+:[   ]*62 54 45 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=of\}\s+0x123\(%r8,%rax,4\),%r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 2c 02 80 f8 7b[         ]+ccmpb \{dfv=sf, cf\}\s+\$0x7b,%r8b
+[      ]*[a-f0-9]+:[   ]*62 54 2c 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, cf\} %r15d,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 ac 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, cf\}\s+0x123\(%r8,%rax,4\),%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 3c 02 83 ff 7b[         ]+ccmpb \{dfv=sf, zf, cf\}\s+\$0x7b,%r15d
+[      ]*[a-f0-9]+:[   ]*62 54 3d 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, zf, cf\}\s+0x123\(%r8,%rax,4\),%r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 34 02 83 ff 7b[         ]+ccmpb \{dfv=sf, zf\}\s+\$0x7b,%r15d
+[      ]*[a-f0-9]+:[   ]*62 54 34 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, zf\} %r15d,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 a4 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbq \{dfv=sf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 a4 02 39 ff[    ]+ccmpb \{dfv=sf\} %r15,%r15
+[      ]*[a-f0-9]+:[   ]*62 54 a4 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf\}\s+0x123\(%r8,%rax,4\),%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 9c 02 83 ff 7b[         ]+ccmpb \{dfv=zf, cf\}\s+\$0x7b,%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 1c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbl \{dfv=zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 1d 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=zf, cf\} %r15w,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 94 02 83 ff 7b[         ]+ccmpb \{dfv=zf\}\s+\$0x7b,%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 15 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbw \{dfv=zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 15 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=zf\} %r15w,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 05 02 83 ff 7b[         ]+ccmpb \{dfv=\}\s+\$0x7b,%r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 04 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbl \{dfv=\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 04 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=\}\s+0x123\(%r8,%rax,4\),%r15d
+[      ]*[a-f0-9]+:[   ]*62 fc c4 00 83 f8 7b[         ]+ccmpo \{dfv=of\} \$0x7b,%r16
+[      ]*[a-f0-9]+:[   ]*62 fc c4 01 83 f9 7b[         ]+ccmpno \{dfv=of\} \$0x7b,%r17
+[      ]*[a-f0-9]+:[   ]*62 fc c4 02 83 fa 7b[         ]+ccmpb \{dfv=of\} \$0x7b,%r18
+[      ]*[a-f0-9]+:[   ]*62 fc c4 03 83 fb 7b[         ]+ccmpae \{dfv=of\} \$0x7b,%r19
+[      ]*[a-f0-9]+:[   ]*62 fc c4 04 83 fc 7b[         ]+ccmpe \{dfv=of\} \$0x7b,%r20
+[      ]*[a-f0-9]+:[   ]*62 fc c4 05 83 fd 7b[         ]+ccmpne \{dfv=of\} \$0x7b,%r21
+[      ]*[a-f0-9]+:[   ]*62 fc c4 06 83 fe 7b[         ]+ccmpbe \{dfv=of\} \$0x7b,%r22
+[      ]*[a-f0-9]+:[   ]*62 fc c4 07 83 ff 7b[         ]+ccmpa \{dfv=of\} \$0x7b,%r23
+[      ]*[a-f0-9]+:[   ]*62 dc c4 08 83 f8 7b[         ]+ccmps \{dfv=of\} \$0x7b,%r24
+[      ]*[a-f0-9]+:[   ]*62 dc c4 09 83 f9 7b[         ]+ccmpns \{dfv=of\} \$0x7b,%r25
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0a 83 fa 7b[         ]+ccmpt \{dfv=of\} \$0x7b,%r26
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0b 83 fb 7b[         ]+ccmpf \{dfv=of\} \$0x7b,%r27
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0c 83 fc 7b[         ]+ccmpl \{dfv=of\} \$0x7b,%r28
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0d 83 fd 7b[         ]+ccmpge \{dfv=of\} \$0x7b,%r29
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0e 83 fe 7b[         ]+ccmple \{dfv=of\} \$0x7b,%r30
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f 83 ff 7b[         ]+ccmpg \{dfv=of\} \$0x7b,%r31
+[      ]*[a-f0-9]+:[   ]*62 d4 8c 02 f7 c7 7b 00 00 00[        ]+ctestb \{dfv=cf\}\s+\$0x7b,%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 0d 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestbw \{dfv=cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 4c 02 f6 84 80 23 01 00 00 7b[  ]+ctestbb \{dfv=of, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 cc 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, cf\} %r15,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 ec 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbq \{dfv=of, sf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 7c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbl \{dfv=of, sf, zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 75 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestbw \{dfv=of, sf, zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 64 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbl \{dfv=of, sf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 65 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, sf\} %r15w,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 5d 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestbw \{dfv=of, zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 5d 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, zf, cf\} %r15w,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 54 02 f6 84 80 23 01 00 00 7b[  ]+ctestbb \{dfv=of, zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 d4 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, zf\} %r15,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 44 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of\} %r15d,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 44 02 84 84 80 23 01 00 00[     ]+ctestb \{dfv=of\} %r8b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 2c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbl \{dfv=sf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 74 2c 02 85 fa[    ]+ctestb \{dfv=sf, cf\} %r15d,%edx
+[      ]*[a-f0-9]+:[   ]*62 54 3c 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=sf, zf, cf\} %r15d,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 74 3c 02 84 c2[    ]+ctestb \{dfv=sf, zf, cf\} %r8b,%dl
+[      ]*[a-f0-9]+:[   ]*62 d4 35 02 f7 c7 7b 00[      ]+ctestb \{dfv=sf, zf\}\s+\$0x7b,%r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 b4 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbq \{dfv=sf, zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 24 02 f7 c7 7b 00 00 00[        ]+ctestb \{dfv=sf\}\s+\$0x7b,%r15d
+[      ]*[a-f0-9]+:[   ]*62 d4 25 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestbw \{dfv=sf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 1c 02 f6 c0 7b[         ]+ctestb \{dfv=zf, cf\}\s+\$0x7b,%r8b
+[      ]*[a-f0-9]+:[   ]*62 d4 9c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbq \{dfv=zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 14 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbl \{dfv=zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 94 02 85 ff[    ]+ctestb \{dfv=zf\} %r15,%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 84 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbq \{dfv=\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 74 05 02 85 f8[    ]+ctestb \{dfv=\} %r15w,%ax
+[      ]*[a-f0-9]+:[   ]*62 fc c4 00 f7 c0 7b 00 00 00[        ]+ctesto \{dfv=of\} \$0x7b,%r16
+[      ]*[a-f0-9]+:[   ]*62 fc c4 01 f7 c1 7b 00 00 00[        ]+ctestno \{dfv=of\} \$0x7b,%r17
+[      ]*[a-f0-9]+:[   ]*62 fc c4 02 f7 c2 7b 00 00 00[        ]+ctestb \{dfv=of\} \$0x7b,%r18
+[      ]*[a-f0-9]+:[   ]*62 fc c4 03 f7 c3 7b 00 00 00[        ]+ctestae \{dfv=of\} \$0x7b,%r19
+[      ]*[a-f0-9]+:[   ]*62 fc c4 04 f7 c4 7b 00 00 00[        ]+cteste \{dfv=of\} \$0x7b,%r20
+[      ]*[a-f0-9]+:[   ]*62 fc c4 05 f7 c5 7b 00 00 00[        ]+ctestne \{dfv=of\} \$0x7b,%r21
+[      ]*[a-f0-9]+:[   ]*62 fc c4 06 f7 c6 7b 00 00 00[        ]+ctestbe \{dfv=of\} \$0x7b,%r22
+[      ]*[a-f0-9]+:[   ]*62 fc c4 07 f7 c7 7b 00 00 00[        ]+ctesta \{dfv=of\} \$0x7b,%r23
+[      ]*[a-f0-9]+:[   ]*62 dc c4 08 f7 c0 7b 00 00 00[        ]+ctests \{dfv=of\} \$0x7b,%r24
+[      ]*[a-f0-9]+:[   ]*62 dc c4 09 f7 c1 7b 00 00 00[        ]+ctestns \{dfv=of\} \$0x7b,%r25
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0a f7 c2 7b 00 00 00[        ]+ctestt \{dfv=of\} \$0x7b,%r26
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0b f7 c3 7b 00 00 00[        ]+ctestf \{dfv=of\} \$0x7b,%r27
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0c f7 c4 7b 00 00 00[        ]+ctestl \{dfv=of\} \$0x7b,%r28
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0d f7 c5 7b 00 00 00[        ]+ctestge \{dfv=of\} \$0x7b,%r29
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0e f7 c6 7b 00 00 00[        ]+ctestle \{dfv=of\} \$0x7b,%r30
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f f7 c7 7b 00 00 00[        ]+ctestg \{dfv=of\} \$0x7b,%r31
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f f7 c7 7b 00 00 00[        ]+ctestg \{dfv=of\} \$0x7b,%r31
+[      ]*[a-f0-9]+:[   ]*62 74 04 0a 39 fa[    ]+ccmpt \{dfv=\} %r15d,%edx
+[      ]*[a-f0-9]+:[   ]*62 fc 84 0a 83 fa 7b[         ]+ccmpt \{dfv=\} \$0x7b,%r18
+[      ]*[a-f0-9]+:[   ]*62 fc 04 0a 80 fa 7b[         ]+ccmpt \{dfv=\} \$0x7b,%r18b
+[      ]*[a-f0-9]+:[   ]*62 74 04 0a 85 fa[    ]+ctestt \{dfv=\} \%r15d,%edx
+[      ]*[a-f0-9]+:[   ]*62 fc 84 0a f7 c2 7b 00 00 00[        ]+ctestt \{dfv=\} \$0x7b,%r18
+[      ]*[a-f0-9]+:[   ]*62 fc 04 0a f6 c2 7b[         ]+ctestt \{dfv=\} \$0x7b,%r18b
+[      ]*[a-f0-9]+:[   ]*62 d4 8c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbq \{dfv=cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 74 0d 02 39 f8[    ]+ccmpb \{dfv=cf\} %r15w,%ax
+[      ]*[a-f0-9]+:[   ]*62 54 0c 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=cf\}\s+0x123\(%r8,%rax,4\),%r15d
+[      ]*[a-f0-9]+:[   ]*62 d4 4d 02 83 ff 7b[         ]+ccmpb \{dfv=of, cf\}\s+\$0x7b,%r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 4c 02 80 bc 80 23 01 00 00 7b[  ]+ccmpbb \{dfv=of, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 6d 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbw \{dfv=of, sf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 ec 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf, cf\} %r15,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 7d 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbw \{dfv=of, sf, zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 fc 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbq \{dfv=of, sf, zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 74 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbl \{dfv=of, sf, zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 f4 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf, zf\} %r15,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 e4 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbq \{dfv=of, sf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 64 02 3a 84 80 23 01 00 00[     ]+ccmpb \{dfv=of, sf\}\s+0x123\(%r8,%rax,4\),%r8b
+[      ]*[a-f0-9]+:[   ]*62 d4 5c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbl \{dfv=of, zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 5c 02 38 84 80 23 01 00 00[     ]+ccmpb \{dfv=of, zf, cf\} %r8b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 55 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbw \{dfv=of, zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 74 54 02 38 c2[    ]+ccmpb \{dfv=of, zf\} %r8b,%dl
+[      ]*[a-f0-9]+:[   ]*62 74 44 02 39 fa[    ]+ccmpb \{dfv=of\} %r15d,%edx
+[      ]*[a-f0-9]+:[   ]*62 54 45 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=of\}\s+0x123\(%r8,%rax,4\),%r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 2c 02 80 f8 7b[         ]+ccmpb \{dfv=sf, cf\}\s+\$0x7b,%r8b
+[      ]*[a-f0-9]+:[   ]*62 54 2c 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, cf\} %r15d,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 ac 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, cf\}\s+0x123\(%r8,%rax,4\),%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 3c 02 83 ff 7b[         ]+ccmpb \{dfv=sf, zf, cf\}\s+\$0x7b,%r15d
+[      ]*[a-f0-9]+:[   ]*62 54 3d 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, zf, cf\}\s+0x123\(%r8,%rax,4\),%r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 34 02 83 ff 7b[         ]+ccmpb \{dfv=sf, zf\}\s+\$0x7b,%r15d
+[      ]*[a-f0-9]+:[   ]*62 54 34 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf, zf\} %r15d,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 a4 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbq \{dfv=sf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 a4 02 39 ff[    ]+ccmpb \{dfv=sf\} %r15,%r15
+[      ]*[a-f0-9]+:[   ]*62 54 a4 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=sf\}\s+0x123\(%r8,%rax,4\),%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 9c 02 83 ff 7b[         ]+ccmpb \{dfv=zf, cf\}\s+\$0x7b,%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 1c 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbl \{dfv=zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 1d 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=zf, cf\} %r15w,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 94 02 83 ff 7b[         ]+ccmpb \{dfv=zf\}\s+\$0x7b,%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 15 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbw \{dfv=zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 15 02 39 bc 80 23 01 00 00[     ]+ccmpb \{dfv=zf\} %r15w,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 05 02 83 ff 7b[         ]+ccmpb \{dfv=\}\s+\$0x7b,%r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 04 02 83 bc 80 23 01 00 00 7b[  ]+ccmpbl \{dfv=\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 04 02 3b bc 80 23 01 00 00[     ]+ccmpb \{dfv=\}\s+0x123\(%r8,%rax,4\),%r15d
+[      ]*[a-f0-9]+:[   ]*62 fc c4 00 83 f8 7b[         ]+ccmpo \{dfv=of\} \$0x7b,%r16
+[      ]*[a-f0-9]+:[   ]*62 fc c4 01 83 f9 7b[         ]+ccmpno \{dfv=of\} \$0x7b,%r17
+[      ]*[a-f0-9]+:[   ]*62 fc c4 02 83 fa 7b[         ]+ccmpb \{dfv=of\} \$0x7b,%r18
+[      ]*[a-f0-9]+:[   ]*62 fc c4 03 83 fb 7b[         ]+ccmpae \{dfv=of\} \$0x7b,%r19
+[      ]*[a-f0-9]+:[   ]*62 fc c4 04 83 fc 7b[         ]+ccmpe \{dfv=of\} \$0x7b,%r20
+[      ]*[a-f0-9]+:[   ]*62 fc c4 05 83 fd 7b[         ]+ccmpne \{dfv=of\} \$0x7b,%r21
+[      ]*[a-f0-9]+:[   ]*62 fc c4 06 83 fe 7b[         ]+ccmpbe \{dfv=of\} \$0x7b,%r22
+[      ]*[a-f0-9]+:[   ]*62 fc c4 07 83 ff 7b[         ]+ccmpa \{dfv=of\} \$0x7b,%r23
+[      ]*[a-f0-9]+:[   ]*62 dc c4 08 83 f8 7b[         ]+ccmps \{dfv=of\} \$0x7b,%r24
+[      ]*[a-f0-9]+:[   ]*62 dc c4 09 83 f9 7b[         ]+ccmpns \{dfv=of\} \$0x7b,%r25
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0a 83 fa 7b[         ]+ccmpt \{dfv=of\} \$0x7b,%r26
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0b 83 fb 7b[         ]+ccmpf \{dfv=of\} \$0x7b,%r27
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0c 83 fc 7b[         ]+ccmpl \{dfv=of\} \$0x7b,%r28
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0d 83 fd 7b[         ]+ccmpge \{dfv=of\} \$0x7b,%r29
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0e 83 fe 7b[         ]+ccmple \{dfv=of\} \$0x7b,%r30
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f 83 ff 7b[         ]+ccmpg \{dfv=of\} \$0x7b,%r31
+[      ]*[a-f0-9]+:[   ]*62 d4 8c 02 f7 c7 7b 00 00 00[        ]+ctestb \{dfv=cf\}\s+\$0x7b,%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 0d 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestbw \{dfv=cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 4c 02 f6 84 80 23 01 00 00 7b[  ]+ctestbb \{dfv=of, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 cc 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, cf\} %r15,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 ec 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbq \{dfv=of, sf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 7c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbl \{dfv=of, sf, zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 75 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestbw \{dfv=of, sf, zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 64 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbl \{dfv=of, sf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 65 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, sf\} %r15w,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 5d 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestbw \{dfv=of, zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 5d 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, zf, cf\} %r15w,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 54 02 f6 84 80 23 01 00 00 7b[  ]+ctestbb \{dfv=of, zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 d4 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of, zf\} %r15,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 44 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=of\} %r15d,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 44 02 84 84 80 23 01 00 00[     ]+ctestb \{dfv=of\} %r8b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 2c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbl \{dfv=sf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 74 2c 02 85 fa[    ]+ctestb \{dfv=sf, cf\} %r15d,%edx
+[      ]*[a-f0-9]+:[   ]*62 54 3c 02 85 bc 80 23 01 00 00[     ]+ctestb \{dfv=sf, zf, cf\} %r15d,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 74 3c 02 84 c2[    ]+ctestb \{dfv=sf, zf, cf\} %r8b,%dl
+[      ]*[a-f0-9]+:[   ]*62 d4 35 02 f7 c7 7b 00[      ]+ctestb \{dfv=sf, zf\}\s+\$0x7b,%r15w
+[      ]*[a-f0-9]+:[   ]*62 d4 b4 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbq \{dfv=sf, zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 24 02 f7 c7 7b 00 00 00[        ]+ctestb \{dfv=sf\}\s+\$0x7b,%r15d
+[      ]*[a-f0-9]+:[   ]*62 d4 25 02 f7 84 80 23 01 00 00 7b 00[       ]+ctestbw \{dfv=sf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 1c 02 f6 c0 7b[         ]+ctestb \{dfv=zf, cf\}\s+\$0x7b,%r8b
+[      ]*[a-f0-9]+:[   ]*62 d4 9c 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbq \{dfv=zf, cf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 d4 14 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbl \{dfv=zf\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 54 94 02 85 ff[    ]+ctestb \{dfv=zf\} %r15,%r15
+[      ]*[a-f0-9]+:[   ]*62 d4 84 02 f7 84 80 23 01 00 00 7b 00 00 00[         ]+ctestbq \{dfv=\}\s+\$0x7b,0x123\(%r8,%rax,4\)
+[      ]*[a-f0-9]+:[   ]*62 74 05 02 85 f8[    ]+ctestb \{dfv=\} %r15w,%ax
+[      ]*[a-f0-9]+:[   ]*62 fc c4 00 f7 c0 7b 00 00 00[        ]+ctesto \{dfv=of\} \$0x7b,%r16
+[      ]*[a-f0-9]+:[   ]*62 fc c4 01 f7 c1 7b 00 00 00[        ]+ctestno \{dfv=of\} \$0x7b,%r17
+[      ]*[a-f0-9]+:[   ]*62 fc c4 02 f7 c2 7b 00 00 00[        ]+ctestb \{dfv=of\} \$0x7b,%r18
+[      ]*[a-f0-9]+:[   ]*62 fc c4 03 f7 c3 7b 00 00 00[        ]+ctestae \{dfv=of\} \$0x7b,%r19
+[      ]*[a-f0-9]+:[   ]*62 fc c4 04 f7 c4 7b 00 00 00[        ]+cteste \{dfv=of\} \$0x7b,%r20
+[      ]*[a-f0-9]+:[   ]*62 fc c4 05 f7 c5 7b 00 00 00[        ]+ctestne \{dfv=of\} \$0x7b,%r21
+[      ]*[a-f0-9]+:[   ]*62 fc c4 06 f7 c6 7b 00 00 00[        ]+ctestbe \{dfv=of\} \$0x7b,%r22
+[      ]*[a-f0-9]+:[   ]*62 fc c4 07 f7 c7 7b 00 00 00[        ]+ctesta \{dfv=of\} \$0x7b,%r23
+[      ]*[a-f0-9]+:[   ]*62 dc c4 08 f7 c0 7b 00 00 00[        ]+ctests \{dfv=of\} \$0x7b,%r24
+[      ]*[a-f0-9]+:[   ]*62 dc c4 09 f7 c1 7b 00 00 00[        ]+ctestns \{dfv=of\} \$0x7b,%r25
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0a f7 c2 7b 00 00 00[        ]+ctestt \{dfv=of\} \$0x7b,%r26
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0b f7 c3 7b 00 00 00[        ]+ctestf \{dfv=of\} \$0x7b,%r27
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0c f7 c4 7b 00 00 00[        ]+ctestl \{dfv=of\} \$0x7b,%r28
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0d f7 c5 7b 00 00 00[        ]+ctestge \{dfv=of\} \$0x7b,%r29
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0e f7 c6 7b 00 00 00[        ]+ctestle \{dfv=of\} \$0x7b,%r30
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f f7 c7 7b 00 00 00[        ]+ctestg \{dfv=of\} \$0x7b,%r31
+[      ]*[a-f0-9]+:[   ]*62 dc c4 0f f7 c7 7b 00 00 00[        ]+ctestg \{dfv=of\} \$0x7b,%r31
+[      ]*[a-f0-9]+:[   ]*62 74 04 0a 39 fa[    ]+ccmpt \{dfv=\} %r15d,%edx
+[      ]*[a-f0-9]+:[   ]*62 fc 84 0a 83 fa 7b[         ]+ccmpt \{dfv=\} \$0x7b,%r18
+[      ]*[a-f0-9]+:[   ]*62 fc 04 0a 80 fa 7b[         ]+ccmpt \{dfv=\} \$0x7b,%r18b
+[      ]*[a-f0-9]+:[   ]*62 74 04 0a 85 fa[    ]+ctestt \{dfv=\} \%r15d,%edx
+[      ]*[a-f0-9]+:[   ]*62 fc 84 0a f7 c2 7b 00 00 00[        ]+ctestt \{dfv=\} \$0x7b,%r18
+[      ]*[a-f0-9]+:[   ]*62 fc 04 0a f6 c2 7b[         ]+ctestt \{dfv=\} \$0x7b,%r18b

diff --git a/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest.s b/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest.s
new file mode 100644 (file)
index 0000000..66bf224
--- /dev/null
+++ b/gas/testsuite/gas/i386/x86-64-apx-ccmp-ctest.s
@@ -0,0 +1,218 @@
+# Check 64bit APX_F CCMP and CTEST instructions
+
+ .text
+_start:
+       ccmpbq   {dfv=cf} $0x7b,0x123(%r8,%rax,4)
+       ccmpb    {dfv=cf} %r15w,%ax
+       ccmpb    {dfv=cf} 0x123(%r8,%rax,4),%r15d
+       ccmpb    {dfv=of, cf} $0x7b,%r15w
+       ccmpbb   {dfv=of, cf} $0x7b,0x123(%r8,%rax,4)
+       ccmpbw   {dfv=of, sf, cf} $0x7b,0x123(%r8,%rax,4)
+       ccmpb    {dfv=of, sf, cf} %r15,0x123(%r8,%rax,4)
+       ccmpbw   {dfv=of, sf, zf, cf} $0x7b,0x123(%r8,%rax,4)
+       ccmpbq   {dfv=of, sf, zf, cf} $0x7b,0x123(%r8,%rax,4)
+       ccmpbl   {dfv=of, sf, zf} $0x7b,0x123(%r8,%rax,4)
+       ccmpb    {dfv=of, sf, zf} %r15,0x123(%r8,%rax,4)
+       ccmpbq   {dfv=of, sf} $0x7b,0x123(%r8,%rax,4)
+       ccmpb    {dfv=of, sf} 0x123(%r8,%rax,4),%r8b
+       ccmpbl   {dfv=of, zf, cf} $0x7b,0x123(%r8,%rax,4)
+       ccmpb    {dfv=of, zf, cf} %r8b,0x123(%r8,%rax,4)
+       ccmpbw   {dfv=of, zf} $0x7b,0x123(%r8,%rax,4)
+       ccmpb    {dfv=of, zf} %r8b,%dl
+       ccmpb    {dfv=of} %r15d,%edx
+       ccmpb    {dfv=of} 0x123(%r8,%rax,4),%r15w
+       ccmpb    {dfv=sf, cf} $0x7b,%r8b
+       ccmpb    {dfv=sf, cf} %r15d,0x123(%r8,%rax,4)
+       ccmpb    {dfv=sf, cf} 0x123(%r8,%rax,4),%r15
+       ccmpb    {dfv=sf, zf, cf} $0x7b,%r15d
+       ccmpb    {dfv=sf, zf, cf} 0x123(%r8,%rax,4),%r15w
+       ccmpb    {dfv=sf, zf} $0x7b,%r15d
+       ccmpb    {dfv=sf, zf} %r15d,0x123(%r8,%rax,4)
+       ccmpbq   {dfv=sf} $0x7b,0x123(%r8,%rax,4)
+       ccmpb    {dfv=sf} %r15,%r15
+       ccmpb    {dfv=sf} 0x123(%r8,%rax,4),%r15
+       ccmpb    {dfv=zf, cf} $0x7b,%r15
+       ccmpbl   {dfv=zf, cf} $0x7b,0x123(%r8,%rax,4)
+       ccmpb    {dfv=zf, cf} %r15w,0x123(%r8,%rax,4)
+       ccmpb    {dfv=zf} $0x7b,%r15
+       ccmpbw   {dfv=zf} $0x7b,0x123(%r8,%rax,4)
+       ccmpb    {dfv=zf} %r15w,0x123(%r8,%rax,4)
+       ccmpb    {dfv=} $0x7b,%r15w
+       ccmpbl   {dfv=} $0x7b,0x123(%r8,%rax,4)
+       ccmpb    {dfv=} 0x123(%r8,%rax,4),%r15d
+       ccmpo    {dfv=of} $0x7b,%r16
+       ccmpno   {dfv=of} $0x7b,%r17
+       ccmpb    {dfv=of} $0x7b,%r18
+       ccmpae   {dfv=of} $0x7b,%r19
+       ccmpe    {dfv=of} $0x7b,%r20
+       ccmpne   {dfv=of} $0x7b,%r21
+       ccmpbe   {dfv=of} $0x7b,%r22
+       ccmpa    {dfv=of} $0x7b,%r23
+       ccmps    {dfv=of} $0x7b,%r24
+       ccmpns   {dfv=of} $0x7b,%r25
+       ccmpt    {dfv=of} $0x7b,%r26
+       ccmpf    {dfv=of} $0x7b,%r27
+       ccmpl    {dfv=of} $0x7b,%r28
+       ccmpge   {dfv=of} $0x7b,%r29
+       ccmple   {dfv=of} $0x7b,%r30
+       ccmpg    {dfv=of} $0x7b,%r31
+       ctestb   {dfv=cf} $0x7b,%r15
+       ctestbw  {dfv=cf} $0x7b,0x123(%r8,%rax,4)
+       ctestbb  {dfv=of, cf} $0x7b,0x123(%r8,%rax,4)
+       ctestb   {dfv=of, cf} %r15,0x123(%r8,%rax,4)
+       ctestbq  {dfv=of, sf, cf} $0x7b,0x123(%r8,%rax,4)
+       ctestbl  {dfv=of, sf, zf, cf} $0x7b,0x123(%r8,%rax,4)
+       ctestbw  {dfv=of, sf, zf} $0x7b,0x123(%r8,%rax,4)
+       ctestbl  {dfv=of, sf} $0x7b,0x123(%r8,%rax,4)
+       ctestb   {dfv=of, sf} %r15w,0x123(%r8,%rax,4)
+       ctestbw  {dfv=of, zf, cf} $0x7b,0x123(%r8,%rax,4)
+       ctestb   {dfv=of, zf, cf} %r15w,0x123(%r8,%rax,4)
+       ctestbb  {dfv=of, zf} $0x7b,0x123(%r8,%rax,4)
+       ctestb   {dfv=of, zf} %r15,0x123(%r8,%rax,4)
+       ctestb   {dfv=of} %r15d,0x123(%r8,%rax,4)
+       ctestb   {dfv=of} %r8b,0x123(%r8,%rax,4)
+       ctestbl  {dfv=sf, cf} $0x7b,0x123(%r8,%rax,4)
+       ctestb   {dfv=sf, cf} %r15d,%edx
+       ctestb   {dfv=sf, zf, cf} %r15d,0x123(%r8,%rax,4)
+       ctestb   {dfv=sf, zf, cf} %r8b,%dl
+       ctestb   {dfv=sf, zf} $0x7b,%r15w
+       ctestbq  {dfv=sf, zf} $0x7b,0x123(%r8,%rax,4)
+       ctestb   {dfv=sf} $0x7b,%r15d
+       ctestbw  {dfv=sf} $0x7b,0x123(%r8,%rax,4)
+       ctestb   {dfv=zf, cf} $0x7b,%r8b
+       ctestbq  {dfv=zf, cf} $0x7b,0x123(%r8,%rax,4)
+       ctestbl  {dfv=zf} $0x7b,0x123(%r8,%rax,4)
+       ctestb   {dfv=zf} %r15,%r15
+       ctestbq  {dfv=} $0x7b,0x123(%r8,%rax,4)
+       ctestb   {dfv=} %r15w,%ax
+       ctesto   {dfv=of} $0x7b,%r16
+       ctestno  {dfv=of} $0x7b,%r17
+       ctestb   {dfv=of} $0x7b,%r18
+       ctestnb  {dfv=of} $0x7b,%r19
+       ctestz   {dfv=of} $0x7b,%r20
+       ctestnz  {dfv=of} $0x7b,%r21
+       ctestbe  {dfv=of} $0x7b,%r22
+       ctestnbe {dfv=of} $0x7b,%r23
+       ctests   {dfv=of} $0x7b,%r24
+       ctestns  {dfv=of} $0x7b,%r25
+       ctestt   {dfv=of} $0x7b,%r26
+       ctestf   {dfv=of} $0x7b,%r27
+       ctestl   {dfv=of} $0x7b,%r28
+       ctestnl  {dfv=of} $0x7b,%r29
+       ctestle  {dfv=of} $0x7b,%r30
+       ctestnle {dfv=of} $0x7b,%r31
+       CTESTNLE {DFV=OF} $0x7b,%r31
+       {evex} cmp %r15d,%edx
+       {evex} cmp $0x7b,%r18
+       {evex} cmp $0x7b,%r18b
+       {evex} test %r15d,%edx
+       {evex} test $0x7b,%r18
+       {evex} test $0x7b,%r18b
+
+       .intel_syntax noprefix
+       ccmpb    {dfv=cf} QWORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=cf} ax,r15w
+       ccmpb    {dfv=cf} r15d,DWORD PTR [r8+rax*4+0x123]
+       ccmpb    {dfv=of, cf} r15w,0x7b
+       ccmpb    {dfv=of, cf} BYTE PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=of, sf, cf} WORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=of, sf, cf} QWORD PTR [r8+rax*4+0x123],r15
+       ccmpb    {dfv=of, sf, zf, cf} WORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=of, sf, zf, cf} QWORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=of, sf, zf} DWORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=of, sf, zf} QWORD PTR [r8+rax*4+0x123],r15
+       ccmpb    {dfv=of, sf} QWORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=of, sf} r8b,BYTE PTR [r8+rax*4+0x123]
+       ccmpb    {dfv=of, zf, cf} DWORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=of, zf, cf} BYTE PTR [r8+rax*4+0x123],r8b
+       ccmpb    {dfv=of, zf} WORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=of, zf} dl,r8b
+       ccmpb    {dfv=of} edx,r15d
+       ccmpb    {dfv=of} r15w,WORD PTR [r8+rax*4+0x123]
+       ccmpb    {dfv=sf, cf} r8b,0x7b
+       ccmpb    {dfv=sf, cf} DWORD PTR [r8+rax*4+0x123],r15d
+       ccmpb    {dfv=sf, cf} r15,QWORD PTR [r8+rax*4+0x123]
+       ccmpb    {dfv=sf, zf, cf} r15d,0x7b
+       ccmpb    {dfv=sf, zf, cf} r15w,WORD PTR [r8+rax*4+0x123]
+       ccmpb    {dfv=sf, zf} r15d,0x7b
+       ccmpb    {dfv=sf, zf} DWORD PTR [r8+rax*4+0x123],r15d
+       ccmpb    {dfv=sf} QWORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=sf} r15,r15
+       ccmpb    {dfv=sf} r15,QWORD PTR [r8+rax*4+0x123]
+       ccmpb    {dfv=zf, cf} r15,0x7b
+       ccmpb    {dfv=zf, cf} DWORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=zf, cf} WORD PTR [r8+rax*4+0x123],r15w
+       ccmpb    {dfv=zf} r15,0x7b
+       ccmpb    {dfv=zf} WORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=zf} WORD PTR [r8+rax*4+0x123],r15w
+       ccmpb    {dfv=} r15w,0x7b
+       ccmpb    {dfv=} DWORD PTR [r8+rax*4+0x123],0x7b
+       ccmpb    {dfv=} r15d,DWORD PTR [r8+rax*4+0x123]
+       ccmpo    {dfv=of} r16,0x7b
+       ccmpno   {dfv=of} r17,0x7b
+       ccmpb    {dfv=of} r18,0x7b
+       ccmpae   {dfv=of} r19,0x7b
+       ccmpe    {dfv=of} r20,0x7b
+       ccmpne   {dfv=of} r21,0x7b
+       ccmpbe   {dfv=of} r22,0x7b
+       ccmpa    {dfv=of} r23,0x7b
+       ccmps    {dfv=of} r24,0x7b
+       ccmpns   {dfv=of} r25,0x7b
+       ccmpt    {dfv=of} r26,0x7b
+       ccmpf    {dfv=of} r27,0x7b
+       ccmpl    {dfv=of} r28,0x7b
+       ccmpge   {dfv=of} r29,0x7b
+       ccmple   {dfv=of} r30,0x7b
+       ccmpg    {dfv=of} r31,0x7b
+       ctestb   {dfv=cf} r15,0x7b
+       ctestb   {dfv=cf} WORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=of, cf} BYTE PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=of, cf} QWORD PTR [r8+rax*4+0x123],r15
+       ctestb   {dfv=of, sf, cf} QWORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=of, sf, zf, cf} DWORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=of, sf, zf} WORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=of, sf} DWORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=of, sf} WORD PTR [r8+rax*4+0x123],r15w
+       ctestb   {dfv=of, zf, cf} WORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=of, zf, cf} WORD PTR [r8+rax*4+0x123],r15w
+       ctestb   {dfv=of, zf} BYTE PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=of, zf} QWORD PTR [r8+rax*4+0x123],r15
+       ctestb   {dfv=of} DWORD PTR [r8+rax*4+0x123],r15d
+       ctestb   {dfv=of} BYTE PTR [r8+rax*4+0x123],r8b
+       ctestb   {dfv=sf, cf} DWORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=sf, cf} edx,r15d
+       ctestb   {dfv=sf, zf, cf} DWORD PTR [r8+rax*4+0x123],r15d
+       ctestb   {dfv=sf, zf, cf} dl,r8b
+       ctestb   {dfv=sf, zf} r15w,0x7b
+       ctestb   {dfv=sf, zf} QWORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=sf} r15d,0x7b
+       ctestb   {dfv=sf} WORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=zf, cf} r8b,0x7b
+       ctestb   {dfv=zf, cf} QWORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=zf} DWORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=zf} r15,r15
+       ctestb   {dfv=} QWORD PTR [r8+rax*4+0x123],0x7b
+       ctestb   {dfv=} ax,r15w
+       ctesto   {dfv=of} r16,0x7b
+       ctestno  {dfv=of} r17,0x7b
+       ctestb   {dfv=of} r18,0x7b
+       ctestnb  {dfv=of} r19,0x7b
+       ctestz   {dfv=of} r20,0x7b
+       ctestnz  {dfv=of} r21,0x7b
+       ctestbe  {dfv=of} r22,0x7b
+       ctestnbe {dfv=of} r23,0x7b
+       ctests   {dfv=of} r24,0x7b
+       ctestns  {dfv=of} r25,0x7b
+       ctestt   {dfv=of} r26,0x7b
+       ctestf   {dfv=of} r27,0x7b
+       ctestl   {dfv=of} r28,0x7b
+       ctestnl  {dfv=of} r29,0x7b
+       ctestle  {dfv=of} r30,0x7b
+       ctestnle {dfv=of} r31,0x7b
+        CTESTNLE {DFV=OF} r31,0x7b
+       {evex} cmp  edx, r15d
+       {evex} cmp  r18, 0x7b
+       {evex} cmp  r18b, 0x7b
+       {evex} test  edx, r15d
+       {evex} test  r18, 0x7b
+       {evex} test  r18b, 0x7b

diff --git a/gas/testsuite/gas/i386/x86-64-apx-evex-promoted-bad.d b/gas/testsuite/gas/i386/x86-64-apx-evex-promoted-bad.d
index 6330367194cb0c24e7e5f289b1cbb871e0a2b3d2..7c2efb08d711ccd2d7415feb9b613aa3183ec186 100644 (file)
--- a/gas/testsuite/gas/i386/x86-64-apx-evex-promoted-bad.d
+++ b/gas/testsuite/gas/i386/x86-64-apx-evex-promoted-bad.d
@@ -15,13 +15,13 @@ Disassembly of section .text:
 [      ]*[a-f0-9]+:[   ]+62 e2 f9 41 91 84[    ]+vpgatherqq \(bad\),%zmm16\{%k1\}
 [      ]*[a-f0-9]+:[   ]+cd ff[        ]+int    \$0xff
 [      ]*[a-f0-9]+:[   ]+62 fd 7d 08 60[       ]+\(bad\)
+[      ]*[a-f0-9]+:[   ]+c7[   ]+.*
+[      ]*[a-f0-9]+:[   ]+62 fc 7d 09 60[       ]+\(bad\).*
 [      ]*[a-f0-9]+:[   ]+c7[   ]+\(bad\)
-[      ]*[a-f0-9]+:[   ]+62 fc 7d[     ]+\(bad\).*
-[      ]*[a-f0-9]+:[   ]+09 60 c7[     ]+or     %esp,-0x39\(%rax\)
-[      ]*[a-f0-9]+:[   ]+62 fc 7d[     ]+\(bad\).*
-[      ]*[a-f0-9]+:[   ]+28 60 c7[     ]+.*
-[      ]*[a-f0-9]+:[   ]+62 fc 7d[     ]+\(bad\).*
-[      ]*[a-f0-9]+:[   ]+8b 60 c7[     ]+.*
+[      ]*[a-f0-9]+:[   ]+62 fc 7d 28 60[       ]+\(bad\).*
+[      ]*[a-f0-9]+:[   ]+c7[   ]+.*
+[      ]*[a-f0-9]+:[   ]+62 fc 7d 8b 60[       ]+\(bad\).*
+[      ]*[a-f0-9]+:[   ]+c7[   ]+.*
 [      ]*[a-f0-9]+:[   ]+62 f2 fc 09 f5[       ]+\(bad\).*
 [      ]*[a-f0-9]+:[   ]+0c 18[        ]+or.*
 [      ]*[a-f0-9]+:[   ]+62 f2 fc 28 f5[       ]+\(bad\)
@@ -30,15 +30,15 @@ Disassembly of section .text:
 [      ]*[a-f0-9]+:[   ]+0c 18[        ]+or.*
 [      ]*[a-f0-9]+:[   ]+62 f2 fc 18 f5[       ]+\(bad\)
 [      ]*[a-f0-9]+:[   ]+0c 18[        ]+or.*
-[      ]*[a-f0-9]+:[   ]+62 f4 e4[     ]+\(bad\)
-[      ]*[a-f0-9]+:[   ]+08 ff[        ]+.*
+[      ]*[a-f0-9]+:[   ]+62 f4 e4 08 ff[       ]+\(bad\)
 [      ]*[a-f0-9]+:[   ]+04 08[        ]+.*
-[      ]*[a-f0-9]+:[   ]+62 f4 3c[     ]+\(bad\)
-[      ]*[a-f0-9]+:[   ]+08 8f c0 ff ff ff[    ]+or.*
+[      ]*[a-f0-9]+:[   ]+62 f4 3c 08 8f[       ]+\(bad\)
+[      ]*[a-f0-9]+:[   ]+c7[   ]+.*
 [      ]*[a-f0-9]+:[   ]+62 74 7c 18 8f c0[    ]+pop2   %rax,\(bad\)
 [      ]*[a-f0-9]+:[   ]+62 d4 24 18 8f[       ]+\(bad\)
 [      ]*[a-f0-9]+:[   ]+c3[   ]+.*
 [      ]*[a-f0-9]+:[   ]+62 fc 7d 0c 60 c7[    ]+movbe  \{bad-nf\},%r23w,%ax
 [      ]*[a-f0-9]+:[   ]+62 fc 79 08 60[       ]+\(bad\)
-[      ]*[a-f0-9]+:[   ]+c2[   ]+.*
+[      ]*[a-f0-9]+:[   ]+c7[    ]+.*
+[      ]*[a-f0-9]+:[   ]+62 d4 fc 18 38 d7[    ]+ccmps\(bad\) \{dfv=of, sf, zf, cf\} %dl,%r15b
 #pass

diff --git a/gas/testsuite/gas/i386/x86-64-apx-evex-promoted-bad.s b/gas/testsuite/gas/i386/x86-64-apx-evex-promoted-bad.s
index cbf34515bab04de6c45d0e5bdfe302cce51e9aeb..959e4e1fb436c6ad159ace084bbdfffae8ed8008 100644 (file)
--- a/gas/testsuite/gas/i386/x86-64-apx-evex-promoted-bad.s
+++ b/gas/testsuite/gas/i386/x86-64-apx-evex-promoted-bad.s
@@ -41,9 +41,8 @@ _start:
        #{evex} inc %rax %rbx EVEX.vvvv != 1111 && EVEX.ND = 0.
        .byte 0x62, 0xf4, 0xe4, 0x08, 0xff, 0x04, 0x08
 
-       # pop2 %rax, %r8 set EVEX.ND=0.
-       .byte 0x62, 0xf4, 0x3c, 0x08, 0x8f, 0xc0
-       .byte 0xff, 0xff, 0xff
+       # pop2 %rdi, %r8 set EVEX.ND=0.
+       .byte 0x62, 0xf4, 0x3c, 0x08, 0x8f, 0xc7
 
        # pop2 %rax, %r8 set EVEX.vvvv = 1111.
        .insn EVEX.L0.M4.W0 0x8f,  %rax, {rn-sae},%r8
@@ -54,5 +53,8 @@ _start:
        #EVEX_MAP4 movbe %r18w,%ax set EVEX.nf = 1.
        .insn EVEX.L0.66.M12.W0 0x60, %di, %ax {%k4}
 
-       # EVEX_MAP4 movbe %r18w,%ax set EVEX.P[10] = 0.
-       .byte 0x62, 0xfc, 0x79, 0x08, 0x60, 0xc2
+       # EVEX_MAP4 movbe %r23w,%ax set EVEX.P[10] = 0.
+       .byte 0x62, 0xfc, 0x79, 0x08, 0x60, 0xc7
+
+       # ccmps {dfv=of,sf,zf,cf} %r15, %rdx set EVEX.ND = 1.
+       .insn EVEX.L0.M4.W1 0x38, %r15, {rn-sae},%rdx

diff --git a/gas/testsuite/gas/i386/x86-64.exp b/gas/testsuite/gas/i386/x86-64.exp
index 8ac7aca1fec8e2fcbb0d4ff08806d3e5e8af8f8a..a8d49cefe8c1034fd5455aec4cbc816c208b181f 100644 (file)
--- a/gas/testsuite/gas/i386/x86-64.exp
+++ b/gas/testsuite/gas/i386/x86-64.exp
@@ -353,6 +353,9 @@ run_dump_test "x86-64-avx512dq-rcigrne"
 run_dump_test "x86-64-apx-push2pop2"
 run_dump_test "x86-64-apx-push2pop2-intel"
 run_list_test "x86-64-apx-push2pop2-inval"
+run_dump_test "x86-64-apx-ccmp-ctest"
+run_dump_test "x86-64-apx-ccmp-ctest-intel"
+run_list_test "x86-64-apx-ccmp-ctest-inval"
 run_dump_test "x86-64-apx-pushp-popp"
 run_dump_test "x86-64-apx-pushp-popp-intel"
 run_list_test "x86-64-apx-pushp-popp-inval"

diff --git a/opcodes/i386-dis-evex-reg.h b/opcodes/i386-dis-evex-reg.h
index 7408295f8e56add730dcf7f54091ee8441100844..eda0e824aef34730dd98e889ad7a32c1101282c2 100644 (file)
--- a/opcodes/i386-dis-evex-reg.h
+++ b/opcodes/i386-dis-evex-reg.h
@@ -58,6 +58,7 @@
     { "%NFandA",       { VexGb, Eb, Ib }, NO_PREFIX },
     { "%NFsubA",       { VexGb, Eb, Ib }, NO_PREFIX },
     { "%NFxorA",       { VexGb, Eb, Ib }, NO_PREFIX },
+    { "%NEccmp%SCA%DF",        { Eb, Ib }, NO_PREFIX },
   },
   /* REG_EVEX_MAP4_81 */
   {
@@ -68,6 +69,7 @@
     { "%NFandQ",       { VexGv, Ev, Iv }, PREFIX_NP_OR_DATA },
     { "%NFsubQ",       { VexGv, Ev, Iv }, PREFIX_NP_OR_DATA },
     { "%NFxorQ",       { VexGv, Ev, Iv }, PREFIX_NP_OR_DATA },
+    { "%NEccmp%SCQ%DF",        { Ev, Iv }, PREFIX_NP_OR_DATA },
   },
   /* REG_EVEX_MAP4_83 */
   {
@@ -78,6 +80,7 @@
     { "%NFandQ",       { VexGv, Ev, sIb }, PREFIX_NP_OR_DATA },
     { "%NFsubQ",       { VexGv, Ev, sIb }, PREFIX_NP_OR_DATA },
     { "%NFxorQ",       { VexGv, Ev, sIb }, PREFIX_NP_OR_DATA },
+    { "%NEccmp%SCQ%DF",        { Ev, sIb }, PREFIX_NP_OR_DATA },
   },
   /* REG_EVEX_MAP4_8F */
   {
@@ -85,8 +88,8 @@
   },
   /* REG_EVEX_MAP4_F6 */
   {
-    { Bad_Opcode },
-    { Bad_Opcode },
+    { "%NEctest%SCA%DF",  { Eb, Ib }, NO_PREFIX },
+    { "%NEctest%SCA%DF",  { Eb, Ib }, NO_PREFIX },
     { "notA",  { VexGb, Eb }, NO_PREFIX },
     { "%NFnegA",       { VexGb, Eb }, NO_PREFIX },
     { "%NFmulA",       { Eb }, NO_PREFIX },
@@ -96,8 +99,8 @@
   },
   /* REG_EVEX_MAP4_F7 */
   {
-    { Bad_Opcode },
-    { Bad_Opcode },
+    { "%NEctest%SCQ%DF",  { Ev, Iv }, PREFIX_NP_OR_DATA },
+    { "%NEctest%SCQ%DF",  { Ev, Iv }, PREFIX_NP_OR_DATA },
     { "notQ",  { VexGv, Ev }, PREFIX_NP_OR_DATA },
     { "%NFnegQ",       { VexGv, Ev }, PREFIX_NP_OR_DATA },
     { "%NFmulQ",       { Ev }, PREFIX_NP_OR_DATA },

diff --git a/opcodes/i386-dis-evex.h b/opcodes/i386-dis-evex.h
index a3d3fbe204d7636eb56495eaef60eb38f57be1cc..77c2ee772d11d9508b959c6616794575d4e0bd6c 100644 (file)
--- a/opcodes/i386-dis-evex.h
+++ b/opcodes/i386-dis-evex.h
@@ -938,10 +938,10 @@ static const struct dis386 evex_table[][256] = {
     { Bad_Opcode },
     { Bad_Opcode },
     /* 38 */
-    { Bad_Opcode },
-    { Bad_Opcode },
-    { Bad_Opcode },
-    { Bad_Opcode },
+    { "%NEccmp%SCB%DF",                { Eb, Gb }, 0 },
+    { "%NEccmp%SCS%DF",                { Ev, Gv }, PREFIX_NP_OR_DATA },
+    { "%NEccmp%SCB%DF",                { Gb, EbS }, 0 },
+    { "%NEccmp%SCS%DF",                { Gv, EvS }, PREFIX_NP_OR_DATA },
     { Bad_Opcode },
     { Bad_Opcode },
     { Bad_Opcode },
@@ -1023,8 +1023,8 @@ static const struct dis386 evex_table[][256] = {
     { REG_TABLE (REG_EVEX_MAP4_81) },
     { Bad_Opcode },
     { REG_TABLE (REG_EVEX_MAP4_83) },
-    { Bad_Opcode },
-    { Bad_Opcode },
+    { "%NEctest%SCB%DF",             { Eb, Gb }, NO_PREFIX },
+    { "%NEctest%SCS%DF",             { Ev, Gv }, PREFIX_NP_OR_DATA },
     { Bad_Opcode },
     { Bad_Opcode },
     /* 88 */

diff --git a/opcodes/i386-dis.c b/opcodes/i386-dis.c
index 5e9e53c49393aecb1725af3cafd205b132905c94..86745a1b933cb262857d86f9ae4f717adf38b318 100644 (file)
--- a/opcodes/i386-dis.c
+++ b/opcodes/i386-dis.c
@@ -219,6 +219,7 @@ struct instr_info
     int length;
     int prefix;
     int mask_register_specifier;
+    int scc;
     int ll;
     bool w;
     bool evex;
@@ -1804,7 +1805,10 @@ struct dis386 {
           instruction.
    "NF" => print "{nf} " pseudo prefix when EVEX.NF = 1 and print "{evex} "
           pseudo prefix when instructions without NF, EGPR and VVVV,
+   "NE" => don't print "{evex} " pseudo prefix for some special instructions
+          in MAP4.
    "ZU" => print 'zu' if EVEX.ZU=1.
+   "SC" => print suffix SCC for SCC insns
    "YK" keep unused, to avoid ambiguity with the combined use of Y and K.
    "YX" keep unused, to avoid ambiguity with the combined use of Y and X.
    "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand, cond
@@ -1814,6 +1818,7 @@ struct dis386 {
    "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
    "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
    "DQ" => print 'd' or 'q' depending on the VEX.W bit
+   "DF" => print default flag value for SCC insns
    "BW" => print 'b' or 'w' depending on the VEX.W bit
    "LP" => print 'w' or 'l' ('d' in Intel mode) if instruction has
           an operand size prefix, or suffix_always is true.  print
@@ -9047,6 +9052,7 @@ get_valid_dis386 (const struct dis386 *dp, instr_info *ins)
 
       ins->vex.v = *ins->codep & 0x8;
       ins->vex.mask_register_specifier = *ins->codep & 0x7;
+      ins->vex.scc = *ins->codep & 0xf;
       ins->vex.zeroing = *ins->codep & 0x80;
       /* Set the NF bit for EVEX-Promoted instructions, this bit will be cleared
         when it's an evex_default one.  */
@@ -9064,22 +9070,8 @@ get_valid_dis386 (const struct dis386 *dp, instr_info *ins)
          ins->rex2 &= ~REX_R;
        }
 
-      /* EVEX from legacy instructions, when the EVEX.ND bit is 0,
-        all bits of EVEX.vvvv and EVEX.V' must be 1.  */
-      if (ins->evex_type == evex_from_legacy && !ins->vex.nd
-         && (ins->vex.register_specifier || !ins->vex.v))
-       return &bad_opcode;
-
       ins->need_vex = 4;
 
-      /* EVEX from legacy instructions require that EVEX.z, EVEX.L’L and the
-        lower 2 bits of EVEX.aaa must be 0.  */
-      if (ins->evex_type == evex_from_legacy
-         && ((ins->vex.mask_register_specifier & 0x3) != 0
-             || ins->vex.ll != 0
-             || ins->vex.zeroing != 0))
-       return &bad_opcode;
-
       ins->codep++;
       vindex = *ins->codep++;
       ins->condition_code = vindex & 0xf;
@@ -9186,7 +9178,7 @@ i386_dis_printf (const disassemble_info *info, enum disassembler_style style,
   va_list ap;
   enum disassembler_style curr_style = style;
   const char *start, *curr;
-  char staging_area[40];
+  char staging_area[50];
 
   va_start (ap, fmt);
   /* In particular print_insn()'s processing of op_txt[] can hand rather long
@@ -9630,7 +9622,32 @@ print_insn (bfd_vma pc, disassemble_info *info, int intel_syntax)
            ? dis_jsr : dis_branch;
       }
   }
+  /* The purpose of placing the check here is to wait for the EVEX prefix for
+     conditional CMP and TEST to be consumed and cleared, and then make a
+     unified judgment. Because they are both in map4, we can not distinguish
+     EVEX prefix for conditional CMP and TEST from others during the
+     EVEX prefix stage of parsing.  */
+  if (ins.evex_type == evex_from_legacy)
+    {
+      /* EVEX from legacy instructions, when the EVEX.ND bit is 0,
+        all bits of EVEX.vvvv and EVEX.V' must be 1.  */
+      if (!ins.vex.nd && (ins.vex.register_specifier || !ins.vex.v))
+       {
+         i386_dis_printf (info, dis_style_text, "(bad)");
+         ret = ins.end_codep - priv.the_buffer;
+         goto out;
+       }
 
+      /* EVEX from legacy instructions require that EVEX.z, EVEX.L’L and the
+        lower 2 bits of EVEX.aaa must be 0.  */
+      if ((ins.vex.mask_register_specifier & 0x3) != 0
+         || ins.vex.ll != 0 || ins.vex.zeroing != 0)
+       {
+         i386_dis_printf (info, dis_style_text, "(bad)");
+         ret = ins.end_codep - priv.the_buffer;
+         goto out;
+       }
+    }
   /* If VEX.vvvv and EVEX.vvvv are unused, they must be all 1s, which
      are all 0s in inverted form.  */
   if (ins.need_vex && ins.vex.register_specifier != 0)
@@ -10216,6 +10233,18 @@ static const char *const fgrps[][8] = {
   },
 };
 
+static const char *const oszc_flags[16] = {
+  " {dfv=}", " {dfv=cf}", " {dfv=zf}", " {dfv=zf, cf}", " {dfv=sf}",
+  " {dfv=sf, cf}", " {dfv=sf, zf}", " {dfv=sf, zf, cf}", " {dfv=of}",
+  " {dfv=of, cf}", " {dfv=of, zf}", " {dfv=of, zf, cf}", " {dfv=of, sf}",
+  " {dfv=of, sf, cf}", " {dfv=of, sf, zf}", " {dfv=of, sf, zf, cf}"
+};
+
+static const char *const scc_suffix[16] = {
+  "o", "no", "b", "ae", "e", "ne", "be", "a", "s", "ns", "t", "f",
+  "l", "ge", "le", "g"
+};
+
 static void
 swap_operand (instr_info *ins)
 {
@@ -10398,6 +10427,23 @@ putop (instr_info *ins, const char *in_template, int sizeflag)
                *ins->obufp++ = *q;
              break;
            }
+         else if (l == 1 && last[0] == 'S')
+           {
+             /* Add scc suffix.  */
+             oappend (ins, scc_suffix[ins->vex.scc]);
+
+             /* For SCC insns, the ND bit is required to be set to 0.  */
+             if (ins->vex.nd)
+               oappend (ins, "(bad)");
+
+             /* These bits have been consumed and should be cleared or restored
+                to default values.  */
+             ins->vex.v = 1;
+             ins->vex.nf = false;
+             ins->vex.mask_register_specifier = 0;
+             break;
+           }
+
          if (l)
            abort ();
          if (ins->intel_syntax && !alt)
@@ -10477,6 +10523,10 @@ putop (instr_info *ins, const char *in_template, int sizeflag)
                  *ins->obufp++ = '}';
                  *ins->obufp++ = ' ';
                  break;
+               case 'N':
+                 /* Skip printing {evex} for some special instructions in MAP4.  */
+                 evex_printed = true;
+                 break;
                case 'M':
                  if (ins->modrm.mod != 3 && !(ins->rex2 & 7))
                    oappend (ins, "{evex} ");
@@ -10532,6 +10582,17 @@ putop (instr_info *ins, const char *in_template, int sizeflag)
                  evex_printed = true;
                }
            }
+         else if (l == 1 && last[0] == 'D')
+           {
+             /* Get oszc flags value from register_specifier.  */
+             int oszc_value = ~ins->vex.register_specifier & 0xf;
+
+             /* Add {dfv=of, sf, zf, cf} flags.  */
+             oappend (ins, oszc_flags[oszc_value]);
+
+             /* These bits have been consumed and should be cleared.  */
+             ins->vex.register_specifier = 0;
+           }
          else
            abort ();
          break;

diff --git a/opcodes/i386-mnem.h b/opcodes/i386-mnem.h
index c2ef4f464f06be9a2e264932131d6cf1f66ce6ae..5f01bb969dd48a014c5a69a69867460c262755ce 100644 (file)
--- a/opcodes/i386-mnem.h
+++ b/opcodes/i386-mnem.h
@@ -132,2272 +132,2328 @@ extern const char i386_mnemonics[];
 #define MN_pusha 0x462
 #define MN_ja 0x468
 #define MN_jna 0x46b
-#define MN_setna 0x46f
-#define MN_setzuna 0x475
+#define MN_ccmpna 0x46f
+#define MN_setna 0x476
+#define MN_ctestna 0x47c
+#define MN_setzuna 0x484
 #define MN_cmovna (MN_fcmovna + 1)
-#define MN_fcmovna 0x47d
-#define MN_popa 0x485
+#define MN_fcmovna 0x48c
+#define MN_ccmpa 0x494
+#define MN_popa 0x49a
 #define MN_movntdqa (MN_vmovntdqa + 1)
-#define MN_vmovntdqa 0x48a
+#define MN_vmovntdqa 0x49f
 #define MN_movdqa (MN_vmovdqa + 1)
-#define MN_vmovdqa 0x494
-#define MN_seta 0x49c
-#define MN_prefetchnta 0x4a1
-#define MN_setzua 0x4ad
+#define MN_vmovdqa 0x4a9
+#define MN_seta 0x4b1
+#define MN_prefetchnta 0x4b6
+#define MN_ctesta 0x4c2
+#define MN_setzua 0x4c9
 #define MN_cmova (MN_fcmova + 1)
-#define MN_fcmova 0x4b4
-#define MN_rex_b 0x4bb
-#define MN_ud2b 0x4c1
-#define MN_vpermi2b 0x4c6
-#define MN_vpmovm2b 0x4cf
-#define MN_vpermt2b 0x4d8
-#define MN_movdir64b 0x4e1
-#define MN_cmpxchg16b 0x4eb
-#define MN_cmpxchg8b 0x4f6
-#define MN_vpshab 0x500
-#define MN_sbb 0x507
+#define MN_fcmova 0x4d0
+#define MN_rex_b 0x4d7
+#define MN_ud2b 0x4dd
+#define MN_vpermi2b 0x4e2
+#define MN_vpmovm2b 0x4eb
+#define MN_vpermt2b 0x4f4
+#define MN_movdir64b 0x4fd
+#define MN_cmpxchg16b 0x507
+#define MN_cmpxchg8b 0x512
+#define MN_vpshab 0x51c
+#define MN_sbb 0x523
 #define MN_psubb (MN_vpsubb + 1)
-#define MN_vpsubb 0x50b
-#define MN_xcrypt_ecb 0x512
-#define MN_xcryptecb 0x51d
-#define MN_llwpcb 0x527
-#define MN_slwpcb 0x52e
-#define MN_kaddb 0x535
+#define MN_vpsubb 0x527
+#define MN_xcrypt_ecb 0x52e
+#define MN_xcryptecb 0x539
+#define MN_llwpcb 0x543
+#define MN_slwpcb 0x54a
+#define MN_kaddb 0x551
 #define MN_paddb (MN_vpaddb + 1)
-#define MN_vpaddb 0x53b
-#define MN_kandb 0x542
-#define MN_vpexpandb 0x548
-#define MN_vpmovusdb 0x552
-#define MN_vpmovsdb 0x55c
-#define MN_vpmovdb 0x565
-#define MN_vpcomgeb 0x56d
-#define MN_vpcomleb 0x576
-#define MN_vpcmpnleb 0x57f
-#define MN_vpcmpleb 0x589
-#define MN_vpcomfalseb 0x592
-#define MN_vpcomtrueb 0x59e
-#define MN_xcrypt_cfb 0x5a9
-#define MN_xcryptcfb 0x5b4
-#define MN_xcrypt_ofb 0x5be
-#define MN_xcryptofb 0x5c9
+#define MN_vpaddb 0x557
+#define MN_kandb 0x55e
+#define MN_vpexpandb 0x564
+#define MN_vpmovusdb 0x56e
+#define MN_vpmovsdb 0x578
+#define MN_vpmovdb 0x581
+#define MN_vpcomgeb 0x589
+#define MN_vpcomleb 0x592
+#define MN_vpcmpnleb 0x59b
+#define MN_vpcmpleb 0x5a5
+#define MN_vpcomfalseb 0x5ae
+#define MN_vpcomtrueb 0x5ba
+#define MN_xcrypt_cfb 0x5c5
+#define MN_xcryptcfb 0x5d0
+#define MN_xcrypt_ofb 0x5da
+#define MN_xcryptofb 0x5e5
 #define MN_pshufb (MN_vpshufb + 1)
-#define MN_vpshufb 0x5d3
-#define MN_invlpgb 0x5db
+#define MN_vpshufb 0x5ef
+#define MN_invlpgb 0x5f7
 #define MN_pavgb (MN_vpavgb + 1)
-#define MN_vpavgb 0x5e3
-#define MN_jb 0x5ea
-#define MN_pbndkb 0x5ed
+#define MN_vpavgb 0x5ff
+#define MN_jb 0x606
+#define MN_pbndkb 0x609
 #define MN_pmovmskb (MN_vpmovmskb + 1)
-#define MN_vpmovmskb 0x5f4
-#define MN_vpshlb 0x5fe
-#define MN_kshiftlb 0x605
+#define MN_vpmovmskb 0x610
+#define MN_vpshlb 0x61a
+#define MN_kshiftlb 0x621
 #define MN_gf2p8mulb (MN_vgf2p8mulb + 1)
-#define MN_vgf2p8mulb 0x60e
-#define MN_vpblendmb 0x619
-#define MN_vptestnmb 0x623
-#define MN_vpcomb 0x62d
-#define MN_vpshufbitqmb 0x634
-#define MN_vpermb 0x641
-#define MN_vptestmb 0x648
-#define MN_kandnb 0x651
+#define MN_vgf2p8mulb 0x62a
+#define MN_vpblendmb 0x635
+#define MN_vptestnmb 0x63f
+#define MN_vpcomb 0x649
+#define MN_vpshufbitqmb 0x650
+#define MN_vpermb 0x65d
+#define MN_vptestmb 0x664
+#define MN_kandnb 0x66d
 #define MN_psignb (MN_vpsignb + 1)
-#define MN_vpsignb 0x658
-#define MN_jnb 0x660
-#define MN_setnb 0x664
-#define MN_setzunb 0x66a
+#define MN_vpsignb 0x674
+#define MN_jnb 0x67c
+#define MN_ccmpnb 0x680
+#define MN_setnb 0x687
+#define MN_ctestnb 0x68d
+#define MN_setzunb 0x695
 #define MN_cmovnb (MN_fcmovnb + 1)
-#define MN_fcmovnb 0x672
-#define MN_vpcmpb 0x67a
-#define MN_vpcomeqb 0x681
+#define MN_fcmovnb 0x69d
+#define MN_ccmpb 0x6a5
+#define MN_vpcmpb 0x6ab
+#define MN_vpcomeqb 0x6b2
 #define MN_gf2p8affineqb (MN_vgf2p8affineqb + 1)
-#define MN_vgf2p8affineqb 0x68a
-#define MN_vpcomneqb 0x699
-#define MN_vpcmpneqb 0x6a3
+#define MN_vgf2p8affineqb 0x6bb
+#define MN_vpcomneqb 0x6ca
+#define MN_vpcmpneqb 0x6d4
 #define MN_pcmpeqb (MN_vpcmpeqb + 1)
-#define MN_vpcmpeqb 0x6ad
-#define MN_vpmovusqb 0x6b6
-#define MN_vpmovsqb 0x6c0
-#define MN_vpmultishiftqb 0x6c9
+#define MN_vpcmpeqb 0x6de
+#define MN_vpmovusqb 0x6e7
+#define MN_vpmovsqb 0x6f1
+#define MN_vpmultishiftqb 0x6fa
 #define MN_gf2p8affineinvqb (MN_vgf2p8affineinvqb + 1)
-#define MN_vgf2p8affineinvqb 0x6d8
-#define MN_vpmovqb 0x6ea
-#define MN_rex_rb 0x6f2
-#define MN_korb 0x6f9
-#define MN_kxnorb 0x6fe
-#define MN_kxorb 0x705
+#define MN_vgf2p8affineinvqb 0x709
+#define MN_vpmovqb 0x71b
+#define MN_rex_rb 0x723
+#define MN_korb 0x72a
+#define MN_kxnorb 0x72f
+#define MN_kxorb 0x736
 #define MN_pinsrb (MN_vpinsrb + 1)
-#define MN_vpinsrb 0x70b
-#define MN_kshiftrb 0x713
+#define MN_vpinsrb 0x73c
+#define MN_kshiftrb 0x744
 #define MN_pextrb (MN_vpextrb + 1)
-#define MN_vpextrb 0x71c
-#define MN_rex_wrb 0x724
+#define MN_vpextrb 0x74d
+#define MN_rex_wrb 0x755
 #define MN_pabsb (MN_vpabsb + 1)
-#define MN_vpabsb 0x72c
+#define MN_vpabsb 0x75d
 #define MN_psubsb (MN_vpsubsb + 1)
-#define MN_vpsubsb 0x733
+#define MN_vpsubsb 0x764
 #define MN_paddsb (MN_vpaddsb + 1)
-#define MN_vpaddsb 0x73b
+#define MN_vpaddsb 0x76c
 #define MN_pminsb (MN_vpminsb + 1)
-#define MN_vpminsb 0x743
-#define MN_vpcompressb 0x74b
+#define MN_vpminsb 0x774
+#define MN_vpcompressb 0x77c
 #define MN_psubusb (MN_vpsubusb + 1)
-#define MN_vpsubusb 0x757
+#define MN_vpsubusb 0x788
 #define MN_paddusb (MN_vpaddusb + 1)
-#define MN_vpaddusb 0x760
-#define MN_pavgusb 0x769
-#define MN_movsb 0x771
+#define MN_vpaddusb 0x791
+#define MN_pavgusb 0x79a
+#define MN_movsb 0x7a2
 #define MN_pmaxsb (MN_vpmaxsb + 1)
-#define MN_vpmaxsb 0x777
-#define MN_setb 0x77f
-#define MN_vpcomgtb 0x784
+#define MN_vpmaxsb 0x7a8
+#define MN_setb 0x7b0
+#define MN_vpcomgtb 0x7b5
 #define MN_pcmpgtb (MN_vpcmpgtb + 1)
-#define MN_vpcmpgtb 0x78d
-#define MN_vpcomltb 0x796
-#define MN_vpcmpnltb 0x79f
-#define MN_vpcmpltb 0x7a9
-#define MN_vpopcntb 0x7b2
-#define MN_knotb 0x7bb
-#define MN_vprotb 0x7c1
-#define MN_vpbroadcastb 0x7c8
-#define MN_ktestb 0x7d5
-#define MN_kortestb 0x7dc
-#define MN_vpcomgeub 0x7e5
-#define MN_vpcomleub 0x7ef
-#define MN_vpcmpnleub 0x7f9
-#define MN_vpcmpleub 0x804
-#define MN_vpcomfalseub 0x80e
-#define MN_vpcomtrueub 0x81b
-#define MN_vpcomub 0x827
+#define MN_vpcmpgtb 0x7be
+#define MN_vpcomltb 0x7c7
+#define MN_vpcmpnltb 0x7d0
+#define MN_vpcmpltb 0x7da
+#define MN_vpopcntb 0x7e3
+#define MN_knotb 0x7ec
+#define MN_vprotb 0x7f2
+#define MN_vpbroadcastb 0x7f9
+#define MN_ctestb 0x806
+#define MN_ktestb 0x80d
+#define MN_kortestb 0x814
+#define MN_vpcomgeub 0x81d
+#define MN_vpcomleub 0x827
+#define MN_vpcmpnleub 0x831
+#define MN_vpcmpleub 0x83c
+#define MN_vpcomfalseub 0x846
+#define MN_vpcomtrueub 0x853
+#define MN_vpcomub 0x85f
 #define MN_pminub (MN_vpminub + 1)
-#define MN_vpminub 0x82f
-#define MN_vpcmpub 0x837
-#define MN_vpcomequb 0x83f
-#define MN_vpcomnequb 0x849
-#define MN_vpcmpnequb 0x854
-#define MN_vpcmpequb 0x85f
+#define MN_vpminub 0x867
+#define MN_vpcmpub 0x86f
+#define MN_vpcomequb 0x877
+#define MN_vpcomnequb 0x881
+#define MN_vpcmpnequb 0x88c
+#define MN_vpcmpequb 0x897
 #define MN_sub (MN_fsub + 1)
 #define MN_fsub (MN_pfsub + 1)
-#define MN_pfsub 0x869
-#define MN_fisub 0x86f
-#define MN_vpcomgtub 0x875
-#define MN_vpcomltub 0x87f
-#define MN_vpcmpnltub 0x889
-#define MN_vpcmpltub 0x894
+#define MN_pfsub 0x8a1
+#define MN_fisub 0x8a7
+#define MN_vpcomgtub 0x8ad
+#define MN_vpcomltub 0x8b7
+#define MN_vpcmpnltub 0x8c1
+#define MN_vpcmpltub 0x8cc
 #define MN_pmaxub (MN_vpmaxub + 1)
-#define MN_vpmaxub 0x89e
-#define MN_setzub 0x8a6
+#define MN_vpmaxub 0x8d6
+#define MN_setzub 0x8de
 #define MN_pblendvb (MN_vpblendvb + 1)
-#define MN_vpblendvb 0x8ad
+#define MN_vpblendvb 0x8e5
 #define MN_cmovb (MN_fcmovb + 1)
-#define MN_fcmovb 0x8b7
-#define MN_kmovb 0x8be
-#define MN_rex_wb 0x8c4
-#define MN_clwb 0x8cb
+#define MN_fcmovb 0x8ef
+#define MN_kmovb 0x8f6
+#define MN_rex_wb 0x8fc
+#define MN_clwb 0x903
 #define MN_packsswb (MN_vpacksswb + 1)
-#define MN_vpacksswb 0x8d0
+#define MN_vpacksswb 0x908
 #define MN_packuswb (MN_vpackuswb + 1)
-#define MN_vpackuswb 0x8da
-#define MN_vpmovuswb 0x8e4
-#define MN_vpmovswb 0x8ee
-#define MN_vpmovwb 0x8f7
-#define MN_rex_xb 0x8ff
-#define MN_rex_rxb 0x906
-#define MN_rex_wrxb 0x90e
-#define MN_rex_wxb 0x917
-#define MN_movzb 0x91f
-#define MN_clac 0x925
-#define MN_stac 0x92a
-#define MN_xcrypt_cbc 0x92f
-#define MN_xcryptcbc 0x93a
-#define MN_pfacc 0x944
-#define MN_pfnacc 0x94a
-#define MN_pfpnacc 0x951
-#define MN_adc 0x959
+#define MN_vpackuswb 0x912
+#define MN_vpmovuswb 0x91c
+#define MN_vpmovswb 0x926
+#define MN_vpmovwb 0x92f
+#define MN_rex_xb 0x937
+#define MN_rex_rxb 0x93e
+#define MN_rex_wrxb 0x946
+#define MN_rex_wxb 0x94f
+#define MN_movzb 0x957
+#define MN_clac 0x95d
+#define MN_stac 0x962
+#define MN_xcrypt_cbc 0x967
+#define MN_xcryptcbc 0x972
+#define MN_pfacc 0x97c
+#define MN_pfnacc 0x982
+#define MN_pfpnacc 0x989
+#define MN_adc 0x991
 #define MN_dec (MN_aesdec + 3)
 #define MN_aesdec (MN_vaesdec + 1)
-#define MN_vaesdec 0x95d
-#define MN_getsec 0x965
-#define MN_xsavec 0x96c
-#define MN_blcic 0x973
-#define MN_blsic 0x979
-#define MN_jc 0x97f
-#define MN_t1mskc 0x982
-#define MN_clc 0x989
-#define MN_cmc 0x98d
+#define MN_vaesdec 0x995
+#define MN_getsec 0x99d
+#define MN_xsavec 0x9a4
+#define MN_blcic 0x9ab
+#define MN_blsic 0x9b1
+#define MN_jc 0x9b7
+#define MN_t1mskc 0x9ba
+#define MN_clc 0x9c1
+#define MN_cmc 0x9c5
 #define MN_aesimc (MN_vaesimc + 1)
-#define MN_vaesimc 0x991
-#define MN_rdpmc 0x999
+#define MN_vaesimc 0x9c9
+#define MN_rdpmc 0x9d1
 #define MN_aesenc (MN_vaesenc + 1)
-#define MN_vaesenc 0x99f
-#define MN_inc 0x9a7
-#define MN_jnc 0x9ab
-#define MN_setnc 0x9af
-#define MN_vmfunc 0x9b5
-#define MN_setzunc 0x9bc
-#define MN_cmovnc 0x9c4
-#define MN_tlbsync 0x9cb
-#define MN_rdtsc 0x9d3
-#define MN_btc 0x9d9
-#define MN_setc 0x9dd
-#define MN_stc 0x9e2
-#define MN_setzuc 0x9e6
-#define MN_cmovc 0x9ed
-#define MN_vpermi2d 0x9f3
-#define MN_vpmovm2d 0x9fc
-#define MN_vpermt2d 0xa05
-#define MN_vpbroadcastmw2d 0xa0e
-#define MN_aad 0xa1e
-#define MN_vmread 0xa22
-#define MN_vpshad 0xa29
-#define MN_vmload 0xa30
+#define MN_vaesenc 0x9d7
+#define MN_inc 0x9df
+#define MN_jnc 0x9e3
+#define MN_ccmpnc 0x9e7
+#define MN_setnc 0x9ee
+#define MN_ctestnc 0x9f4
+#define MN_vmfunc 0x9fc
+#define MN_setzunc 0xa03
+#define MN_cmovnc 0xa0b
+#define MN_tlbsync 0xa12
+#define MN_ccmpc 0xa1a
+#define MN_rdtsc 0xa20
+#define MN_btc 0xa26
+#define MN_setc 0xa2a
+#define MN_stc (MN_ctestc + 3)
+#define MN_ctestc 0xa2f
+#define MN_setzuc 0xa36
+#define MN_cmovc 0xa3d
+#define MN_vpermi2d 0xa43
+#define MN_vpmovm2d 0xa4c
+#define MN_vpermt2d 0xa55
+#define MN_vpbroadcastmw2d 0xa5e
+#define MN_aad 0xa6e
+#define MN_vmread 0xa72
+#define MN_vpshad 0xa79
+#define MN_vmload 0xa80
 #define MN_psrad (MN_vpsrad + 1)
-#define MN_vpsrad 0xa37
-#define MN_vphaddbd 0xa3e
-#define MN_vphaddubd 0xa47
+#define MN_vpsrad 0xa87
+#define MN_vphaddbd 0xa8e
+#define MN_vphaddubd 0xa97
 #define MN_phsubd (MN_vphsubd + 1)
-#define MN_vphsubd 0xa51
+#define MN_vphsubd 0xaa1
 #define MN_psubd (MN_vpsubd + 1)
-#define MN_vpsubd 0xa59
+#define MN_vpsubd 0xaa9
 #define MN_pmovsxbd (MN_vpmovsxbd + 1)
-#define MN_vpmovsxbd 0xa60
+#define MN_vpmovsxbd 0xab0
 #define MN_pmovzxbd (MN_vpmovzxbd + 1)
-#define MN_vpmovzxbd 0xa6a
+#define MN_vpmovzxbd 0xaba
 #define MN_add (MN_aadd + 1)
-#define MN_aadd 0xa74
+#define MN_aadd 0xac4
 #define MN_fadd (MN_pfadd + 1)
-#define MN_pfadd 0xa79
-#define MN_fiadd 0xa7f
-#define MN_tileloadd 0xa85
+#define MN_pfadd 0xac9
+#define MN_fiadd 0xacf
+#define MN_tileloadd 0xad5
 #define MN_xadd (MN_cmpnaxadd + 5)
-#define MN_cmpnaxadd 0xa8f
-#define MN_cmpaxadd 0xa99
-#define MN_cmpnbxadd 0xaa2
-#define MN_cmpbxadd 0xaac
-#define MN_cmpncxadd 0xab5
-#define MN_cmpcxadd 0xabf
-#define MN_cmpnaexadd 0xac8
-#define MN_cmpaexadd 0xad3
-#define MN_cmpnbexadd 0xadd
-#define MN_cmpbexadd 0xae8
-#define MN_cmpngexadd 0xaf2
-#define MN_cmpgexadd 0xafd
-#define MN_cmpnlexadd 0xb07
-#define MN_cmplexadd 0xb12
-#define MN_cmpnexadd 0xb1c
-#define MN_cmpexadd 0xb26
-#define MN_cmppexadd 0xb2f
-#define MN_cmpngxadd 0xb39
-#define MN_cmpgxadd 0xb43
-#define MN_cmpnlxadd 0xb4c
-#define MN_cmplxadd 0xb56
-#define MN_cmpnoxadd 0xb5f
-#define MN_cmpoxadd 0xb69
-#define MN_cmppoxadd 0xb72
-#define MN_cmpnpxadd 0xb7c
-#define MN_cmppxadd 0xb86
-#define MN_cmpnsxadd 0xb8f
-#define MN_cmpsxadd 0xb99
-#define MN_cmpnzxadd 0xba2
-#define MN_cmpzxadd 0xbac
+#define MN_cmpnaxadd 0xadf
+#define MN_cmpaxadd 0xae9
+#define MN_cmpnbxadd 0xaf2
+#define MN_cmpbxadd 0xafc
+#define MN_cmpncxadd 0xb05
+#define MN_cmpcxadd 0xb0f
+#define MN_cmpnaexadd 0xb18
+#define MN_cmpaexadd 0xb23
+#define MN_cmpnbexadd 0xb2d
+#define MN_cmpbexadd 0xb38
+#define MN_cmpngexadd 0xb42
+#define MN_cmpgexadd 0xb4d
+#define MN_cmpnlexadd 0xb57
+#define MN_cmplexadd 0xb62
+#define MN_cmpnexadd 0xb6c
+#define MN_cmpexadd 0xb76
+#define MN_cmppexadd 0xb7f
+#define MN_cmpngxadd 0xb89
+#define MN_cmpgxadd 0xb93
+#define MN_cmpnlxadd 0xb9c
+#define MN_cmplxadd 0xba6
+#define MN_cmpnoxadd 0xbaf
+#define MN_cmpoxadd 0xbb9
+#define MN_cmppoxadd 0xbc2
+#define MN_cmpnpxadd 0xbcc
+#define MN_cmppxadd 0xbd6
+#define MN_cmpnsxadd 0xbdf
+#define MN_cmpsxadd 0xbe9
+#define MN_cmpnzxadd 0xbf2
+#define MN_cmpzxadd 0xbfc
 #define MN_phaddd (MN_vphaddd + 1)
-#define MN_vphaddd 0xbb5
-#define MN_kaddd 0xbbd
+#define MN_vphaddd 0xc05
+#define MN_kaddd 0xc0d
 #define MN_paddd (MN_vpaddd + 1)
-#define MN_vpaddd 0xbc3
-#define MN_vpshldd 0xbca
-#define MN_kandd 0xbd2
-#define MN_vpandd 0xbd8
-#define MN_vpexpandd 0xbdf
-#define MN_vpblendd 0xbe9
-#define MN_vpgatherdd 0xbf2
-#define MN_vpscatterdd 0xbfd
-#define MN_vpshrdd 0xc09
-#define MN_vpmacsdd 0xc11
-#define MN_vpmacssdd 0xc1a
-#define MN_rdseed 0xc24
-#define MN_vpcomged 0xc2b
-#define MN_vpcomled 0xc34
-#define MN_vpcmpnled 0xc3d
-#define MN_vpcmpled 0xc47
-#define MN_tilestored 0xc50
-#define MN_vpcomfalsed 0xc5b
-#define MN_vpcomtrued 0xc67
-#define MN_pi2fd 0xc72
+#define MN_vpaddd 0xc13
+#define MN_vpshldd 0xc1a
+#define MN_kandd 0xc22
+#define MN_vpandd 0xc28
+#define MN_vpexpandd 0xc2f
+#define MN_vpblendd 0xc39
+#define MN_vpgatherdd 0xc42
+#define MN_vpscatterdd 0xc4d
+#define MN_vpshrdd 0xc59
+#define MN_vpmacsdd 0xc61
+#define MN_vpmacssdd 0xc6a
+#define MN_rdseed 0xc74
+#define MN_vpcomged 0xc7b
+#define MN_vpcomled 0xc84
+#define MN_vpcmpnled 0xc8d
+#define MN_vpcmpled 0xc97
+#define MN_tilestored 0xca0
+#define MN_vpcomfalsed 0xcab
+#define MN_vpcomtrued 0xcb7
+#define MN_pi2fd 0xcc2
 #define MN_pshufd (MN_vpshufd + 1)
-#define MN_vpshufd 0xc78
-#define MN_vpternlogd 0xc80
-#define MN_pf2id 0xc8b
-#define MN_invpcid 0xc91
-#define MN_rdpid 0xc99
-#define MN_invvpid 0xc9f
-#define MN_cpuid 0xca7
-#define MN_fbld 0xcad
-#define MN_cld 0xcb2
-#define MN_fld 0xcb6
+#define MN_vpshufd 0xcc8
+#define MN_vpternlogd 0xcd0
+#define MN_pf2id 0xcdb
+#define MN_invpcid 0xce1
+#define MN_rdpid 0xce9
+#define MN_invvpid 0xcef
+#define MN_cpuid 0xcf7
+#define MN_fbld 0xcfd
+#define MN_cld 0xd02
+#define MN_fld 0xd06
 #define MN_shld (MN_vpshld + 2)
-#define MN_vpshld 0xcba
-#define MN_fild 0xcc1
+#define MN_vpshld 0xd0a
+#define MN_fild 0xd11
 #define MN_pslld (MN_vpslld + 1)
-#define MN_vpslld 0xcc6
+#define MN_vpslld 0xd16
 #define MN_pmulld (MN_vpmulld + 1)
-#define MN_vpmulld 0xccd
-#define MN_vprold 0xcd5
+#define MN_vpmulld 0xd1d
+#define MN_vprold 0xd25
 #define MN_psrld (MN_vpsrld + 1)
-#define MN_vpsrld 0xcdc
-#define MN_vmptrld 0xce3
-#define MN_kshiftld 0xceb
-#define MN_enqcmd 0xcf4
-#define MN_vpblendmd 0xcfb
-#define MN_vptestnmd 0xd05
-#define MN_vpcomd 0xd0f
-#define MN_vpermd 0xd16
-#define MN_vptestmd 0xd1d
+#define MN_vpsrld 0xd2c
+#define MN_vmptrld 0xd33
+#define MN_kshiftld 0xd3b
+#define MN_enqcmd 0xd44
+#define MN_vpblendmd 0xd4b
+#define MN_vptestnmd 0xd55
+#define MN_vpcomd 0xd5f
+#define MN_vpermd 0xd66
+#define MN_vptestmd 0xd6d
 #define MN_and (MN_aand + 1)
-#define MN_aand 0xd26
+#define MN_aand 0xd76
 #define MN_pand (MN_vpand + 1)
-#define MN_vpand 0xd2b
-#define MN_rdrand 0xd31
-#define MN_bnd 0xd38
-#define MN_kandnd 0xd3c
-#define MN_vpandnd 0xd43
-#define MN_xend 0xd4b
-#define MN_valignd 0xd50
+#define MN_vpand 0xd7b
+#define MN_rdrand 0xd81
+#define MN_bnd 0xd88
+#define MN_kandnd 0xd8c
+#define MN_vpandnd 0xd93
+#define MN_xend 0xd9b
+#define MN_valignd 0xda0
 #define MN_psignd (MN_vpsignd + 1)
-#define MN_vpsignd 0xd58
-#define MN_bound 0xd60
-#define MN_slod 0xd66
-#define MN_vfmaddsub231pd 0xd6b
-#define MN_vfmsub231pd 0xd7a
-#define MN_vfnmsub231pd 0xd86
-#define MN_vfmsubadd231pd 0xd93
-#define MN_vfmadd231pd 0xda2
-#define MN_vfnmadd231pd 0xdae
-#define MN_vfmaddsub132pd 0xdbb
-#define MN_vfmsub132pd 0xdca
-#define MN_vfnmsub132pd 0xdd6
-#define MN_vfmsubadd132pd 0xde3
-#define MN_vfmadd132pd 0xdf2
-#define MN_vfnmadd132pd 0xdfe
-#define MN_vcvtph2pd 0xe0b
-#define MN_vpermi2pd 0xe15
-#define MN_cvtpi2pd 0xe1f
-#define MN_vpermil2pd 0xe28
-#define MN_vexp2pd 0xe33
+#define MN_vpsignd 0xda8
+#define MN_bound 0xdb0
+#define MN_slod 0xdb6
+#define MN_vfmaddsub231pd 0xdbb
+#define MN_vfmsub231pd 0xdca
+#define MN_vfnmsub231pd 0xdd6
+#define MN_vfmsubadd231pd 0xde3
+#define MN_vfmadd231pd 0xdf2
+#define MN_vfnmadd231pd 0xdfe
+#define MN_vfmaddsub132pd 0xe0b
+#define MN_vfmsub132pd 0xe1a
+#define MN_vfnmsub132pd 0xe26
+#define MN_vfmsubadd132pd 0xe33
+#define MN_vfmadd132pd 0xe42
+#define MN_vfnmadd132pd 0xe4e
+#define MN_vcvtph2pd 0xe5b
+#define MN_vpermi2pd 0xe65
+#define MN_cvtpi2pd 0xe6f
+#define MN_vpermil2pd 0xe78
+#define MN_vexp2pd 0xe83
 #define MN_cvtdq2pd (MN_vcvtdq2pd + 1)
-#define MN_vcvtdq2pd 0xe3b
-#define MN_vcvtudq2pd 0xe45
-#define MN_vcvtqq2pd 0xe50
-#define MN_vcvtuqq2pd 0xe5a
+#define MN_vcvtdq2pd 0xe8b
+#define MN_vcvtudq2pd 0xe95
+#define MN_vcvtqq2pd 0xea0
+#define MN_vcvtuqq2pd 0xeaa
 #define MN_cvtps2pd (MN_vcvtps2pd + 1)
-#define MN_vcvtps2pd 0xe65
-#define MN_vpermt2pd 0xe6f
-#define MN_vfmaddsub213pd 0xe79
-#define MN_vfmsub213pd 0xe88
-#define MN_vfnmsub213pd 0xe94
-#define MN_vfmsubadd213pd 0xea1
-#define MN_vfmadd213pd 0xeb0
-#define MN_vfnmadd213pd 0xebc
-#define MN_vrcp14pd 0xec9
-#define MN_vrsqrt14pd 0xed2
-#define MN_vrcp28pd 0xedd
-#define MN_vrsqrt28pd 0xee6
+#define MN_vcvtps2pd 0xeb5
+#define MN_vpermt2pd 0xebf
+#define MN_vfmaddsub213pd 0xec9
+#define MN_vfmsub213pd 0xed8
+#define MN_vfnmsub213pd 0xee4
+#define MN_vfmsubadd213pd 0xef1
+#define MN_vfmadd213pd 0xf00
+#define MN_vfnmadd213pd 0xf0c
+#define MN_vrcp14pd 0xf19
+#define MN_vrsqrt14pd 0xf22
+#define MN_vrcp28pd 0xf2d
+#define MN_vrsqrt28pd 0xf36
 #define MN_movapd (MN_vmovapd + 1)
-#define MN_vmovapd 0xef1
-#define MN_pswapd 0xef9
+#define MN_vmovapd 0xf41
+#define MN_pswapd 0xf49
 #define MN_subpd (MN_addsubpd + 3)
 #define MN_addsubpd (MN_vfmaddsubpd + 3)
-#define MN_vfmaddsubpd 0xf00
-#define MN_vaddsubpd 0xf0c
+#define MN_vfmaddsubpd 0xf50
+#define MN_vaddsubpd 0xf5c
 #define MN_hsubpd (MN_vhsubpd + 1)
-#define MN_vhsubpd 0xf16
-#define MN_vfmsubpd 0xf1e
-#define MN_vfnmsubpd 0xf27
-#define MN_vsubpd 0xf31
-#define MN_vgatherpf0dpd 0xf38
-#define MN_vscatterpf0dpd 0xf46
-#define MN_vgatherpf1dpd 0xf55
-#define MN_vscatterpf1dpd 0xf63
+#define MN_vhsubpd 0xf66
+#define MN_vfmsubpd 0xf6e
+#define MN_vfnmsubpd 0xf77
+#define MN_vsubpd 0xf81
+#define MN_vgatherpf0dpd 0xf88
+#define MN_vscatterpf0dpd 0xf96
+#define MN_vgatherpf1dpd 0xfa5
+#define MN_vscatterpf1dpd 0xfb3
 #define MN_addpd (MN_vfmsubaddpd + 6)
-#define MN_vfmsubaddpd 0xf72
+#define MN_vfmsubaddpd 0xfc2
 #define MN_haddpd (MN_vhaddpd + 1)
-#define MN_vhaddpd 0xf7e
-#define MN_vfmaddpd 0xf86
-#define MN_vfnmaddpd 0xf8f
-#define MN_vaddpd 0xf99
+#define MN_vhaddpd 0xfce
+#define MN_vfmaddpd 0xfd6
+#define MN_vfnmaddpd 0xfdf
+#define MN_vaddpd 0xfe9
 #define MN_andpd (MN_vexpandpd + 4)
-#define MN_vexpandpd 0xfa0
-#define MN_vandpd 0xfaa
+#define MN_vexpandpd 0xff0
+#define MN_vandpd 0xffa
 #define MN_blendpd (MN_vblendpd + 1)
-#define MN_vblendpd 0xfb1
+#define MN_vblendpd 0x1001
 #define MN_roundpd (MN_vroundpd + 1)
-#define MN_vroundpd 0xfba
-#define MN_vgatherdpd 0xfc3
-#define MN_vscatterdpd 0xfce
+#define MN_vroundpd 0x100a
+#define MN_vgatherdpd 0x1013
+#define MN_vscatterdpd 0x101e
 #define MN_cmpunordpd (MN_vcmpunordpd + 1)
-#define MN_vcmpunordpd 0xfda
+#define MN_vcmpunordpd 0x102a
 #define MN_cmpordpd (MN_vcmpordpd + 1)
-#define MN_vcmpordpd 0xfe6
-#define MN_vreducepd 0xff0
-#define MN_vrangepd 0xffa
-#define MN_vcmpngepd 0x1003
-#define MN_vcmpgepd 0x100d
-#define MN_vrndscalepd 0x1016
+#define MN_vcmpordpd 0x1036
+#define MN_vreducepd 0x1040
+#define MN_vrangepd 0x104a
+#define MN_vcmpngepd 0x1053
+#define MN_vcmpgepd 0x105d
+#define MN_vrndscalepd 0x1066
 #define MN_cmpnlepd (MN_vcmpnlepd + 1)
-#define MN_vcmpnlepd 0x1022
+#define MN_vcmpnlepd 0x1072
 #define MN_cmplepd (MN_vcmplepd + 1)
-#define MN_vcmplepd 0x102c
-#define MN_vcmpfalsepd 0x1035
-#define MN_vcmptruepd 0x1041
-#define MN_vscalefpd 0x104c
+#define MN_vcmplepd 0x107c
+#define MN_vcmpfalsepd 0x1085
+#define MN_vcmptruepd 0x1091
+#define MN_vscalefpd 0x109c
 #define MN_shufpd (MN_vshufpd + 1)
-#define MN_vshufpd 0x1056
+#define MN_vshufpd 0x10a6
 #define MN_unpckhpd (MN_vunpckhpd + 1)
-#define MN_vunpckhpd 0x105e
+#define MN_vunpckhpd 0x10ae
 #define MN_movhpd (MN_vmovhpd + 1)
-#define MN_vmovhpd 0x1068
+#define MN_vmovhpd 0x10b8
 #define MN_movmskpd (MN_vmovmskpd + 1)
-#define MN_vmovmskpd 0x1070
-#define MN_vpermilpd 0x107a
+#define MN_vmovmskpd 0x10c0
+#define MN_vpermilpd 0x10ca
 #define MN_unpcklpd (MN_vunpcklpd + 1)
-#define MN_vunpcklpd 0x1084
+#define MN_vunpcklpd 0x10d4
 #define MN_mulpd (MN_vmulpd + 1)
-#define MN_vmulpd 0x108e
+#define MN_vmulpd 0x10de
 #define MN_movlpd (MN_vmovlpd + 1)
-#define MN_vmovlpd 0x1095
-#define MN_vpcmpd 0x109d
-#define MN_vblendmpd 0x10a4
-#define MN_vfixupimmpd 0x10ae
-#define MN_vpermpd 0x10ba
+#define MN_vmovlpd 0x10e5
+#define MN_vpcmpd 0x10ed
+#define MN_vblendmpd 0x10f4
+#define MN_vfixupimmpd 0x10fe
+#define MN_vpermpd 0x110a
 #define MN_andnpd (MN_vandnpd + 1)
-#define MN_vandnpd 0x10c2
+#define MN_vandnpd 0x1112
 #define MN_minpd (MN_vminpd + 1)
-#define MN_vminpd 0x10ca
+#define MN_vminpd 0x111a
 #define MN_dppd (MN_vdppd + 1)
-#define MN_vdppd 0x10d1
+#define MN_vdppd 0x1121
 #define MN_cmppd (MN_vcmppd + 1)
-#define MN_vcmppd 0x10d7
-#define MN_vgetexppd 0x10de
-#define MN_vgatherpf0qpd 0x10e8
-#define MN_vscatterpf0qpd 0x10f6
-#define MN_vgatherpf1qpd 0x1105
-#define MN_vscatterpf1qpd 0x1113
-#define MN_vcmpunord_qpd 0x1122
-#define MN_vcmpord_qpd 0x1130
+#define MN_vcmppd 0x1127
+#define MN_vgetexppd 0x112e
+#define MN_vgatherpf0qpd 0x1138
+#define MN_vscatterpf0qpd 0x1146
+#define MN_vgatherpf1qpd 0x1155
+#define MN_vscatterpf1qpd 0x1163
+#define MN_vcmpunord_qpd 0x1172
+#define MN_vcmpord_qpd 0x1180
 #define MN_cmpneqpd (MN_vcmpneqpd + 1)
-#define MN_vcmpneqpd 0x113c
+#define MN_vcmpneqpd 0x118c
 #define MN_cmpeqpd (MN_vcmpeqpd + 1)
-#define MN_vcmpeqpd 0x1146
-#define MN_vcmpge_oqpd 0x114f
-#define MN_vcmple_oqpd 0x115b
-#define MN_vcmpfalse_oqpd 0x1167
-#define MN_vcmpneq_oqpd 0x1176
-#define MN_vcmpeq_oqpd 0x1183
-#define MN_vcmpgt_oqpd 0x118f
-#define MN_vcmplt_oqpd 0x119b
-#define MN_vgatherqpd 0x11a7
-#define MN_vscatterqpd 0x11b2
-#define MN_vcmpnge_uqpd 0x11be
-#define MN_vcmpnle_uqpd 0x11cb
-#define MN_vcmptrue_uqpd 0x11d8
-#define MN_vcmpneq_uqpd 0x11e6
-#define MN_vcmpeq_uqpd 0x11f3
-#define MN_vcmpngt_uqpd 0x11ff
-#define MN_vcmpnlt_uqpd 0x120c
+#define MN_vcmpeqpd 0x1196
+#define MN_vcmpge_oqpd 0x119f
+#define MN_vcmple_oqpd 0x11ab
+#define MN_vcmpfalse_oqpd 0x11b7
+#define MN_vcmpneq_oqpd 0x11c6
+#define MN_vcmpeq_oqpd 0x11d3
+#define MN_vcmpgt_oqpd 0x11df
+#define MN_vcmplt_oqpd 0x11eb
+#define MN_vgatherqpd 0x11f7
+#define MN_vscatterqpd 0x1202
+#define MN_vcmpnge_uqpd 0x120e
+#define MN_vcmpnle_uqpd 0x121b
+#define MN_vcmptrue_uqpd 0x1228
+#define MN_vcmpneq_uqpd 0x1236
+#define MN_vcmpeq_uqpd 0x1243
+#define MN_vcmpngt_uqpd 0x124f
+#define MN_vcmpnlt_uqpd 0x125c
 #define MN_orpd (MN_vorpd + 1)
-#define MN_vorpd 0x1219
+#define MN_vorpd 0x1269
 #define MN_xorpd (MN_vxorpd + 1)
-#define MN_vxorpd 0x121f
-#define MN_vcmpunord_spd 0x1226
-#define MN_vcmpord_spd 0x1234
-#define MN_vcmpge_ospd 0x1240
-#define MN_vcmple_ospd 0x124c
-#define MN_vcmpfalse_ospd 0x1258
-#define MN_vcmpneq_ospd 0x1267
-#define MN_vcmpeq_ospd 0x1274
-#define MN_vcmpgt_ospd 0x1280
-#define MN_vcmplt_ospd 0x128c
-#define MN_vfpclasspd 0x1298
-#define MN_incsspd 0x12a3
-#define MN_rdsspd 0x12ab
-#define MN_vcompresspd 0x12b2
-#define MN_vcmpnge_uspd 0x12be
-#define MN_vcmpnle_uspd 0x12cb
-#define MN_vcmptrue_uspd 0x12d8
-#define MN_vcmpneq_uspd 0x12e6
-#define MN_vcmpeq_uspd 0x12f3
-#define MN_vcmpngt_uspd 0x12ff
-#define MN_vcmpnlt_uspd 0x130c
-#define MN_vcmpngtpd 0x1319
-#define MN_vcmpgtpd 0x1323
+#define MN_vxorpd 0x126f
+#define MN_vcmpunord_spd 0x1276
+#define MN_vcmpord_spd 0x1284
+#define MN_vcmpge_ospd 0x1290
+#define MN_vcmple_ospd 0x129c
+#define MN_vcmpfalse_ospd 0x12a8
+#define MN_vcmpneq_ospd 0x12b7
+#define MN_vcmpeq_ospd 0x12c4
+#define MN_vcmpgt_ospd 0x12d0
+#define MN_vcmplt_ospd 0x12dc
+#define MN_vfpclasspd 0x12e8
+#define MN_incsspd 0x12f3
+#define MN_rdsspd 0x12fb
+#define MN_vcompresspd 0x1302
+#define MN_vcmpnge_uspd 0x130e
+#define MN_vcmpnle_uspd 0x131b
+#define MN_vcmptrue_uspd 0x1328
+#define MN_vcmpneq_uspd 0x1336
+#define MN_vcmpeq_uspd 0x1343
+#define MN_vcmpngt_uspd 0x134f
+#define MN_vcmpnlt_uspd 0x135c
+#define MN_vcmpngtpd 0x1369
+#define MN_vcmpgtpd 0x1373
 #define MN_cmpnltpd (MN_vcmpnltpd + 1)
-#define MN_vcmpnltpd 0x132c
+#define MN_vcmpnltpd 0x137c
 #define MN_cmpltpd (MN_vcmpltpd + 1)
-#define MN_vcmpltpd 0x1336
-#define MN_vgetmantpd 0x133f
+#define MN_vcmpltpd 0x1386
+#define MN_vgetmantpd 0x138f
 #define MN_movntpd (MN_vmovntpd + 1)
-#define MN_vmovntpd 0x134a
+#define MN_vmovntpd 0x139a
 #define MN_sqrtpd (MN_vsqrtpd + 1)
-#define MN_vsqrtpd 0x1353
-#define MN_vtestpd 0x135b
+#define MN_vsqrtpd 0x13a3
+#define MN_vtestpd 0x13ab
 #define MN_movupd (MN_vmovupd + 1)
-#define MN_vmovupd 0x1363
+#define MN_vmovupd 0x13b3
 #define MN_blendvpd (MN_vblendvpd + 1)
-#define MN_vblendvpd 0x136b
+#define MN_vblendvpd 0x13bb
 #define MN_divpd (MN_vdivpd + 1)
-#define MN_vdivpd 0x1375
-#define MN_vmaskmovpd 0x137c
+#define MN_vdivpd 0x13c5
+#define MN_vmaskmovpd 0x13cc
 #define MN_maxpd (MN_vmaxpd + 1)
-#define MN_vmaxpd 0x1387
-#define MN_vfrczpd 0x138e
-#define MN_vpcomeqd 0x1396
-#define MN_vpcomneqd 0x139f
-#define MN_vpcmpneqd 0x13a9
+#define MN_vmaxpd 0x13d7
+#define MN_vfrczpd 0x13de
+#define MN_vpcomeqd 0x13e6
+#define MN_vpcomneqd 0x13ef
+#define MN_vpcmpneqd 0x13f9
 #define MN_pcmpeqd (MN_vpcmpeqd + 1)
-#define MN_vpcmpeqd 0x13b3
-#define MN_vpgatherqd 0x13bc
-#define MN_vpscatterqd 0x13c7
-#define MN_vpmovusqd 0x13d3
-#define MN_vpmovsqd 0x13dd
-#define MN_vpmovqd 0x13e6
-#define MN_shrd 0x13ee
-#define MN_kord 0x13f3
-#define MN_kxnord 0x13f8
-#define MN_vpord 0x13ff
-#define MN_vprord 0x1405
+#define MN_vpcmpeqd 0x1403
+#define MN_vpgatherqd 0x140c
+#define MN_vpscatterqd 0x1417
+#define MN_vpmovusqd 0x1423
+#define MN_vpmovsqd 0x142d
+#define MN_vpmovqd 0x1436
+#define MN_shrd 0x143e
+#define MN_kord 0x1443
+#define MN_kxnord 0x1448
+#define MN_vpord 0x144f
+#define MN_vprord 0x1455
 #define MN_word (MN_aword + 1)
-#define MN_aword 0x140c
+#define MN_aword 0x145c
 #define MN_dword (MN_adword + 1)
-#define MN_adword 0x1412
-#define MN_kxord 0x1419
-#define MN_vpxord 0x141f
+#define MN_adword 0x1462
+#define MN_kxord 0x1469
+#define MN_vpxord 0x146f
 #define MN_pinsrd (MN_vpinsrd + 1)
-#define MN_vpinsrd 0x1426
-#define MN_kshiftrd 0x142e
+#define MN_vpinsrd 0x1476
+#define MN_kshiftrd 0x147e
 #define MN_pextrd (MN_vpextrd + 1)
-#define MN_vpextrd 0x1437
-#define MN_vfmsub231sd 0x143f
-#define MN_vfnmsub231sd 0x144b
-#define MN_vfmadd231sd 0x1458
-#define MN_vfnmadd231sd 0x1464
-#define MN_vfmsub132sd 0x1471
-#define MN_vfnmsub132sd 0x147d
-#define MN_vfmadd132sd 0x148a
-#define MN_vfnmadd132sd 0x1496
-#define MN_vcvtsh2sd 0x14a3
+#define MN_vpextrd 0x1487
+#define MN_vfmsub231sd 0x148f
+#define MN_vfnmsub231sd 0x149b
+#define MN_vfmadd231sd 0x14a8
+#define MN_vfnmadd231sd 0x14b4
+#define MN_vfmsub132sd 0x14c1
+#define MN_vfnmsub132sd 0x14cd
+#define MN_vfmadd132sd 0x14da
+#define MN_vfnmadd132sd 0x14e6
+#define MN_vcvtsh2sd 0x14f3
 #define MN_cvtsi2sd (MN_vcvtsi2sd + 1)
-#define MN_vcvtsi2sd 0x14ad
-#define MN_vcvtusi2sd 0x14b7
+#define MN_vcvtsi2sd 0x14fd
+#define MN_vcvtusi2sd 0x1507
 #define MN_cvtss2sd (MN_vcvtss2sd + 1)
-#define MN_vcvtss2sd 0x14c2
-#define MN_vfmsub213sd 0x14cc
-#define MN_vfnmsub213sd 0x14d8
-#define MN_vfmadd213sd 0x14e5
-#define MN_vfnmadd213sd 0x14f1
-#define MN_vrcp14sd 0x14fe
-#define MN_vrsqrt14sd 0x1507
-#define MN_vrcp28sd 0x1512
-#define MN_vrsqrt28sd 0x151b
+#define MN_vcvtss2sd 0x1512
+#define MN_vfmsub213sd 0x151c
+#define MN_vfnmsub213sd 0x1528
+#define MN_vfmadd213sd 0x1535
+#define MN_vfnmadd213sd 0x1541
+#define MN_vrcp14sd 0x154e
+#define MN_vrsqrt14sd 0x1557
+#define MN_vrcp28sd 0x1562
+#define MN_vrsqrt28sd 0x156b
 #define MN_pabsd (MN_vpabsd + 1)
-#define MN_vpabsd 0x1526
+#define MN_vpabsd 0x1576
 #define MN_subsd (MN_vfmsubsd + 3)
-#define MN_vfmsubsd 0x152d
-#define MN_vfnmsubsd 0x1536
-#define MN_vsubsd 0x1540
+#define MN_vfmsubsd 0x157d
+#define MN_vfnmsubsd 0x1586
+#define MN_vsubsd 0x1590
 #define MN_addsd (MN_vfmaddsd + 3)
-#define MN_vfmaddsd 0x1547
-#define MN_vfnmaddsd 0x1550
-#define MN_vaddsd 0x155a
+#define MN_vfmaddsd 0x1597
+#define MN_vfnmaddsd 0x15a0
+#define MN_vaddsd 0x15aa
 #define MN_roundsd (MN_vroundsd + 1)
-#define MN_vroundsd 0x1561
+#define MN_vroundsd 0x15b1
 #define MN_cmpunordsd (MN_vcmpunordsd + 1)
-#define MN_vcmpunordsd 0x156a
+#define MN_vcmpunordsd 0x15ba
 #define MN_cmpordsd (MN_vcmpordsd + 1)
-#define MN_vcmpordsd 0x1576
-#define MN_vreducesd 0x1580
-#define MN_vrangesd 0x158a
-#define MN_vcmpngesd 0x1593
-#define MN_vcmpgesd 0x159d
-#define MN_vrndscalesd 0x15a6
+#define MN_vcmpordsd 0x15c6
+#define MN_vreducesd 0x15d0
+#define MN_vrangesd 0x15da
+#define MN_vcmpngesd 0x15e3
+#define MN_vcmpgesd 0x15ed
+#define MN_vrndscalesd 0x15f6
 #define MN_cmpnlesd (MN_vcmpnlesd + 1)
-#define MN_vcmpnlesd 0x15b2
+#define MN_vcmpnlesd 0x1602
 #define MN_cmplesd (MN_vcmplesd + 1)
-#define MN_vcmplesd 0x15bc
-#define MN_vcmpfalsesd 0x15c5
-#define MN_vcmptruesd 0x15d1
-#define MN_vscalefsd 0x15dc
+#define MN_vcmplesd 0x160c
+#define MN_vcmpfalsesd 0x1615
+#define MN_vcmptruesd 0x1621
+#define MN_vscalefsd 0x162c
 #define MN_comisd (MN_ucomisd + 1)
 #define MN_ucomisd (MN_vucomisd + 1)
-#define MN_vucomisd 0x15e6
-#define MN_vcomisd 0x15ef
+#define MN_vucomisd 0x1636
+#define MN_vcomisd 0x163f
 #define MN_mulsd (MN_vmulsd + 1)
-#define MN_vmulsd 0x15f7
-#define MN_vfixupimmsd 0x15fe
+#define MN_vmulsd 0x1647
+#define MN_vfixupimmsd 0x164e
 #define MN_minsd (MN_pminsd + 1)
 #define MN_pminsd (MN_vpminsd + 1)
-#define MN_vpminsd 0x160a
-#define MN_vminsd 0x1612
+#define MN_vpminsd 0x165a
+#define MN_vminsd 0x1662
 #define MN_cmpsd (MN_vcmpsd + 1)
-#define MN_vcmpsd 0x1619
-#define MN_vgetexpsd 0x1620
-#define MN_vcmpunord_qsd 0x162a
-#define MN_vcmpord_qsd 0x1638
+#define MN_vcmpsd 0x1669
+#define MN_vgetexpsd 0x1670
+#define MN_vcmpunord_qsd 0x167a
+#define MN_vcmpord_qsd 0x1688
 #define MN_cmpneqsd (MN_vcmpneqsd + 1)
-#define MN_vcmpneqsd 0x1644
+#define MN_vcmpneqsd 0x1694
 #define MN_cmpeqsd (MN_vcmpeqsd + 1)
-#define MN_vcmpeqsd 0x164e
-#define MN_vcmpge_oqsd 0x1657
-#define MN_vcmple_oqsd 0x1663
-#define MN_vcmpfalse_oqsd 0x166f
-#define MN_vcmpneq_oqsd 0x167e
-#define MN_vcmpeq_oqsd 0x168b
-#define MN_vcmpgt_oqsd 0x1697
-#define MN_vcmplt_oqsd 0x16a3
-#define MN_vcmpnge_uqsd 0x16af
-#define MN_vcmpnle_uqsd 0x16bc
-#define MN_vcmptrue_uqsd 0x16c9
-#define MN_vcmpneq_uqsd 0x16d7
-#define MN_vcmpeq_uqsd 0x16e4
-#define MN_vcmpngt_uqsd 0x16f0
-#define MN_vcmpnlt_uqsd 0x16fd
-#define MN_vcmpunord_ssd 0x170a
-#define MN_vcmpord_ssd 0x1718
-#define MN_vpdpbssd 0x1724
-#define MN_tdpbssd 0x172d
-#define MN_vpcompressd 0x1735
-#define MN_vcmpge_ossd 0x1741
-#define MN_vcmple_ossd 0x174d
-#define MN_vcmpfalse_ossd 0x1759
-#define MN_vcmpneq_ossd 0x1768
-#define MN_vcmpeq_ossd 0x1775
-#define MN_vcmpgt_ossd 0x1781
-#define MN_vcmplt_ossd 0x178d
-#define MN_wrssd 0x1799
-#define MN_vfpclasssd 0x179f
-#define MN_vcmpnge_ussd 0x17aa
-#define MN_vcmpnle_ussd 0x17b7
-#define MN_vcmptrue_ussd 0x17c4
-#define MN_vcmpneq_ussd 0x17d2
-#define MN_vcmpeq_ussd 0x17df
-#define MN_vcmpngt_ussd 0x17eb
-#define MN_vcmpnlt_ussd 0x17f8
-#define MN_wrussd 0x1805
-#define MN_vp4dpwssd 0x180c
-#define MN_vpdpwssd 0x1816
-#define MN_vcmpngtsd 0x181f
-#define MN_vcmpgtsd 0x1829
+#define MN_vcmpeqsd 0x169e
+#define MN_vcmpge_oqsd 0x16a7
+#define MN_vcmple_oqsd 0x16b3
+#define MN_vcmpfalse_oqsd 0x16bf
+#define MN_vcmpneq_oqsd 0x16ce
+#define MN_vcmpeq_oqsd 0x16db
+#define MN_vcmpgt_oqsd 0x16e7
+#define MN_vcmplt_oqsd 0x16f3
+#define MN_vcmpnge_uqsd 0x16ff
+#define MN_vcmpnle_uqsd 0x170c
+#define MN_vcmptrue_uqsd 0x1719
+#define MN_vcmpneq_uqsd 0x1727
+#define MN_vcmpeq_uqsd 0x1734
+#define MN_vcmpngt_uqsd 0x1740
+#define MN_vcmpnlt_uqsd 0x174d
+#define MN_vcmpunord_ssd 0x175a
+#define MN_vcmpord_ssd 0x1768
+#define MN_vpdpbssd 0x1774
+#define MN_tdpbssd 0x177d
+#define MN_vpcompressd 0x1785
+#define MN_vcmpge_ossd 0x1791
+#define MN_vcmple_ossd 0x179d
+#define MN_vcmpfalse_ossd 0x17a9
+#define MN_vcmpneq_ossd 0x17b8
+#define MN_vcmpeq_ossd 0x17c5
+#define MN_vcmpgt_ossd 0x17d1
+#define MN_vcmplt_ossd 0x17dd
+#define MN_wrssd 0x17e9
+#define MN_vfpclasssd 0x17ef
+#define MN_vcmpnge_ussd 0x17fa
+#define MN_vcmpnle_ussd 0x1807
+#define MN_vcmptrue_ussd 0x1814
+#define MN_vcmpneq_ussd 0x1822
+#define MN_vcmpeq_ussd 0x182f
+#define MN_vcmpngt_ussd 0x183b
+#define MN_vcmpnlt_ussd 0x1848
+#define MN_wrussd 0x1855
+#define MN_vp4dpwssd 0x185c
+#define MN_vpdpwssd 0x1866
+#define MN_vcmpngtsd 0x186f
+#define MN_vcmpgtsd 0x1879
 #define MN_cmpnltsd (MN_vcmpnltsd + 1)
-#define MN_vcmpnltsd 0x1832
+#define MN_vcmpnltsd 0x1882
 #define MN_cmpltsd (MN_vcmpltsd + 1)
-#define MN_vcmpltsd 0x183c
-#define MN_vgetmantsd 0x1845
-#define MN_movntsd 0x1850
+#define MN_vcmpltsd 0x188c
+#define MN_vgetmantsd 0x1895
+#define MN_movntsd 0x18a0
 #define MN_sqrtsd (MN_vsqrtsd + 1)
-#define MN_vsqrtsd 0x1858
-#define MN_vbroadcastsd 0x1860
-#define MN_vpdpbusd 0x186d
-#define MN_tdpbusd 0x1876
-#define MN_vpdpwusd 0x187e
+#define MN_vsqrtsd 0x18a8
+#define MN_vbroadcastsd 0x18b0
+#define MN_vpdpbusd 0x18bd
+#define MN_tdpbusd 0x18c6
+#define MN_vpdpwusd 0x18ce
 #define MN_divsd (MN_vdivsd + 1)
-#define MN_vdivsd 0x1887
+#define MN_vdivsd 0x18d7
 #define MN_movsd (MN_vmovsd + 1)
-#define MN_vmovsd 0x188e
+#define MN_vmovsd 0x18de
 #define MN_maxsd (MN_pmaxsd + 1)
 #define MN_pmaxsd (MN_vpmaxsd + 1)
-#define MN_vpmaxsd 0x1895
-#define MN_vmaxsd 0x189d
-#define MN_vfrczsd 0x18a4
-#define MN_vp2intersectd 0x18ac
-#define MN_vpconflictd 0x18ba
-#define MN_vpcomgtd 0x18c6
+#define MN_vpmaxsd 0x18e5
+#define MN_vmaxsd 0x18ed
+#define MN_vfrczsd 0x18f4
+#define MN_vp2intersectd 0x18fc
+#define MN_vpconflictd 0x190a
+#define MN_vpcomgtd 0x1916
 #define MN_pcmpgtd (MN_vpcmpgtd + 1)
-#define MN_vpcmpgtd 0x18cf
-#define MN_cltd 0x18d8
-#define MN_vpcomltd 0x18dd
-#define MN_vpcmpnltd 0x18e6
-#define MN_vpcmpltd 0x18f0
-#define MN_vpopcntd 0x18f9
-#define MN_vplzcntd 0x1902
-#define MN_knotd 0x190b
-#define MN_vprotd 0x1911
+#define MN_vpcmpgtd 0x191f
+#define MN_cltd 0x1928
+#define MN_vpcomltd 0x192d
+#define MN_vpcmpnltd 0x1936
+#define MN_vpcmpltd 0x1940
+#define MN_vpopcntd 0x1949
+#define MN_vplzcntd 0x1952
+#define MN_knotd 0x195b
+#define MN_vprotd 0x1961
 #define MN_std (MN_vpbroadcastd + 9)
-#define MN_vpbroadcastd 0x1918
-#define MN_ktestd 0x1925
-#define MN_kortestd 0x192c
-#define MN_cwtd 0x1935
-#define MN_vpcomgeud 0x193a
-#define MN_vpcomleud 0x1944
-#define MN_vpcmpnleud 0x194e
-#define MN_vpcmpleud 0x1959
-#define MN_vpcomfalseud 0x1963
-#define MN_vpcomtrueud 0x1970
-#define MN_vpcomud 0x197c
+#define MN_vpbroadcastd 0x1968
+#define MN_ktestd 0x1975
+#define MN_kortestd 0x197c
+#define MN_cwtd 0x1985
+#define MN_vpcomgeud 0x198a
+#define MN_vpcomleud 0x1994
+#define MN_vpcmpnleud 0x199e
+#define MN_vpcmpleud 0x19a9
+#define MN_vpcomfalseud 0x19b3
+#define MN_vpcomtrueud 0x19c0
+#define MN_vpcomud 0x19cc
 #define MN_pminud (MN_vpminud + 1)
-#define MN_vpminud 0x1984
-#define MN_vpcmpud 0x198c
-#define MN_vpcomequd 0x1994
-#define MN_vpcomnequd 0x199e
-#define MN_vpcmpnequd 0x19a9
-#define MN_vpcmpequd 0x19b4
-#define MN_vpdpbsud 0x19be
-#define MN_tdpbsud 0x19c7
-#define MN_vpdpwsud 0x19cf
-#define MN_vpcomgtud 0x19d8
-#define MN_vpcomltud 0x19e2
-#define MN_vpcmpnltud 0x19ec
-#define MN_vpcmpltud 0x19f7
-#define MN_vpdpbuud 0x1a01
-#define MN_tdpbuud 0x1a0a
-#define MN_vpdpwuud 0x1a12
+#define MN_vpminud 0x19d4
+#define MN_vpcmpud 0x19dc
+#define MN_vpcomequd 0x19e4
+#define MN_vpcomnequd 0x19ee
+#define MN_vpcmpnequd 0x19f9
+#define MN_vpcmpequd 0x1a04
+#define MN_vpdpbsud 0x1a0e
+#define MN_tdpbsud 0x1a17
+#define MN_vpdpwsud 0x1a1f
+#define MN_vpcomgtud 0x1a28
+#define MN_vpcomltud 0x1a32
+#define MN_vpcmpnltud 0x1a3c
+#define MN_vpcmpltud 0x1a47
+#define MN_vpdpbuud 0x1a51
+#define MN_tdpbuud 0x1a5a
+#define MN_vpdpwuud 0x1a62
 #define MN_pmaxud (MN_vpmaxud + 1)
-#define MN_vpmaxud 0x1a1b
-#define MN_vpsravd 0x1a23
-#define MN_vpshldvd 0x1a2b
-#define MN_vpshrdvd 0x1a34
-#define MN_vpsllvd 0x1a3d
-#define MN_vprolvd 0x1a45
-#define MN_vpsrlvd 0x1a4d
+#define MN_vpmaxud 0x1a6b
+#define MN_vpsravd 0x1a73
+#define MN_vpshldvd 0x1a7b
+#define MN_vpshrdvd 0x1a84
+#define MN_vpsllvd 0x1a8d
+#define MN_vprolvd 0x1a95
+#define MN_vpsrlvd 0x1a9d
 #define MN_invd (MN_wbinvd + 2)
-#define MN_wbinvd 0x1a55
-#define MN_wbnoinvd 0x1a5c
+#define MN_wbinvd 0x1aa5
+#define MN_wbnoinvd 0x1aac
 #define MN_movd (MN_kmovd + 1)
 #define MN_kmovd (MN_vpmaskmovd + 5)
-#define MN_vpmaskmovd 0x1a65
-#define MN_vmovd 0x1a70
-#define MN_vprorvd 0x1a76
-#define MN_vphsubwd 0x1a7e
-#define MN_cwd 0x1a87
-#define MN_vphaddwd 0x1a8b
+#define MN_vpmaskmovd 0x1ab5
+#define MN_vmovd 0x1ac0
+#define MN_vprorvd 0x1ac6
+#define MN_vphsubwd 0x1ace
+#define MN_cwd 0x1ad7
+#define MN_vphaddwd 0x1adb
 #define MN_pmaddwd (MN_vpmaddwd + 1)
-#define MN_vpmaddwd 0x1a94
+#define MN_vpmaddwd 0x1ae4
 #define MN_punpckhwd (MN_vpunpckhwd + 1)
-#define MN_vpunpckhwd 0x1a9d
-#define MN_kunpckwd 0x1aa8
+#define MN_vpunpckhwd 0x1aed
+#define MN_kunpckwd 0x1af8
 #define MN_punpcklwd (MN_vpunpcklwd + 1)
-#define MN_vpunpcklwd 0x1ab1
-#define MN_vpmacswd 0x1abc
-#define MN_vpmadcswd 0x1ac5
-#define MN_vpmacsswd 0x1acf
-#define MN_vpmadcsswd 0x1ad9
-#define MN_vphadduwd 0x1ae4
+#define MN_vpunpcklwd 0x1b01
+#define MN_vpmacswd 0x1b0c
+#define MN_vpmadcswd 0x1b15
+#define MN_vpmacsswd 0x1b1f
+#define MN_vpmadcsswd 0x1b29
+#define MN_vphadduwd 0x1b34
 #define MN_pmovsxwd (MN_vpmovsxwd + 1)
-#define MN_vpmovsxwd 0x1aee
+#define MN_vpmovsxwd 0x1b3e
 #define MN_pmovzxwd (MN_vpmovzxwd + 1)
-#define MN_vpmovzxwd 0x1af8
-#define MN_movsxd 0x1b02
-#define MN_fldl2e 0x1b09
-#define MN_jae 0x1b10
-#define MN_jnae 0x1b14
-#define MN_setnae 0x1b19
-#define MN_setzunae 0x1b20
+#define MN_vpmovzxwd 0x1b48
+#define MN_movsxd 0x1b52
+#define MN_fldl2e 0x1b59
+#define MN_jae 0x1b60
+#define MN_jnae 0x1b64
+#define MN_ccmpnae 0x1b69
+#define MN_setnae 0x1b71
+#define MN_ctestnae 0x1b78
+#define MN_setzunae 0x1b81
 #define MN_cmovnae (MN_fcmovnae + 1)
-#define MN_fcmovnae 0x1b29
-#define MN_setae 0x1b32
-#define MN_setzuae 0x1b38
+#define MN_fcmovnae 0x1b8a
+#define MN_ccmpae 0x1b93
+#define MN_setae 0x1b9a
+#define MN_ctestae 0x1ba0
+#define MN_setzuae 0x1ba8
 #define MN_cmovae (MN_fcmovae + 1)
-#define MN_fcmovae 0x1b40
-#define MN_jbe 0x1b48
-#define MN_jnbe 0x1b4c
-#define MN_setnbe 0x1b51
-#define MN_setzunbe 0x1b58
+#define MN_fcmovae 0x1bb0
+#define MN_jbe 0x1bb8
+#define MN_jnbe 0x1bbc
+#define MN_ccmpnbe 0x1bc1
+#define MN_setnbe 0x1bc9
+#define MN_ctestnbe 0x1bd0
+#define MN_setzunbe 0x1bd9
 #define MN_cmovnbe (MN_fcmovnbe + 1)
-#define MN_fcmovnbe 0x1b61
-#define MN_setbe 0x1b6a
-#define MN_setzube 0x1b70
+#define MN_fcmovnbe 0x1be2
+#define MN_ccmpbe 0x1beb
+#define MN_setbe 0x1bf2
+#define MN_ctestbe 0x1bf8
+#define MN_setzube 0x1c00
 #define MN_movbe (MN_cmovbe + 1)
 #define MN_cmovbe (MN_fcmovbe + 1)
-#define MN_fcmovbe 0x1b78
-#define MN_lfence 0x1b80
-#define MN_mfence 0x1b87
-#define MN_sfence 0x1b8e
-#define MN_cwde 0x1b95
-#define MN_ffree 0x1b9a
-#define MN_jge 0x1ba0
-#define MN_jnge 0x1ba4
-#define MN_setnge 0x1ba9
-#define MN_setzunge 0x1bb0
-#define MN_cmovnge 0x1bb9
-#define MN_pfcmpge 0x1bc1
-#define MN_setge 0x1bc9
-#define MN_setzuge 0x1bcf
-#define MN_cmovge 0x1bd7
-#define MN_je 0x1bde
-#define MN_fscale 0x1be1
-#define MN_jle 0x1be8
-#define MN_jnle 0x1bec
-#define MN_setnle 0x1bf1
-#define MN_setzunle 0x1bf8
-#define MN_cmovnle 0x1c01
-#define MN_setle 0x1c09
-#define MN_setzule 0x1c0f
-#define MN_cmovle 0x1c17
-#define MN_vmresume 0x1c1e
-#define MN_jne 0x1c27
-#define MN_repne 0x1c2b
-#define MN_loopne 0x1c31
-#define MN_setne 0x1c38
-#define MN_setzune 0x1c3e
+#define MN_fcmovbe 0x1c08
+#define MN_lfence 0x1c10
+#define MN_mfence 0x1c17
+#define MN_sfence 0x1c1e
+#define MN_cwde 0x1c25
+#define MN_ffree 0x1c2a
+#define MN_jge 0x1c30
+#define MN_jnge 0x1c34
+#define MN_ccmpnge 0x1c39
+#define MN_setnge 0x1c41
+#define MN_ctestnge 0x1c48
+#define MN_setzunge 0x1c51
+#define MN_cmovnge 0x1c5a
+#define MN_ccmpge 0x1c62
+#define MN_pfcmpge 0x1c69
+#define MN_setge 0x1c71
+#define MN_ctestge 0x1c77
+#define MN_setzuge 0x1c7f
+#define MN_cmovge 0x1c87
+#define MN_je 0x1c8e
+#define MN_fscale 0x1c91
+#define MN_jle 0x1c98
+#define MN_jnle 0x1c9c
+#define MN_ccmpnle 0x1ca1
+#define MN_setnle 0x1ca9
+#define MN_ctestnle 0x1cb0
+#define MN_setzunle 0x1cb9
+#define MN_cmovnle 0x1cc2
+#define MN_ccmple 0x1cca
+#define MN_setle 0x1cd1
+#define MN_ctestle 0x1cd7
+#define MN_setzule 0x1cdf
+#define MN_cmovle 0x1ce7
+#define MN_vmresume 0x1cee
+#define MN_jne 0x1cf7
+#define MN_repne 0x1cfb
+#define MN_ccmpne 0x1d01
+#define MN_loopne 0x1d08
+#define MN_setne 0x1d0f
+#define MN_ctestne 0x1d15
+#define MN_setzune 0x1d1d
 #define MN_cmovne (MN_fcmovne + 1)
-#define MN_fcmovne 0x1c46
-#define MN_repe 0x1c4e
-#define MN_jpe 0x1c53
-#define MN_loope 0x1c57
-#define MN_setpe 0x1c5d
-#define MN_setzupe 0x1c63
-#define MN_cmovpe 0x1c6b
-#define MN_cdqe 0x1c72
-#define MN_xacquire 0x1c77
-#define MN_xstore 0x1c80
-#define MN_rdfsbase 0x1c87
-#define MN_wrfsbase 0x1c90
-#define MN_rdgsbase 0x1c99
-#define MN_wrgsbase 0x1ca2
-#define MN_tilerelease 0x1cab
-#define MN_xrelease 0x1cb7
+#define MN_fcmovne 0x1d25
+#define MN_repe 0x1d2d
+#define MN_jpe 0x1d32
+#define MN_ccmpe 0x1d36
+#define MN_loope 0x1d3c
+#define MN_setpe 0x1d42
+#define MN_setzupe 0x1d48
+#define MN_cmovpe 0x1d50
+#define MN_cdqe 0x1d57
+#define MN_xacquire 0x1d5c
+#define MN_xstore 0x1d65
+#define MN_rdfsbase 0x1d6c
+#define MN_wrfsbase 0x1d75
+#define MN_rdgsbase 0x1d7e
+#define MN_wrgsbase 0x1d87
+#define MN_tilerelease 0x1d90
+#define MN_xrelease 0x1d9c
 #define MN_pause (MN_tpause + 1)
-#define MN_tpause 0x1cc0
-#define MN_pvalidate 0x1cc7
-#define MN_rmpupdate 0x1cd1
-#define MN_sete 0x1cdb
-#define MN_vmwrite 0x1ce0
-#define MN_ptwrite 0x1ce8
-#define MN_cldemote 0x1cf0
-#define MN_sha1nexte 0x1cf9
-#define MN_setzue 0x1d03
-#define MN_leave 0x1d0a
-#define MN_fsave 0x1d10
-#define MN_vmsave 0x1d16
-#define MN_fnsave 0x1d1d
+#define MN_tpause 0x1da5
+#define MN_pvalidate 0x1dac
+#define MN_rmpupdate 0x1db6
+#define MN_sete 0x1dc0
+#define MN_vmwrite 0x1dc5
+#define MN_ptwrite 0x1dcd
+#define MN_cldemote 0x1dd5
+#define MN_cteste 0x1dde
+#define MN_sha1nexte 0x1de5
+#define MN_setzue 0x1def
+#define MN_leave 0x1df6
+#define MN_fsave 0x1dfc
+#define MN_vmsave 0x1e02
+#define MN_fnsave 0x1e09
 #define MN_xsave (MN_fxsave + 1)
-#define MN_fxsave 0x1d24
+#define MN_fxsave 0x1e10
 #define MN_cmove (MN_fcmove + 1)
-#define MN_fcmove 0x1d2b
-#define MN_serialize 0x1d32
-#define MN_vmxoff 0x1d3c
-#define MN_lahf 0x1d43
-#define MN_sahf 0x1d48
-#define MN_pushf 0x1d4d
-#define MN_popf 0x1d53
-#define MN_bsf 0x1d58
-#define MN_retf 0x1d5c
-#define MN_neg 0x1d61
-#define MN_ldtilecfg 0x1d65
-#define MN_sttilecfg 0x1d6f
+#define MN_fcmove 0x1e17
+#define MN_serialize 0x1e1e
+#define MN_vmxoff 0x1e28
+#define MN_lahf 0x1e2f
+#define MN_sahf 0x1e34
+#define MN_pushf 0x1e39
+#define MN_ccmpf 0x1e3f
+#define MN_popf 0x1e45
+#define MN_bsf 0x1e4a
+#define MN_retf 0x1e4e
+#define MN_ctestf 0x1e53
+#define MN_neg 0x1e5a
+#define MN_ldtilecfg 0x1e5e
+#define MN_sttilecfg 0x1e68
 #define MN_xchg (MN_cmpxchg + 3)
-#define MN_cmpxchg 0x1d79
-#define MN_pconfig 0x1d81
-#define MN_jg 0x1d89
-#define MN_jng 0x1d8c
-#define MN_xstore_rng 0x1d90
-#define MN_xstorerng 0x1d9b
-#define MN_setng 0x1da5
-#define MN_setzung 0x1dab
-#define MN_cmovng 0x1db3
-#define MN_invlpg 0x1dba
-#define MN_setg 0x1dc1
-#define MN_setzug 0x1dc6
-#define MN_cmovg 0x1dcd
-#define MN_vmlaunch 0x1dd3
-#define MN_prefetch 0x1ddc
-#define MN_fxch 0x1de5
-#define MN_vfmaddsub231ph 0x1dea
-#define MN_vfmsub231ph 0x1df9
-#define MN_vfnmsub231ph 0x1e05
-#define MN_vfmsubadd231ph 0x1e12
-#define MN_vfmadd231ph 0x1e21
-#define MN_vfnmadd231ph 0x1e2d
-#define MN_vfmaddsub132ph 0x1e3a
-#define MN_vfmsub132ph 0x1e49
-#define MN_vfnmsub132ph 0x1e55
-#define MN_vfmsubadd132ph 0x1e62
-#define MN_vfmadd132ph 0x1e71
-#define MN_vfnmadd132ph 0x1e7d
-#define MN_vcvtpd2ph 0x1e8a
-#define MN_vcvtdq2ph 0x1e94
-#define MN_vcvtudq2ph 0x1e9e
-#define MN_vcvtqq2ph 0x1ea9
-#define MN_vcvtuqq2ph 0x1eb3
-#define MN_vcvtps2ph 0x1ebe
-#define MN_vcvtw2ph 0x1ec8
-#define MN_vcvtuw2ph 0x1ed1
-#define MN_vfmaddsub213ph 0x1edb
-#define MN_vfmsub213ph 0x1eea
-#define MN_vfnmsub213ph 0x1ef6
-#define MN_vfmsubadd213ph 0x1f03
-#define MN_vfmadd213ph 0x1f12
-#define MN_vfnmadd213ph 0x1f1e
-#define MN_vsubph 0x1f2b
-#define MN_vfcmaddcph 0x1f32
-#define MN_vfmaddcph 0x1f3d
-#define MN_vfcmulcph 0x1f47
-#define MN_vfmulcph 0x1f51
-#define MN_vaddph 0x1f5a
-#define MN_vcmpunordph 0x1f61
-#define MN_vcmpordph 0x1f6d
-#define MN_vreduceph 0x1f77
-#define MN_vcmpngeph 0x1f81
-#define MN_vcmpgeph 0x1f8b
-#define MN_vrndscaleph 0x1f94
-#define MN_vcmpnleph 0x1fa0
-#define MN_vcmpleph 0x1faa
-#define MN_vcmpfalseph 0x1fb3
-#define MN_vcmptrueph 0x1fbf
-#define MN_vscalefph 0x1fca
-#define MN_vmulph 0x1fd4
-#define MN_vminph 0x1fdb
-#define MN_vrcpph 0x1fe2
-#define MN_vcmpph 0x1fe9
-#define MN_vgetexpph 0x1ff0
-#define MN_vcmpunord_qph 0x1ffa
-#define MN_vcmpord_qph 0x2008
-#define MN_vcmpneqph 0x2014
-#define MN_vcmpeqph 0x201e
-#define MN_vcmpge_oqph 0x2027
-#define MN_vcmple_oqph 0x2033
-#define MN_vcmpfalse_oqph 0x203f
-#define MN_vcmpneq_oqph 0x204e
-#define MN_vcmpeq_oqph 0x205b
-#define MN_vcmpgt_oqph 0x2067
-#define MN_vcmplt_oqph 0x2073
-#define MN_vcmpnge_uqph 0x207f
-#define MN_vcmpnle_uqph 0x208c
-#define MN_vcmptrue_uqph 0x2099
-#define MN_vcmpneq_uqph 0x20a7
-#define MN_vcmpeq_uqph 0x20b4
-#define MN_vcmpngt_uqph 0x20c0
-#define MN_vcmpnlt_uqph 0x20cd
-#define MN_vcmpunord_sph 0x20da
-#define MN_vcmpord_sph 0x20e8
-#define MN_vcmpge_osph 0x20f4
-#define MN_vcmple_osph 0x2100
-#define MN_vcmpfalse_osph 0x210c
-#define MN_vcmpneq_osph 0x211b
-#define MN_vcmpeq_osph 0x2128
-#define MN_vcmpgt_osph 0x2134
-#define MN_vcmplt_osph 0x2140
-#define MN_vfpclassph 0x214c
-#define MN_vcmpnge_usph 0x2157
-#define MN_vcmpnle_usph 0x2164
-#define MN_vcmptrue_usph 0x2171
-#define MN_vcmpneq_usph 0x217f
-#define MN_vcmpeq_usph 0x218c
-#define MN_vcmpngt_usph 0x2198
-#define MN_vcmpnlt_usph 0x21a5
-#define MN_vcmpngtph 0x21b2
-#define MN_vcmpgtph 0x21bc
-#define MN_vcmpnltph 0x21c5
-#define MN_vcmpltph 0x21cf
-#define MN_vgetmantph 0x21d8
-#define MN_vrsqrtph 0x21e3
-#define MN_vsqrtph 0x21ec
-#define MN_vdivph 0x21f4
-#define MN_vmaxph 0x21fb
-#define MN_vpmacsdqh 0x2202
-#define MN_vpmacssdqh 0x220c
-#define MN_vfmsub231sh 0x2217
-#define MN_vfnmsub231sh 0x2223
-#define MN_vfmadd231sh 0x2230
-#define MN_vfnmadd231sh 0x223c
-#define MN_vfmsub132sh 0x2249
-#define MN_vfnmsub132sh 0x2255
-#define MN_vfmadd132sh 0x2262
-#define MN_vfnmadd132sh 0x226e
-#define MN_vcvtsd2sh 0x227b
-#define MN_vcvtsi2sh 0x2285
-#define MN_vcvtusi2sh 0x228f
-#define MN_vcvtss2sh 0x229a
-#define MN_vfmsub213sh 0x22a4
-#define MN_vfnmsub213sh 0x22b0
-#define MN_vfmadd213sh 0x22bd
-#define MN_vfnmadd213sh 0x22c9
-#define MN_psmash 0x22d6
-#define MN_vsubsh 0x22dd
-#define MN_vfcmaddcsh 0x22e4
-#define MN_vfmaddcsh 0x22ef
-#define MN_vfcmulcsh 0x22f9
-#define MN_vfmulcsh 0x2303
-#define MN_vaddsh 0x230c
-#define MN_vcmpunordsh 0x2313
-#define MN_vcmpordsh 0x231f
-#define MN_vreducesh 0x2329
-#define MN_vcmpngesh 0x2333
-#define MN_vcmpgesh 0x233d
-#define MN_vrndscalesh 0x2346
-#define MN_vcmpnlesh 0x2352
-#define MN_vcmplesh 0x235c
-#define MN_vcmpfalsesh 0x2365
-#define MN_vcmptruesh 0x2371
-#define MN_vscalefsh 0x237c
-#define MN_vucomish 0x2386
-#define MN_vcomish 0x238f
-#define MN_vmulsh 0x2397
-#define MN_vminsh 0x239e
-#define MN_vrcpsh 0x23a5
-#define MN_vcmpsh 0x23ac
-#define MN_vgetexpsh 0x23b3
-#define MN_vcmpunord_qsh 0x23bd
-#define MN_vcmpord_qsh 0x23cb
-#define MN_vcmpneqsh 0x23d7
-#define MN_vcmpeqsh 0x23e1
-#define MN_vcmpge_oqsh 0x23ea
-#define MN_vcmple_oqsh 0x23f6
-#define MN_vcmpfalse_oqsh 0x2402
-#define MN_vcmpneq_oqsh 0x2411
-#define MN_vcmpeq_oqsh 0x241e
-#define MN_vcmpgt_oqsh 0x242a
-#define MN_vcmplt_oqsh 0x2436
-#define MN_vcmpnge_uqsh 0x2442
-#define MN_vcmpnle_uqsh 0x244f
-#define MN_vcmptrue_uqsh 0x245c
-#define MN_vcmpneq_uqsh 0x246a
-#define MN_vcmpeq_uqsh 0x2477
-#define MN_vcmpngt_uqsh 0x2483
-#define MN_vcmpnlt_uqsh 0x2490
-#define MN_vcmpunord_ssh 0x249d
-#define MN_vcmpord_ssh 0x24ab
-#define MN_vcmpge_ossh 0x24b7
-#define MN_vcmple_ossh 0x24c3
-#define MN_vcmpfalse_ossh 0x24cf
-#define MN_vcmpneq_ossh 0x24de
-#define MN_vcmpeq_ossh 0x24eb
-#define MN_vcmpgt_ossh 0x24f7
-#define MN_vcmplt_ossh 0x2503
-#define MN_vfpclasssh 0x250f
-#define MN_vcmpnge_ussh 0x251a
-#define MN_vcmpnle_ussh 0x2527
-#define MN_vcmptrue_ussh 0x2534
-#define MN_vcmpneq_ussh 0x2542
-#define MN_vcmpeq_ussh 0x254f
-#define MN_vcmpngt_ussh 0x255b
-#define MN_vcmpnlt_ussh 0x2568
-#define MN_vcmpngtsh 0x2575
-#define MN_vcmpgtsh 0x257f
-#define MN_vcmpnltsh 0x2588
-#define MN_vcmpltsh 0x2592
-#define MN_vgetmantsh 0x259b
-#define MN_vrsqrtsh 0x25a6
-#define MN_vsqrtsh 0x25af
-#define MN_clflush 0x25b7
-#define MN_push 0x25bf
-#define MN_vdivsh 0x25c4
-#define MN_vmovsh 0x25cb
-#define MN_vmaxsh 0x25d2
-#define MN_blci 0x25d9
-#define MN_clgi 0x25de
-#define MN_stgi 0x25e3
-#define MN_bzhi 0x25e8
-#define MN_cli 0x25ed
-#define MN_fcomi 0x25f1
-#define MN_fucomi 0x25f7
-#define MN_feni 0x25fe
-#define MN_fneni 0x2603
-#define MN_cvttpd2pi 0x2609
-#define MN_cvtpd2pi 0x2613
-#define MN_cvttps2pi 0x261c
-#define MN_cvtps2pi 0x2626
-#define MN_fldpi 0x262f
-#define MN_senduipi 0x2635
-#define MN_fcompi 0x263e
-#define MN_fucompi 0x2645
-#define MN_movdiri 0x264d
+#define MN_cmpxchg 0x1e72
+#define MN_pconfig 0x1e7a
+#define MN_jg 0x1e82
+#define MN_jng 0x1e85
+#define MN_ccmpng 0x1e89
+#define MN_xstore_rng 0x1e90
+#define MN_xstorerng 0x1e9b
+#define MN_setng 0x1ea5
+#define MN_ctestng 0x1eab
+#define MN_setzung 0x1eb3
+#define MN_cmovng 0x1ebb
+#define MN_invlpg 0x1ec2
+#define MN_ccmpg 0x1ec9
+#define MN_setg 0x1ecf
+#define MN_ctestg 0x1ed4
+#define MN_setzug 0x1edb
+#define MN_cmovg 0x1ee2
+#define MN_vmlaunch 0x1ee8
+#define MN_prefetch 0x1ef1
+#define MN_fxch 0x1efa
+#define MN_vfmaddsub231ph 0x1eff
+#define MN_vfmsub231ph 0x1f0e
+#define MN_vfnmsub231ph 0x1f1a
+#define MN_vfmsubadd231ph 0x1f27
+#define MN_vfmadd231ph 0x1f36
+#define MN_vfnmadd231ph 0x1f42
+#define MN_vfmaddsub132ph 0x1f4f
+#define MN_vfmsub132ph 0x1f5e
+#define MN_vfnmsub132ph 0x1f6a
+#define MN_vfmsubadd132ph 0x1f77
+#define MN_vfmadd132ph 0x1f86
+#define MN_vfnmadd132ph 0x1f92
+#define MN_vcvtpd2ph 0x1f9f
+#define MN_vcvtdq2ph 0x1fa9
+#define MN_vcvtudq2ph 0x1fb3
+#define MN_vcvtqq2ph 0x1fbe
+#define MN_vcvtuqq2ph 0x1fc8
+#define MN_vcvtps2ph 0x1fd3
+#define MN_vcvtw2ph 0x1fdd
+#define MN_vcvtuw2ph 0x1fe6
+#define MN_vfmaddsub213ph 0x1ff0
+#define MN_vfmsub213ph 0x1fff
+#define MN_vfnmsub213ph 0x200b
+#define MN_vfmsubadd213ph 0x2018
+#define MN_vfmadd213ph 0x2027
+#define MN_vfnmadd213ph 0x2033
+#define MN_vsubph 0x2040
+#define MN_vfcmaddcph 0x2047
+#define MN_vfmaddcph 0x2052
+#define MN_vfcmulcph 0x205c
+#define MN_vfmulcph 0x2066
+#define MN_vaddph 0x206f
+#define MN_vcmpunordph 0x2076
+#define MN_vcmpordph 0x2082
+#define MN_vreduceph 0x208c
+#define MN_vcmpngeph 0x2096
+#define MN_vcmpgeph 0x20a0
+#define MN_vrndscaleph 0x20a9
+#define MN_vcmpnleph 0x20b5
+#define MN_vcmpleph 0x20bf
+#define MN_vcmpfalseph 0x20c8
+#define MN_vcmptrueph 0x20d4
+#define MN_vscalefph 0x20df
+#define MN_vmulph 0x20e9
+#define MN_vminph 0x20f0
+#define MN_vrcpph 0x20f7
+#define MN_vcmpph 0x20fe
+#define MN_vgetexpph 0x2105
+#define MN_vcmpunord_qph 0x210f
+#define MN_vcmpord_qph 0x211d
+#define MN_vcmpneqph 0x2129
+#define MN_vcmpeqph 0x2133
+#define MN_vcmpge_oqph 0x213c
+#define MN_vcmple_oqph 0x2148
+#define MN_vcmpfalse_oqph 0x2154
+#define MN_vcmpneq_oqph 0x2163
+#define MN_vcmpeq_oqph 0x2170
+#define MN_vcmpgt_oqph 0x217c
+#define MN_vcmplt_oqph 0x2188
+#define MN_vcmpnge_uqph 0x2194
+#define MN_vcmpnle_uqph 0x21a1
+#define MN_vcmptrue_uqph 0x21ae
+#define MN_vcmpneq_uqph 0x21bc
+#define MN_vcmpeq_uqph 0x21c9
+#define MN_vcmpngt_uqph 0x21d5
+#define MN_vcmpnlt_uqph 0x21e2
+#define MN_vcmpunord_sph 0x21ef
+#define MN_vcmpord_sph 0x21fd
+#define MN_vcmpge_osph 0x2209
+#define MN_vcmple_osph 0x2215
+#define MN_vcmpfalse_osph 0x2221
+#define MN_vcmpneq_osph 0x2230
+#define MN_vcmpeq_osph 0x223d
+#define MN_vcmpgt_osph 0x2249
+#define MN_vcmplt_osph 0x2255
+#define MN_vfpclassph 0x2261
+#define MN_vcmpnge_usph 0x226c
+#define MN_vcmpnle_usph 0x2279
+#define MN_vcmptrue_usph 0x2286
+#define MN_vcmpneq_usph 0x2294
+#define MN_vcmpeq_usph 0x22a1
+#define MN_vcmpngt_usph 0x22ad
+#define MN_vcmpnlt_usph 0x22ba
+#define MN_vcmpngtph 0x22c7
+#define MN_vcmpgtph 0x22d1
+#define MN_vcmpnltph 0x22da
+#define MN_vcmpltph 0x22e4
+#define MN_vgetmantph 0x22ed
+#define MN_vrsqrtph 0x22f8
+#define MN_vsqrtph 0x2301
+#define MN_vdivph 0x2309
+#define MN_vmaxph 0x2310
+#define MN_vpmacsdqh 0x2317
+#define MN_vpmacssdqh 0x2321
+#define MN_vfmsub231sh 0x232c
+#define MN_vfnmsub231sh 0x2338
+#define MN_vfmadd231sh 0x2345
+#define MN_vfnmadd231sh 0x2351
+#define MN_vfmsub132sh 0x235e
+#define MN_vfnmsub132sh 0x236a
+#define MN_vfmadd132sh 0x2377
+#define MN_vfnmadd132sh 0x2383
+#define MN_vcvtsd2sh 0x2390
+#define MN_vcvtsi2sh 0x239a
+#define MN_vcvtusi2sh 0x23a4
+#define MN_vcvtss2sh 0x23af
+#define MN_vfmsub213sh 0x23b9
+#define MN_vfnmsub213sh 0x23c5
+#define MN_vfmadd213sh 0x23d2
+#define MN_vfnmadd213sh 0x23de
+#define MN_psmash 0x23eb
+#define MN_vsubsh 0x23f2
+#define MN_vfcmaddcsh 0x23f9
+#define MN_vfmaddcsh 0x2404
+#define MN_vfcmulcsh 0x240e
+#define MN_vfmulcsh 0x2418
+#define MN_vaddsh 0x2421
+#define MN_vcmpunordsh 0x2428
+#define MN_vcmpordsh 0x2434
+#define MN_vreducesh 0x243e
+#define MN_vcmpngesh 0x2448
+#define MN_vcmpgesh 0x2452
+#define MN_vrndscalesh 0x245b
+#define MN_vcmpnlesh 0x2467
+#define MN_vcmplesh 0x2471
+#define MN_vcmpfalsesh 0x247a
+#define MN_vcmptruesh 0x2486
+#define MN_vscalefsh 0x2491
+#define MN_vucomish 0x249b
+#define MN_vcomish 0x24a4
+#define MN_vmulsh 0x24ac
+#define MN_vminsh 0x24b3
+#define MN_vrcpsh 0x24ba
+#define MN_vcmpsh 0x24c1
+#define MN_vgetexpsh 0x24c8
+#define MN_vcmpunord_qsh 0x24d2
+#define MN_vcmpord_qsh 0x24e0
+#define MN_vcmpneqsh 0x24ec
+#define MN_vcmpeqsh 0x24f6
+#define MN_vcmpge_oqsh 0x24ff
+#define MN_vcmple_oqsh 0x250b
+#define MN_vcmpfalse_oqsh 0x2517
+#define MN_vcmpneq_oqsh 0x2526
+#define MN_vcmpeq_oqsh 0x2533
+#define MN_vcmpgt_oqsh 0x253f
+#define MN_vcmplt_oqsh 0x254b
+#define MN_vcmpnge_uqsh 0x2557
+#define MN_vcmpnle_uqsh 0x2564
+#define MN_vcmptrue_uqsh 0x2571
+#define MN_vcmpneq_uqsh 0x257f
+#define MN_vcmpeq_uqsh 0x258c
+#define MN_vcmpngt_uqsh 0x2598
+#define MN_vcmpnlt_uqsh 0x25a5
+#define MN_vcmpunord_ssh 0x25b2
+#define MN_vcmpord_ssh 0x25c0
+#define MN_vcmpge_ossh 0x25cc
+#define MN_vcmple_ossh 0x25d8
+#define MN_vcmpfalse_ossh 0x25e4
+#define MN_vcmpneq_ossh 0x25f3
+#define MN_vcmpeq_ossh 0x2600
+#define MN_vcmpgt_ossh 0x260c
+#define MN_vcmplt_ossh 0x2618
+#define MN_vfpclasssh 0x2624
+#define MN_vcmpnge_ussh 0x262f
+#define MN_vcmpnle_ussh 0x263c
+#define MN_vcmptrue_ussh 0x2649
+#define MN_vcmpneq_ussh 0x2657
+#define MN_vcmpeq_ussh 0x2664
+#define MN_vcmpngt_ussh 0x2670
+#define MN_vcmpnlt_ussh 0x267d
+#define MN_vcmpngtsh 0x268a
+#define MN_vcmpgtsh 0x2694
+#define MN_vcmpnltsh 0x269d
+#define MN_vcmpltsh 0x26a7
+#define MN_vgetmantsh 0x26b0
+#define MN_vrsqrtsh 0x26bb
+#define MN_vsqrtsh 0x26c4
+#define MN_clflush 0x26cc
+#define MN_push 0x26d4
+#define MN_vdivsh 0x26d9
+#define MN_vmovsh 0x26e0
+#define MN_vmaxsh 0x26e7
+#define MN_blci 0x26ee
+#define MN_clgi 0x26f3
+#define MN_stgi 0x26f8
+#define MN_bzhi 0x26fd
+#define MN_cli 0x2702
+#define MN_fcomi 0x2706
+#define MN_fucomi 0x270c
+#define MN_feni 0x2713
+#define MN_fneni 0x2718
+#define MN_cvttpd2pi 0x271e
+#define MN_cvtpd2pi 0x2728
+#define MN_cvttps2pi 0x2731
+#define MN_cvtps2pi 0x273b
+#define MN_fldpi 0x2744
+#define MN_senduipi 0x274a
+#define MN_fcompi 0x2753
+#define MN_fucompi 0x275a
+#define MN_movdiri 0x2762
 #define MN_pcmpestri (MN_vpcmpestri + 1)
-#define MN_vpcmpestri 0x2655
+#define MN_vpcmpestri 0x276a
 #define MN_pcmpistri (MN_vpcmpistri + 1)
-#define MN_vpcmpistri 0x2660
+#define MN_vpcmpistri 0x2775
 #define MN_cvttsd2si (MN_vcvttsd2si + 1)
-#define MN_vcvttsd2si 0x266b
+#define MN_vcvttsd2si 0x2780
 #define MN_cvtsd2si (MN_vcvtsd2si + 1)
-#define MN_vcvtsd2si 0x2676
-#define MN_vcvttsh2si 0x2680
-#define MN_vcvtsh2si 0x268b
+#define MN_vcvtsd2si 0x278b
+#define MN_vcvttsh2si 0x2795
+#define MN_vcvtsh2si 0x27a0
 #define MN_cvttss2si (MN_vcvttss2si + 1)
-#define MN_vcvttss2si 0x2695
+#define MN_vcvttss2si 0x27aa
 #define MN_cvtss2si (MN_vcvtss2si + 1)
-#define MN_vcvtss2si 0x26a0
-#define MN_fdisi 0x26aa
-#define MN_fndisi 0x26b0
-#define MN_blsi 0x26b7
-#define MN_vcvttsd2usi 0x26bc
-#define MN_vcvtsd2usi 0x26c8
-#define MN_vcvttsh2usi 0x26d3
-#define MN_vcvtsh2usi 0x26df
-#define MN_vcvttss2usi 0x26ea
-#define MN_vcvtss2usi 0x26f6
-#define MN_movnti 0x2701
-#define MN_sti 0x2708
-#define MN_clui 0x270c
+#define MN_vcvtss2si 0x27b5
+#define MN_fdisi 0x27bf
+#define MN_fndisi 0x27c5
+#define MN_blsi 0x27cc
+#define MN_vcvttsd2usi 0x27d1
+#define MN_vcvtsd2usi 0x27dd
+#define MN_vcvttsh2usi 0x27e8
+#define MN_vcvtsh2usi 0x27f4
+#define MN_vcvttss2usi 0x27ff
+#define MN_vcvtss2usi 0x280b
+#define MN_movnti 0x2816
+#define MN_sti 0x281d
+#define MN_clui 0x2821
 #define MN_stui (MN_testui + 2)
-#define MN_testui 0x2711
-#define MN_notrack 0x2718
-#define MN_lock 0x2720
-#define MN_bndmk 0x2725
-#define MN_xresldtrk 0x272b
-#define MN_xsusldtrk 0x2735
-#define MN_blcmsk 0x273f
-#define MN_blsmsk 0x2746
-#define MN_tzmsk 0x274d
-#define MN_sal 0x2753
-#define MN_lwpval 0x2757
-#define MN_bndcl 0x275e
-#define MN_rcl 0x2764
-#define MN_shl 0x2768
-#define MN_jl 0x276c
-#define MN_aesdec256kl 0x276f
-#define MN_aesenc256kl 0x277b
-#define MN_aesdecwide256kl 0x2787
-#define MN_aesencwide256kl 0x2797
-#define MN_aesdec128kl 0x27a7
-#define MN_aesenc128kl 0x27b3
-#define MN_aesdecwide128kl 0x27bf
-#define MN_aesencwide128kl 0x27cf
+#define MN_testui 0x2826
+#define MN_notrack 0x282d
+#define MN_lock 0x2835
+#define MN_bndmk 0x283a
+#define MN_xresldtrk 0x2840
+#define MN_xsusldtrk 0x284a
+#define MN_blcmsk 0x2854
+#define MN_blsmsk 0x285b
+#define MN_tzmsk 0x2862
+#define MN_sal 0x2868
+#define MN_lwpval 0x286c
+#define MN_bndcl 0x2873
+#define MN_rcl 0x2879
+#define MN_shl 0x287d
+#define MN_jl 0x2881
+#define MN_aesdec256kl 0x2884
+#define MN_aesenc256kl 0x2890
+#define MN_aesdecwide256kl 0x289c
+#define MN_aesencwide256kl 0x28ac
+#define MN_aesdec128kl 0x28bc
+#define MN_aesenc128kl 0x28c8
+#define MN_aesdecwide128kl 0x28d4
+#define MN_aesencwide128kl 0x28e4
 #define MN_call (MN_tdcall + 2)
-#define MN_tdcall 0x27df
-#define MN_lcall 0x27e6
-#define MN_seamcall 0x27ec
-#define MN_vmmcall 0x27f5
-#define MN_vmcall 0x27fd
-#define MN_syscall 0x2804
-#define MN_vzeroall 0x280c
-#define MN_fildll 0x2815
-#define MN_blcfill 0x281c
-#define MN_blsfill 0x2824
-#define MN_fistpll 0x282c
-#define MN_fisttpll 0x2834
-#define MN_jnl 0x283d
-#define MN_setnl 0x2841
-#define MN_setzunl 0x2847
-#define MN_cmovnl 0x284f
-#define MN_rol 0x2856
-#define MN_arpl 0x285a
-#define MN_vpmacsdql 0x285f
-#define MN_vpmacssdql 0x2869
-#define MN_lsl 0x2874
-#define MN_movsl 0x2878
-#define MN_setl 0x287e
-#define MN_cwtl 0x2883
+#define MN_tdcall 0x28f4
+#define MN_lcall 0x28fb
+#define MN_seamcall 0x2901
+#define MN_vmmcall 0x290a
+#define MN_vmcall 0x2912
+#define MN_syscall 0x2919
+#define MN_vzeroall 0x2921
+#define MN_fildll 0x292a
+#define MN_blcfill 0x2931
+#define MN_blsfill 0x2939
+#define MN_fistpll 0x2941
+#define MN_fisttpll 0x2949
+#define MN_jnl 0x2952
+#define MN_ccmpnl 0x2956
+#define MN_setnl 0x295d
+#define MN_ctestnl 0x2963
+#define MN_setzunl 0x296b
+#define MN_cmovnl 0x2973
+#define MN_rol 0x297a
+#define MN_ccmpl 0x297e
+#define MN_arpl 0x2984
+#define MN_vpmacsdql 0x2989
+#define MN_vpmacssdql 0x2993
+#define MN_lsl 0x299e
+#define MN_movsl 0x29a2
+#define MN_setl 0x29a8
+#define MN_ctestl 0x29ad
+#define MN_cwtl 0x29b4
 #define MN_mul (MN_fmul + 1)
 #define MN_fmul (MN_pfmul + 1)
-#define MN_pfmul 0x2888
+#define MN_pfmul 0x29b9
 #define MN_imul (MN_fimul + 1)
-#define MN_fimul 0x288e
-#define MN_montmul 0x2894
-#define MN_setzul 0x289c
-#define MN_cmovl 0x28a3
-#define MN_vpmovb2m 0x28a9
-#define MN_vpmovd2m 0x28b2
-#define MN_vpmovq2m 0x28bb
-#define MN_vpmovw2m 0x28c4
-#define MN_aam 0x28cd
-#define MN_fxam 0x28d1
-#define MN_fprem 0x28d6
-#define MN_fcom 0x28dc
-#define MN_ficom 0x28e1
-#define MN_fucom 0x28e7
-#define MN_fsetpm 0x28ed
-#define MN_fnsetpm 0x28f4
-#define MN_frstpm 0x28fc
-#define MN_vpperm 0x2903
+#define MN_fimul 0x29bf
+#define MN_montmul 0x29c5
+#define MN_setzul 0x29cd
+#define MN_cmovl 0x29d4
+#define MN_vpmovb2m 0x29da
+#define MN_vpmovd2m 0x29e3
+#define MN_vpmovq2m 0x29ec
+#define MN_vpmovw2m 0x29f5
+#define MN_aam 0x29fe
+#define MN_fxam 0x2a02
+#define MN_fprem 0x2a07
+#define MN_fcom 0x2a0d
+#define MN_ficom 0x2a12
+#define MN_fucom 0x2a18
+#define MN_fsetpm 0x2a1e
+#define MN_fnsetpm 0x2a25
+#define MN_frstpm 0x2a2d
+#define MN_vpperm 0x2a34
 #define MN_pcmpestrm (MN_vpcmpestrm + 1)
-#define MN_vpcmpestrm 0x290a
+#define MN_vpcmpestrm 0x2a3b
 #define MN_pcmpistrm (MN_vpcmpistrm + 1)
-#define MN_vpcmpistrm 0x2915
-#define MN_rsm 0x2920
-#define MN_fpatan 0x2924
-#define MN_fptan 0x292b
-#define MN_bndcn 0x2931
+#define MN_vpcmpistrm 0x2a46
+#define MN_rsm 0x2a51
+#define MN_fpatan 0x2a55
+#define MN_fptan 0x2a5c
+#define MN_bndcn 0x2a62
 #define MN_andn (MN_pandn + 1)
 #define MN_pandn (MN_vpandn + 1)
-#define MN_vpandn 0x2937
+#define MN_vpandn 0x2a68
 #define MN_in (MN_xbegin + 4)
-#define MN_xbegin 0x293e
-#define MN_pfmin 0x2945
-#define MN_fsin 0x294b
-#define MN_vmxon 0x2950
-#define MN_vmrun 0x2956
-#define MN_jo 0x295c
-#define MN_jno 0x295f
-#define MN_setno 0x2963
-#define MN_setzuno 0x2969
-#define MN_cmovno 0x2971
-#define MN_jpo 0x2978
-#define MN_setpo 0x297c
-#define MN_setzupo 0x2982
-#define MN_cmovpo 0x298a
-#define MN_cqo 0x2991
-#define MN_tilezero 0x2995
-#define MN_clzero 0x299e
-#define MN_seto 0x29a5
-#define MN_into 0x29aa
-#define MN_cqto 0x29af
-#define MN_ssto 0x29b4
-#define MN_setzuo 0x29b9
-#define MN_cmovo 0x29c0
-#define MN_push2p 0x29c6
-#define MN_pop2p 0x29cd
-#define MN_bswap 0x29d3
-#define MN_fsubp 0x29d9
-#define MN_pfrcp 0x29df
-#define MN_rdtscp 0x29e5
-#define MN_faddp 0x29ec
-#define MN_pdep 0x29f2
-#define MN_ffreep 0x29f7
-#define MN_rep 0x29fe
-#define MN_pushp 0x2a02
-#define MN_fcomip 0x2a08
-#define MN_fucomip 0x2a0f
-#define MN_jp 0x2a17
-#define MN_fmulp 0x2a1a
+#define MN_xbegin 0x2a6f
+#define MN_pfmin 0x2a76
+#define MN_fsin 0x2a7c
+#define MN_vmxon 0x2a81
+#define MN_vmrun 0x2a87
+#define MN_jo 0x2a8d
+#define MN_jno 0x2a90
+#define MN_ccmpno 0x2a94
+#define MN_setno 0x2a9b
+#define MN_ctestno 0x2aa1
+#define MN_setzuno 0x2aa9
+#define MN_cmovno 0x2ab1
+#define MN_jpo 0x2ab8
+#define MN_ccmpo 0x2abc
+#define MN_setpo 0x2ac2
+#define MN_setzupo 0x2ac8
+#define MN_cmovpo 0x2ad0
+#define MN_cqo 0x2ad7
+#define MN_tilezero 0x2adb
+#define MN_clzero 0x2ae4
+#define MN_seto 0x2aeb
+#define MN_into 0x2af0
+#define MN_cqto 0x2af5
+#define MN_ctesto 0x2afa
+#define MN_ssto 0x2b01
+#define MN_setzuo 0x2b06
+#define MN_cmovo 0x2b0d
+#define MN_push2p 0x2b13
+#define MN_pop2p 0x2b1a
+#define MN_bswap 0x2b20
+#define MN_fsubp 0x2b26
+#define MN_pfrcp 0x2b2c
+#define MN_rdtscp 0x2b32
+#define MN_faddp 0x2b39
+#define MN_pdep 0x2b3f
+#define MN_ffreep 0x2b44
+#define MN_rep 0x2b4b
+#define MN_pushp 0x2b4f
+#define MN_fcomip 0x2b55
+#define MN_fucomip 0x2b5c
+#define MN_jp 0x2b64
+#define MN_fmulp 0x2b67
 #define MN_cmp (MN_scmp + 1)
-#define MN_scmp 0x2a20
+#define MN_scmp 0x2b6d
 #define MN_jmp (MN_ljmp + 1)
-#define MN_ljmp 0x2a25
-#define MN_fcomp 0x2a2a
-#define MN_ficomp 0x2a30
-#define MN_fucomp 0x2a37
-#define MN_jnp 0x2a3e
-#define MN_setnp 0x2a42
-#define MN_setzunp 0x2a48
-#define MN_cmovnp 0x2a50
+#define MN_ljmp 0x2b72
+#define MN_fcomp 0x2b77
+#define MN_ficomp 0x2b7d
+#define MN_fucomp 0x2b84
+#define MN_jnp 0x2b8b
+#define MN_setnp 0x2b8f
+#define MN_setzunp 0x2b95
+#define MN_cmovnp 0x2b9d
 #define MN_nop (MN_fnop + 1)
-#define MN_fnop 0x2a57
-#define MN_loop 0x2a5c
-#define MN_pop 0x2a61
-#define MN_fcompp 0x2a65
-#define MN_fucompp 0x2a6c
-#define MN_popp 0x2a74
-#define MN_fsubrp 0x2a79
-#define MN_fdivrp 0x2a80
-#define MN_rstorssp 0x2a87
-#define MN_saveprevssp 0x2a90
-#define MN_setp 0x2a9c
-#define MN_fbstp 0x2aa1
-#define MN_fdecstp 0x2aa7
-#define MN_fincstp 0x2aaf
-#define MN_fstp 0x2ab7
-#define MN_fistp 0x2abc
-#define MN_fisttp 0x2ac2
+#define MN_fnop 0x2ba4
+#define MN_loop 0x2ba9
+#define MN_pop 0x2bae
+#define MN_fcompp 0x2bb2
+#define MN_fucompp 0x2bb9
+#define MN_popp 0x2bc1
+#define MN_fsubrp 0x2bc6
+#define MN_fdivrp 0x2bcd
+#define MN_rstorssp 0x2bd4
+#define MN_saveprevssp 0x2bdd
+#define MN_setp 0x2be9
+#define MN_fbstp 0x2bee
+#define MN_fdecstp 0x2bf4
+#define MN_fincstp 0x2bfc
+#define MN_fstp 0x2c04
+#define MN_fistp 0x2c09
+#define MN_fisttp 0x2c0f
 #define MN_movddup (MN_vmovddup + 1)
-#define MN_vmovddup 0x2ac9
+#define MN_vmovddup 0x2c16
 #define MN_movshdup (MN_vmovshdup + 1)
-#define MN_vmovshdup 0x2ad2
+#define MN_vmovshdup 0x2c1f
 #define MN_movsldup (MN_vmovsldup + 1)
-#define MN_vmovsldup 0x2adc
-#define MN_setzup 0x2ae6
-#define MN_fdivp 0x2aed
-#define MN_cmovp 0x2af3
-#define MN_vpbroadcastmb2q 0x2af9
-#define MN_vpermi2q 0x2b09
-#define MN_vpmovm2q 0x2b12
-#define MN_movdq2q 0x2b1b
-#define MN_vpermt2q 0x2b23
-#define MN_vpshaq 0x2b2c
-#define MN_vpsraq 0x2b33
-#define MN_vphaddbq 0x2b3a
-#define MN_vphaddubq 0x2b43
+#define MN_vmovsldup 0x2c29
+#define MN_setzup 0x2c33
+#define MN_fdivp 0x2c3a
+#define MN_cmovp 0x2c40
+#define MN_vpbroadcastmb2q 0x2c46
+#define MN_vpermi2q 0x2c56
+#define MN_vpmovm2q 0x2c5f
+#define MN_movdq2q 0x2c68
+#define MN_vpermt2q 0x2c70
+#define MN_vpshaq 0x2c79
+#define MN_vpsraq 0x2c80
+#define MN_vphaddbq 0x2c87
+#define MN_vphaddubq 0x2c90
 #define MN_psubq (MN_vpsubq + 1)
-#define MN_vpsubq 0x2b4d
+#define MN_vpsubq 0x2c9a
 #define MN_pmovsxbq (MN_vpmovsxbq + 1)
-#define MN_vpmovsxbq 0x2b54
+#define MN_vpmovsxbq 0x2ca1
 #define MN_pmovzxbq (MN_vpmovzxbq + 1)
-#define MN_vpmovzxbq 0x2b5e
+#define MN_vpmovzxbq 0x2cab
 #define MN_cvttpd2dq (MN_vcvttpd2dq + 1)
-#define MN_vcvttpd2dq 0x2b68
+#define MN_vcvttpd2dq 0x2cb5
 #define MN_cvtpd2dq (MN_vcvtpd2dq + 1)
-#define MN_vcvtpd2dq 0x2b73
-#define MN_vcvttph2dq 0x2b7d
-#define MN_vcvtph2dq 0x2b88
-#define MN_movq2dq 0x2b92
+#define MN_vcvtpd2dq 0x2cc0
+#define MN_vcvttph2dq 0x2cca
+#define MN_vcvtph2dq 0x2cd5
+#define MN_movq2dq 0x2cdf
 #define MN_cvttps2dq (MN_vcvttps2dq + 1)
-#define MN_vcvttps2dq 0x2b9a
+#define MN_vcvttps2dq 0x2ce7
 #define MN_cvtps2dq (MN_vcvtps2dq + 1)
-#define MN_vcvtps2dq 0x2ba5
-#define MN_vphsubdq 0x2baf
-#define MN_cdq 0x2bb8
-#define MN_kaddq 0x2bbc
+#define MN_vcvtps2dq 0x2cf2
+#define MN_vphsubdq 0x2cfc
+#define MN_cdq 0x2d05
+#define MN_kaddq 0x2d09
 #define MN_paddq (MN_vpaddq + 1)
-#define MN_vpaddq 0x2bc2
-#define MN_vphadddq 0x2bc9
+#define MN_vpaddq 0x2d0f
+#define MN_vphadddq 0x2d16
 #define MN_punpckhdq (MN_vpunpckhdq + 1)
-#define MN_vpunpckhdq 0x2bd2
-#define MN_kunpckdq 0x2bdd
-#define MN_vpshldq 0x2be6
+#define MN_vpunpckhdq 0x2d1f
+#define MN_kunpckdq 0x2d2a
+#define MN_vpshldq 0x2d33
 #define MN_punpckldq (MN_vpunpckldq + 1)
-#define MN_vpunpckldq 0x2bee
+#define MN_vpunpckldq 0x2d3b
 #define MN_pslldq (MN_vpslldq + 1)
-#define MN_vpslldq 0x2bf9
+#define MN_vpslldq 0x2d46
 #define MN_psrldq (MN_vpsrldq + 1)
-#define MN_vpsrldq 0x2c01
+#define MN_vpsrldq 0x2d4e
 #define MN_pmuldq (MN_vpmuldq + 1)
-#define MN_vpmuldq 0x2c09
-#define MN_kandq 0x2c11
-#define MN_vpandq 0x2c17
-#define MN_vpexpandq 0x2c1e
+#define MN_vpmuldq 0x2d56
+#define MN_kandq 0x2d5e
+#define MN_vpandq 0x2d64
+#define MN_vpexpandq 0x2d6b
 #define MN_punpckhqdq (MN_vpunpckhqdq + 1)
-#define MN_vpunpckhqdq 0x2c28
+#define MN_vpunpckhqdq 0x2d75
 #define MN_pclmulhqhqdq (MN_vpclmulhqhqdq + 1)
-#define MN_vpclmulhqhqdq 0x2c34
+#define MN_vpclmulhqhqdq 0x2d81
 #define MN_pclmullqhqdq (MN_vpclmullqhqdq + 1)
-#define MN_vpclmullqhqdq 0x2c42
+#define MN_vpclmullqhqdq 0x2d8f
 #define MN_punpcklqdq (MN_vpunpcklqdq + 1)
-#define MN_vpunpcklqdq 0x2c50
+#define MN_vpunpcklqdq 0x2d9d
 #define MN_pclmulhqlqdq (MN_vpclmulhqlqdq + 1)
-#define MN_vpclmulhqlqdq 0x2c5c
+#define MN_vpclmulhqlqdq 0x2da9
 #define MN_pclmullqlqdq (MN_vpclmullqlqdq + 1)
-#define MN_vpclmullqlqdq 0x2c6a
+#define MN_vpclmullqlqdq 0x2db7
 #define MN_pclmulqdq (MN_vpclmulqdq + 1)
-#define MN_vpclmulqdq 0x2c78
-#define MN_vpgatherdq 0x2c83
-#define MN_vpscatterdq 0x2c8e
-#define MN_vpshrdq 0x2c9a
+#define MN_vpclmulqdq 0x2dc5
+#define MN_vpgatherdq 0x2dd0
+#define MN_vpscatterdq 0x2ddb
+#define MN_vpshrdq 0x2de7
 #define MN_movntdq (MN_vmovntdq + 1)
-#define MN_vmovntdq 0x2ca2
-#define MN_vcvttpd2udq 0x2cab
-#define MN_vcvtpd2udq 0x2cb7
-#define MN_vcvttph2udq 0x2cc2
-#define MN_vcvtph2udq 0x2cce
-#define MN_vcvttps2udq 0x2cd9
-#define MN_vcvtps2udq 0x2ce5
-#define MN_vphaddudq 0x2cf0
+#define MN_vmovntdq 0x2def
+#define MN_vcvttpd2udq 0x2df8
+#define MN_vcvtpd2udq 0x2e04
+#define MN_vcvttph2udq 0x2e0f
+#define MN_vcvtph2udq 0x2e1b
+#define MN_vcvttps2udq 0x2e26
+#define MN_vcvtps2udq 0x2e32
+#define MN_vphaddudq 0x2e3d
 #define MN_pmuludq (MN_vpmuludq + 1)
-#define MN_vpmuludq 0x2cfa
+#define MN_vpmuludq 0x2e47
 #define MN_pmovsxdq (MN_vpmovsxdq + 1)
-#define MN_vpmovsxdq 0x2d03
+#define MN_vpmovsxdq 0x2e50
 #define MN_pmovzxdq (MN_vpmovzxdq + 1)
-#define MN_vpmovzxdq 0x2d0d
-#define MN_vpcomgeq 0x2d17
-#define MN_vpcomleq 0x2d20
-#define MN_vpcmpnleq 0x2d29
-#define MN_vpcmpleq 0x2d33
-#define MN_pfcmpeq 0x2d3c
-#define MN_vpcomfalseq 0x2d44
-#define MN_vpcomtrueq 0x2d50
-#define MN_vpternlogq 0x2d5b
-#define MN_vpshlq 0x2d66
+#define MN_vpmovzxdq 0x2e5a
+#define MN_vpcomgeq 0x2e64
+#define MN_vpcomleq 0x2e6d
+#define MN_vpcmpnleq 0x2e76
+#define MN_vpcmpleq 0x2e80
+#define MN_pfcmpeq 0x2e89
+#define MN_vpcomfalseq 0x2e91
+#define MN_vpcomtrueq 0x2e9d
+#define MN_vpternlogq 0x2ea8
+#define MN_vpshlq 0x2eb3
 #define MN_psllq (MN_vpsllq + 1)
-#define MN_vpsllq 0x2d6d
-#define MN_vpmullq 0x2d74
-#define MN_vprolq 0x2d7c
+#define MN_vpsllq 0x2eba
+#define MN_vpmullq 0x2ec1
+#define MN_vprolq 0x2ec9
 #define MN_psrlq (MN_vpsrlq + 1)
-#define MN_vpsrlq 0x2d83
-#define MN_kshiftlq 0x2d8a
-#define MN_vpblendmq 0x2d93
-#define MN_vptestnmq 0x2d9d
-#define MN_vpcomq 0x2da7
-#define MN_vpermq 0x2dae
-#define MN_vptestmq 0x2db5
-#define MN_kandnq 0x2dbe
-#define MN_vpandnq 0x2dc5
-#define MN_valignq 0x2dcd
-#define MN_vpcmpq 0x2dd5
-#define MN_incsspq 0x2ddc
-#define MN_rdsspq 0x2de4
-#define MN_vcvttpd2qq 0x2deb
-#define MN_vcvtpd2qq 0x2df6
-#define MN_vcvttph2qq 0x2e00
-#define MN_vcvtph2qq 0x2e0b
-#define MN_vcvttps2qq 0x2e15
-#define MN_vcvtps2qq 0x2e20
-#define MN_vpcomeqq 0x2e2a
-#define MN_vpcomneqq 0x2e33
-#define MN_vpcmpneqq 0x2e3d
+#define MN_vpsrlq 0x2ed0
+#define MN_kshiftlq 0x2ed7
+#define MN_vpblendmq 0x2ee0
+#define MN_vptestnmq 0x2eea
+#define MN_vpcomq 0x2ef4
+#define MN_vpermq 0x2efb
+#define MN_vptestmq 0x2f02
+#define MN_kandnq 0x2f0b
+#define MN_vpandnq 0x2f12
+#define MN_valignq 0x2f1a
+#define MN_vpcmpq 0x2f22
+#define MN_incsspq 0x2f29
+#define MN_rdsspq 0x2f31
+#define MN_vcvttpd2qq 0x2f38
+#define MN_vcvtpd2qq 0x2f43
+#define MN_vcvttph2qq 0x2f4d
+#define MN_vcvtph2qq 0x2f58
+#define MN_vcvttps2qq 0x2f62
+#define MN_vcvtps2qq 0x2f6d
+#define MN_vpcomeqq 0x2f77
+#define MN_vpcomneqq 0x2f80
+#define MN_vpcmpneqq 0x2f8a
 #define MN_pcmpeqq (MN_vpcmpeqq + 1)
-#define MN_vpcmpeqq 0x2e47
-#define MN_vpgatherqq 0x2e50
-#define MN_vpscatterqq 0x2e5b
-#define MN_vcvttpd2uqq 0x2e67
-#define MN_vcvtpd2uqq 0x2e73
-#define MN_vcvttph2uqq 0x2e7e
-#define MN_vcvtph2uqq 0x2e8a
-#define MN_vcvttps2uqq 0x2e95
-#define MN_vcvtps2uqq 0x2ea1
-#define MN_korq 0x2eac
-#define MN_kxnorq 0x2eb1
-#define MN_vporq 0x2eb8
-#define MN_vprorq 0x2ebe
-#define MN_kxorq 0x2ec5
-#define MN_vpxorq 0x2ecb
+#define MN_vpcmpeqq 0x2f94
+#define MN_vpgatherqq 0x2f9d
+#define MN_vpscatterqq 0x2fa8
+#define MN_vcvttpd2uqq 0x2fb4
+#define MN_vcvtpd2uqq 0x2fc0
+#define MN_vcvttph2uqq 0x2fcb
+#define MN_vcvtph2uqq 0x2fd7
+#define MN_vcvttps2uqq 0x2fe2
+#define MN_vcvtps2uqq 0x2fee
+#define MN_korq 0x2ff9
+#define MN_kxnorq 0x2ffe
+#define MN_vporq 0x3005
+#define MN_vprorq 0x300b
+#define MN_kxorq 0x3012
+#define MN_vpxorq 0x3018
 #define MN_pinsrq (MN_vpinsrq + 1)
-#define MN_vpinsrq 0x2ed2
-#define MN_kshiftrq 0x2eda
+#define MN_vpinsrq 0x301f
+#define MN_kshiftrq 0x3027
 #define MN_extrq (MN_pextrq + 1)
 #define MN_pextrq (MN_vpextrq + 1)
-#define MN_vpextrq 0x2ee3
-#define MN_vpabsq 0x2eeb
-#define MN_vpminsq 0x2ef2
-#define MN_vpcompressq 0x2efa
-#define MN_wrssq 0x2f06
-#define MN_wrussq 0x2f0c
-#define MN_vpmaxsq 0x2f13
-#define MN_vp2intersectq 0x2f1b
-#define MN_vpconflictq 0x2f29
-#define MN_vpcomgtq 0x2f35
+#define MN_vpextrq 0x3030
+#define MN_vpabsq 0x3038
+#define MN_vpminsq 0x303f
+#define MN_vpcompressq 0x3047
+#define MN_wrssq 0x3053
+#define MN_wrussq 0x3059
+#define MN_vpmaxsq 0x3060
+#define MN_vp2intersectq 0x3068
+#define MN_vpconflictq 0x3076
+#define MN_vpcomgtq 0x3082
 #define MN_pcmpgtq (MN_vpcmpgtq + 1)
-#define MN_vpcmpgtq 0x2f3e
-#define MN_cltq 0x2f47
-#define MN_vpcomltq 0x2f4c
-#define MN_vpcmpnltq 0x2f55
-#define MN_vpcmpltq 0x2f5f
-#define MN_vpopcntq 0x2f68
-#define MN_vplzcntq 0x2f71
-#define MN_movntq 0x2f7a
-#define MN_knotq 0x2f81
-#define MN_vprotq 0x2f87
-#define MN_insertq 0x2f8e
-#define MN_vpbroadcastq 0x2f96
-#define MN_ktestq 0x2fa3
-#define MN_kortestq 0x2faa
-#define MN_vpcomgeuq 0x2fb3
-#define MN_vpcomleuq 0x2fbd
-#define MN_vpcmpnleuq 0x2fc7
-#define MN_vpcmpleuq 0x2fd2
-#define MN_vpcomfalseuq 0x2fdc
-#define MN_vpcomtrueuq 0x2fe9
-#define MN_vpmadd52huq 0x2ff5
-#define MN_vpmadd52luq 0x3001
-#define MN_vpcomuq 0x300d
-#define MN_vpminuq 0x3015
-#define MN_vpcmpuq 0x301d
-#define MN_vpcomequq 0x3025
-#define MN_vpcomnequq 0x302f
-#define MN_vpcmpnequq 0x303a
-#define MN_vpcmpequq 0x3045
-#define MN_vpcomgtuq 0x304f
-#define MN_vpcomltuq 0x3059
-#define MN_vpcmpnltuq 0x3063
-#define MN_vpcmpltuq 0x306e
-#define MN_vpmaxuq 0x3078
-#define MN_vpsravq 0x3080
-#define MN_vpshldvq 0x3088
-#define MN_vpshrdvq 0x3091
-#define MN_vpsllvq 0x309a
-#define MN_vprolvq 0x30a2
-#define MN_vpsrlvq 0x30aa
+#define MN_vpcmpgtq 0x308b
+#define MN_cltq 0x3094
+#define MN_vpcomltq 0x3099
+#define MN_vpcmpnltq 0x30a2
+#define MN_vpcmpltq 0x30ac
+#define MN_vpopcntq 0x30b5
+#define MN_vplzcntq 0x30be
+#define MN_movntq 0x30c7
+#define MN_knotq 0x30ce
+#define MN_vprotq 0x30d4
+#define MN_insertq 0x30db
+#define MN_vpbroadcastq 0x30e3
+#define MN_ktestq 0x30f0
+#define MN_kortestq 0x30f7
+#define MN_vpcomgeuq 0x3100
+#define MN_vpcomleuq 0x310a
+#define MN_vpcmpnleuq 0x3114
+#define MN_vpcmpleuq 0x311f
+#define MN_vpcomfalseuq 0x3129
+#define MN_vpcomtrueuq 0x3136
+#define MN_vpmadd52huq 0x3142
+#define MN_vpmadd52luq 0x314e
+#define MN_vpcomuq 0x315a
+#define MN_vpminuq 0x3162
+#define MN_vpcmpuq 0x316a
+#define MN_vpcomequq 0x3172
+#define MN_vpcomnequq 0x317c
+#define MN_vpcmpnequq 0x3187
+#define MN_vpcmpequq 0x3192
+#define MN_vpcomgtuq 0x319c
+#define MN_vpcomltuq 0x31a6
+#define MN_vpcmpnltuq 0x31b0
+#define MN_vpcmpltuq 0x31bb
+#define MN_vpmaxuq 0x31c5
+#define MN_vpsravq 0x31cd
+#define MN_vpshldvq 0x31d5
+#define MN_vpshrdvq 0x31de
+#define MN_vpsllvq 0x31e7
+#define MN_vprolvq 0x31ef
+#define MN_vpsrlvq 0x31f7
 #define MN_movq (MN_kmovq + 1)
 #define MN_kmovq (MN_maskmovq + 3)
 #define MN_maskmovq (MN_vpmaskmovq + 2)
-#define MN_vpmaskmovq 0x30b2
-#define MN_vmovq 0x30bd
-#define MN_vprorvq 0x30c3
-#define MN_vphaddwq 0x30cb
-#define MN_vphadduwq 0x30d4
+#define MN_vpmaskmovq 0x31ff
+#define MN_vmovq 0x320a
+#define MN_vprorvq 0x3210
+#define MN_vphaddwq 0x3218
+#define MN_vphadduwq 0x3221
 #define MN_pmovsxwq (MN_vpmovsxwq + 1)
-#define MN_vpmovsxwq 0x30de
+#define MN_vpmovsxwq 0x322b
 #define MN_pmovzxwq (MN_vpmovzxwq + 1)
-#define MN_vpmovzxwq 0x30e8
-#define MN_rex_r 0x30f2
-#define MN_vmclear 0x30f8
-#define MN_lar 0x3100
-#define MN_sar 0x3104
+#define MN_vpmovzxwq 0x3235
+#define MN_rex_r 0x323f
+#define MN_vmclear 0x3245
+#define MN_lar 0x324d
+#define MN_sar 0x3251
 #define MN_fsubr (MN_pfsubr + 1)
-#define MN_pfsubr 0x3108
-#define MN_fisubr 0x310f
-#define MN_rcr 0x3116
-#define MN_vzeroupper 0x311a
+#define MN_pfsubr 0x3255
+#define MN_fisubr 0x325c
+#define MN_rcr 0x3263
+#define MN_vzeroupper 0x3267
 #define MN_enter (MN_sysenter + 3)
-#define MN_sysenter 0x3125
-#define MN_shr 0x312e
-#define MN_clr 0x3132
+#define MN_sysenter 0x3272
+#define MN_shr 0x327b
+#define MN_clr 0x327f
 #define MN_palignr (MN_vpalignr + 1)
-#define MN_vpalignr 0x3136
+#define MN_vpalignr 0x3283
 #define MN_or (MN_aor + 1)
-#define MN_aor 0x313f
+#define MN_aor 0x328c
 #define MN_por (MN_vpor + 1)
-#define MN_vpor 0x3143
-#define MN_ror 0x3148
+#define MN_vpor 0x3290
+#define MN_ror 0x3295
 #define MN_monitor (MN_umonitor + 1)
-#define MN_umonitor 0x314c
-#define MN_frstor 0x3155
+#define MN_umonitor 0x3299
+#define MN_frstor 0x32a2
 #define MN_xrstor (MN_fxrstor + 1)
-#define MN_fxrstor 0x315c
+#define MN_fxrstor 0x32a9
 #define MN_xor (MN_axor + 1)
-#define MN_axor 0x3164
+#define MN_axor 0x32b1
 #define MN_pxor (MN_vpxor + 1)
-#define MN_vpxor 0x3169
-#define MN_verr 0x316f
-#define MN_bsr 0x3174
+#define MN_vpxor 0x32b6
+#define MN_verr 0x32bc
+#define MN_bsr 0x32c1
 #define MN_ldmxcsr (MN_vldmxcsr + 1)
-#define MN_vldmxcsr 0x3178
+#define MN_vldmxcsr 0x32c5
 #define MN_stmxcsr (MN_vstmxcsr + 1)
-#define MN_vstmxcsr 0x3181
-#define MN_blsr 0x318a
+#define MN_vstmxcsr 0x32ce
+#define MN_blsr 0x32d7
 #define MN_rdmsr (MN_urdmsr + 1)
-#define MN_urdmsr 0x318f
+#define MN_urdmsr 0x32dc
 #define MN_wrmsr (MN_uwrmsr + 1)
-#define MN_uwrmsr 0x3196
-#define MN_btr 0x319d
-#define MN_xcrypt_ctr 0x31a1
-#define MN_xcryptctr 0x31ac
-#define MN_ltr 0x31b6
-#define MN_str 0x31ba
-#define MN_bextr 0x31be
-#define MN_fdivr 0x31c4
-#define MN_fidivr 0x31ca
-#define MN_rex_wr 0x31d1
-#define MN_aas 0x31d8
-#define MN_scas 0x31dc
-#define MN_das 0x31e1
-#define MN_fabs 0x31e5
-#define MN_movabs 0x31ea
+#define MN_uwrmsr 0x32e3
+#define MN_btr 0x32ea
+#define MN_xcrypt_ctr 0x32ee
+#define MN_xcryptctr 0x32f9
+#define MN_ltr 0x3303
+#define MN_str 0x3307
+#define MN_bextr 0x330b
+#define MN_fdivr 0x3311
+#define MN_fidivr 0x3317
+#define MN_rex_wr 0x331e
+#define MN_aas 0x3325
+#define MN_scas 0x3329
+#define MN_das 0x332e
+#define MN_fabs 0x3332
+#define MN_movabs 0x3337
 #define MN_cs (MN_blcs + 2)
-#define MN_blcs 0x31f1
+#define MN_blcs 0x333e
 #define MN_ds (MN_lds + 1)
-#define MN_lds 0x31f6
-#define MN_enqcmds 0x31fa
-#define MN_lods 0x3202
-#define MN_vpdpbssds 0x3207
-#define MN_vp4dpwssds 0x3211
-#define MN_vpdpwssds 0x321c
-#define MN_vpdpbusds 0x3226
-#define MN_vpdpwusds 0x3230
-#define MN_vpdpbsuds 0x323a
-#define MN_vpdpwsuds 0x3244
-#define MN_vpdpbuuds 0x324e
-#define MN_vpdpwuuds 0x3258
+#define MN_lds 0x3343
+#define MN_enqcmds 0x3347
+#define MN_lods 0x334f
+#define MN_vpdpbssds 0x3354
+#define MN_vp4dpwssds 0x335e
+#define MN_vpdpwssds 0x3369
+#define MN_vpdpbusds 0x3373
+#define MN_vpdpwusds 0x337d
+#define MN_vpdpbsuds 0x3387
+#define MN_vpdpwsuds 0x3391
+#define MN_vpdpbuuds 0x339b
+#define MN_vpdpwuuds 0x33a5
 #define MN_es (MN_les + 1)
-#define MN_les 0x3262
-#define MN_xsaves 0x3266
+#define MN_les 0x33af
+#define MN_xsaves 0x33b3
 #define MN_fs (MN_lfs + 1)
-#define MN_lfs 0x326d
+#define MN_lfs 0x33ba
 #define MN_gs (MN_lkgs + 2)
-#define MN_lkgs 0x3271
-#define MN_lgs 0x3276
-#define MN_swapgs 0x327a
-#define MN_fchs 0x3281
-#define MN_js 0x3286
-#define MN_encls 0x3289
+#define MN_lkgs 0x33be
+#define MN_lgs 0x33c3
+#define MN_swapgs 0x33c7
+#define MN_fchs 0x33ce
+#define MN_js 0x33d3
+#define MN_encls 0x33d6
 #define MN_emms (MN_femms + 1)
-#define MN_femms 0x328f
+#define MN_femms 0x33dc
 #define MN_ins (MN_lwpins + 3)
-#define MN_lwpins 0x3295
-#define MN_jns 0x329c
-#define MN_wrmsrns 0x32a0
-#define MN_setns 0x32a8
-#define MN_setzuns 0x32ae
-#define MN_cmovns 0x32b6
-#define MN_fcos 0x32bd
-#define MN_fsincos 0x32c2
-#define MN_stos 0x32ca
-#define MN_vfmaddsub231ps 0x32cf
-#define MN_vfmsub231ps 0x32de
-#define MN_vfnmsub231ps 0x32ea
-#define MN_vfmsubadd231ps 0x32f7
-#define MN_vfmadd231ps 0x3306
-#define MN_vfnmadd231ps 0x3312
-#define MN_vfmaddsub132ps 0x331f
-#define MN_vfmsub132ps 0x332e
-#define MN_vfnmsub132ps 0x333a
-#define MN_vfmsubadd132ps 0x3347
-#define MN_vfmadd132ps 0x3356
-#define MN_vfnmadd132ps 0x3362
-#define MN_vcvtneebf162ps 0x336f
-#define MN_vbcstnebf162ps 0x337e
-#define MN_vcvtneobf162ps 0x338d
+#define MN_lwpins 0x33e2
+#define MN_jns 0x33e9
+#define MN_ccmpns 0x33ed
+#define MN_wrmsrns 0x33f4
+#define MN_setns 0x33fc
+#define MN_ctestns 0x3402
+#define MN_setzuns 0x340a
+#define MN_cmovns 0x3412
+#define MN_fcos 0x3419
+#define MN_fsincos 0x341e
+#define MN_stos 0x3426
+#define MN_vfmaddsub231ps 0x342b
+#define MN_vfmsub231ps 0x343a
+#define MN_vfnmsub231ps 0x3446
+#define MN_vfmsubadd231ps 0x3453
+#define MN_vfmadd231ps 0x3462
+#define MN_vfnmadd231ps 0x346e
+#define MN_vfmaddsub132ps 0x347b
+#define MN_vfmsub132ps 0x348a
+#define MN_vfnmsub132ps 0x3496
+#define MN_vfmsubadd132ps 0x34a3
+#define MN_vfmadd132ps 0x34b2
+#define MN_vfnmadd132ps 0x34be
+#define MN_vcvtneebf162ps 0x34cb
+#define MN_vbcstnebf162ps 0x34da
+#define MN_vcvtneobf162ps 0x34e9
 #define MN_cvtpd2ps (MN_vcvtpd2ps + 1)
-#define MN_vcvtpd2ps 0x339c
-#define MN_vcvtneeph2ps 0x33a6
-#define MN_vcvtneoph2ps 0x33b3
-#define MN_vcvtph2ps 0x33c0
-#define MN_vbcstnesh2ps 0x33ca
-#define MN_vpermi2ps 0x33d7
-#define MN_cvtpi2ps 0x33e1
-#define MN_vpermil2ps 0x33ea
-#define MN_vexp2ps 0x33f5
+#define MN_vcvtpd2ps 0x34f8
+#define MN_vcvtneeph2ps 0x3502
+#define MN_vcvtneoph2ps 0x350f
+#define MN_vcvtph2ps 0x351c
+#define MN_vbcstnesh2ps 0x3526
+#define MN_vpermi2ps 0x3533
+#define MN_cvtpi2ps 0x353d
+#define MN_vpermil2ps 0x3546
+#define MN_vexp2ps 0x3551
 #define MN_cvtdq2ps (MN_vcvtdq2ps + 1)
-#define MN_vcvtdq2ps 0x33fd
-#define MN_vcvtudq2ps 0x3407
-#define MN_vcvtqq2ps 0x3412
-#define MN_vcvtuqq2ps 0x341c
-#define MN_vpermt2ps 0x3427
-#define MN_vfmaddsub213ps 0x3431
-#define MN_vfmsub213ps 0x3440
-#define MN_vfnmsub213ps 0x344c
-#define MN_vfmsubadd213ps 0x3459
-#define MN_vfmadd213ps 0x3468
-#define MN_vfnmadd213ps 0x3474
-#define MN_vrcp14ps 0x3481
-#define MN_vrsqrt14ps 0x348a
-#define MN_tdpbf16ps 0x3495
-#define MN_vdpbf16ps 0x349f
-#define MN_tcmmrlfp16ps 0x34a9
-#define MN_tcmmimfp16ps 0x34b6
-#define MN_tdpfp16ps 0x34c3
-#define MN_vrcp28ps 0x34cd
-#define MN_vrsqrt28ps 0x34d6
+#define MN_vcvtdq2ps 0x3559
+#define MN_vcvtudq2ps 0x3563
+#define MN_vcvtqq2ps 0x356e
+#define MN_vcvtuqq2ps 0x3578
+#define MN_vpermt2ps 0x3583
+#define MN_vfmaddsub213ps 0x358d
+#define MN_vfmsub213ps 0x359c
+#define MN_vfnmsub213ps 0x35a8
+#define MN_vfmsubadd213ps 0x35b5
+#define MN_vfmadd213ps 0x35c4
+#define MN_vfnmadd213ps 0x35d0
+#define MN_vrcp14ps 0x35dd
+#define MN_vrsqrt14ps 0x35e6
+#define MN_tdpbf16ps 0x35f1
+#define MN_vdpbf16ps 0x35fb
+#define MN_tcmmrlfp16ps 0x3605
+#define MN_tcmmimfp16ps 0x3612
+#define MN_tdpfp16ps 0x361f
+#define MN_vrcp28ps 0x3629
+#define MN_vrsqrt28ps 0x3632
 #define MN_movaps (MN_vmovaps + 1)
-#define MN_vmovaps 0x34e1
+#define MN_vmovaps 0x363d
 #define MN_subps (MN_addsubps + 3)
 #define MN_addsubps (MN_vfmaddsubps + 3)
-#define MN_vfmaddsubps 0x34e9
-#define MN_vaddsubps 0x34f5
+#define MN_vfmaddsubps 0x3645
+#define MN_vaddsubps 0x3651
 #define MN_hsubps (MN_vhsubps + 1)
-#define MN_vhsubps 0x34ff
-#define MN_vfmsubps 0x3507
-#define MN_vfnmsubps 0x3510
-#define MN_vsubps 0x351a
-#define MN_vgatherpf0dps 0x3521
-#define MN_vscatterpf0dps 0x352f
-#define MN_vgatherpf1dps 0x353e
-#define MN_vscatterpf1dps 0x354c
+#define MN_vhsubps 0x365b
+#define MN_vfmsubps 0x3663
+#define MN_vfnmsubps 0x366c
+#define MN_vsubps 0x3676
+#define MN_vgatherpf0dps 0x367d
+#define MN_vscatterpf0dps 0x368b
+#define MN_vgatherpf1dps 0x369a
+#define MN_vscatterpf1dps 0x36a8
 #define MN_addps (MN_vfmsubaddps + 6)
-#define MN_vfmsubaddps 0x355b
+#define MN_vfmsubaddps 0x36b7
 #define MN_haddps (MN_vhaddps + 1)
-#define MN_vhaddps 0x3567
-#define MN_v4fmaddps 0x356f
-#define MN_vfmaddps 0x3579
-#define MN_v4fnmaddps 0x3582
-#define MN_vfnmaddps 0x358d
-#define MN_vaddps 0x3597
+#define MN_vhaddps 0x36c3
+#define MN_v4fmaddps 0x36cb
+#define MN_vfmaddps 0x36d5
+#define MN_v4fnmaddps 0x36de
+#define MN_vfnmaddps 0x36e9
+#define MN_vaddps 0x36f3
 #define MN_andps (MN_vexpandps + 4)
-#define MN_vexpandps 0x359e
-#define MN_vandps 0x35a8
+#define MN_vexpandps 0x36fa
+#define MN_vandps 0x3704
 #define MN_blendps (MN_vblendps + 1)
-#define MN_vblendps 0x35af
+#define MN_vblendps 0x370b
 #define MN_roundps (MN_vroundps + 1)
-#define MN_vroundps 0x35b8
-#define MN_vgatherdps 0x35c1
-#define MN_vscatterdps 0x35cc
+#define MN_vroundps 0x3714
+#define MN_vgatherdps 0x371d
+#define MN_vscatterdps 0x3728
 #define MN_cmpunordps (MN_vcmpunordps + 1)
-#define MN_vcmpunordps 0x35d8
+#define MN_vcmpunordps 0x3734
 #define MN_cmpordps (MN_vcmpordps + 1)
-#define MN_vcmpordps 0x35e4
-#define MN_vreduceps 0x35ee
-#define MN_vrangeps 0x35f8
-#define MN_vcmpngeps 0x3601
-#define MN_vcmpgeps 0x360b
-#define MN_vrndscaleps 0x3614
+#define MN_vcmpordps 0x3740
+#define MN_vreduceps 0x374a
+#define MN_vrangeps 0x3754
+#define MN_vcmpngeps 0x375d
+#define MN_vcmpgeps 0x3767
+#define MN_vrndscaleps 0x3770
 #define MN_cmpnleps (MN_vcmpnleps + 1)
-#define MN_vcmpnleps 0x3620
+#define MN_vcmpnleps 0x377c
 #define MN_cmpleps (MN_vcmpleps + 1)
-#define MN_vcmpleps 0x362a
-#define MN_vcmpfalseps 0x3633
-#define MN_vcmptrueps 0x363f
-#define MN_vscalefps 0x364a
+#define MN_vcmpleps 0x3786
+#define MN_vcmpfalseps 0x378f
+#define MN_vcmptrueps 0x379b
+#define MN_vscalefps 0x37a6
 #define MN_shufps (MN_vshufps + 1)
-#define MN_vshufps 0x3654
+#define MN_vshufps 0x37b0
 #define MN_unpckhps (MN_vunpckhps + 1)
-#define MN_vunpckhps 0x365c
+#define MN_vunpckhps 0x37b8
 #define MN_movlhps (MN_vmovlhps + 1)
-#define MN_vmovlhps 0x3666
+#define MN_vmovlhps 0x37c2
 #define MN_movhps (MN_vmovhps + 1)
-#define MN_vmovhps 0x366f
+#define MN_vmovhps 0x37cb
 #define MN_movmskps (MN_vmovmskps + 1)
-#define MN_vmovmskps 0x3677
+#define MN_vmovmskps 0x37d3
 #define MN_movhlps (MN_vmovhlps + 1)
-#define MN_vmovhlps 0x3681
-#define MN_vpermilps 0x368a
+#define MN_vmovhlps 0x37dd
+#define MN_vpermilps 0x37e6
 #define MN_unpcklps (MN_vunpcklps + 1)
-#define MN_vunpcklps 0x3694
+#define MN_vunpcklps 0x37f0
 #define MN_mulps (MN_vmulps + 1)
-#define MN_vmulps 0x369e
+#define MN_vmulps 0x37fa
 #define MN_movlps (MN_vmovlps + 1)
-#define MN_vmovlps 0x36a5
-#define MN_cmps 0x36ad
-#define MN_vblendmps 0x36b2
-#define MN_vfixupimmps 0x36bc
-#define MN_vpermps 0x36c8
+#define MN_vmovlps 0x3801
+#define MN_cmps (MN_ccmps + 1)
+#define MN_ccmps 0x3809
+#define MN_vblendmps 0x380f
+#define MN_vfixupimmps 0x3819
+#define MN_vpermps 0x3825
 #define MN_andnps (MN_vandnps + 1)
-#define MN_vandnps 0x36d0
+#define MN_vandnps 0x382d
 #define MN_minps (MN_vminps + 1)
-#define MN_vminps 0x36d8
-#define MN_seamops 0x36df
+#define MN_vminps 0x3835
+#define MN_seamops 0x383c
 #define MN_rcpps (MN_vrcpps + 1)
-#define MN_vrcpps 0x36e7
+#define MN_vrcpps 0x3844
 #define MN_dpps (MN_vdpps + 1)
-#define MN_vdpps 0x36ee
+#define MN_vdpps 0x384b
 #define MN_cmpps (MN_vcmpps + 1)
-#define MN_vcmpps 0x36f4
-#define MN_vgetexpps 0x36fb
-#define MN_vgatherpf0qps 0x3705
-#define MN_vscatterpf0qps 0x3713
-#define MN_vgatherpf1qps 0x3722
-#define MN_vscatterpf1qps 0x3730
-#define MN_vcmpunord_qps 0x373f
-#define MN_vcmpord_qps 0x374d
+#define MN_vcmpps 0x3851
+#define MN_vgetexpps 0x3858
+#define MN_vgatherpf0qps 0x3862
+#define MN_vscatterpf0qps 0x3870
+#define MN_vgatherpf1qps 0x387f
+#define MN_vscatterpf1qps 0x388d
+#define MN_vcmpunord_qps 0x389c
+#define MN_vcmpord_qps 0x38aa
 #define MN_cmpneqps (MN_vcmpneqps + 1)
-#define MN_vcmpneqps 0x3759
+#define MN_vcmpneqps 0x38b6
 #define MN_cmpeqps (MN_vcmpeqps + 1)
-#define MN_vcmpeqps 0x3763
-#define MN_vcmpge_oqps 0x376c
-#define MN_vcmple_oqps 0x3778
-#define MN_vcmpfalse_oqps 0x3784
-#define MN_vcmpneq_oqps 0x3793
-#define MN_vcmpeq_oqps 0x37a0
-#define MN_vcmpgt_oqps 0x37ac
-#define MN_vcmplt_oqps 0x37b8
-#define MN_vgatherqps 0x37c4
-#define MN_vscatterqps 0x37cf
-#define MN_vcmpnge_uqps 0x37db
-#define MN_vcmpnle_uqps 0x37e8
-#define MN_vcmptrue_uqps 0x37f5
-#define MN_vcmpneq_uqps 0x3803
-#define MN_vcmpeq_uqps 0x3810
-#define MN_vcmpngt_uqps 0x381c
-#define MN_vcmpnlt_uqps 0x3829
+#define MN_vcmpeqps 0x38c0
+#define MN_vcmpge_oqps 0x38c9
+#define MN_vcmple_oqps 0x38d5
+#define MN_vcmpfalse_oqps 0x38e1
+#define MN_vcmpneq_oqps 0x38f0
+#define MN_vcmpeq_oqps 0x38fd
+#define MN_vcmpgt_oqps 0x3909
+#define MN_vcmplt_oqps 0x3915
+#define MN_vgatherqps 0x3921
+#define MN_vscatterqps 0x392c
+#define MN_vcmpnge_uqps 0x3938
+#define MN_vcmpnle_uqps 0x3945
+#define MN_vcmptrue_uqps 0x3952
+#define MN_vcmpneq_uqps 0x3960
+#define MN_vcmpeq_uqps 0x396d
+#define MN_vcmpngt_uqps 0x3979
+#define MN_vcmpnlt_uqps 0x3986
 #define MN_orps (MN_vorps + 1)
-#define MN_vorps 0x3836
+#define MN_vorps 0x3993
 #define MN_xorps (MN_vxorps + 1)
-#define MN_vxorps 0x383c
-#define MN_vcmpunord_sps 0x3843
-#define MN_vcmpord_sps 0x3851
-#define MN_vcmpge_osps 0x385d
-#define MN_vcmple_osps 0x3869
-#define MN_vcmpfalse_osps 0x3875
-#define MN_vcmpneq_osps 0x3884
-#define MN_vcmpeq_osps 0x3891
-#define MN_vcmpgt_osps 0x389d
-#define MN_vcmplt_osps 0x38a9
-#define MN_vfpclassps 0x38b5
-#define MN_vcompressps 0x38c0
-#define MN_vcmpnge_usps 0x38cc
-#define MN_vcmpnle_usps 0x38d9
-#define MN_vcmptrue_usps 0x38e6
-#define MN_vcmpneq_usps 0x38f4
-#define MN_vcmpeq_usps 0x3901
-#define MN_vcmpngt_usps 0x390d
-#define MN_vcmpnlt_usps 0x391a
+#define MN_vxorps 0x3999
+#define MN_vcmpunord_sps 0x39a0
+#define MN_vcmpord_sps 0x39ae
+#define MN_vcmpge_osps 0x39ba
+#define MN_vcmple_osps 0x39c6
+#define MN_vcmpfalse_osps 0x39d2
+#define MN_vcmpneq_osps 0x39e1
+#define MN_vcmpeq_osps 0x39ee
+#define MN_vcmpgt_osps 0x39fa
+#define MN_vcmplt_osps 0x3a06
+#define MN_vfpclassps 0x3a12
+#define MN_vcompressps 0x3a1d
+#define MN_vcmpnge_usps 0x3a29
+#define MN_vcmpnle_usps 0x3a36
+#define MN_vcmptrue_usps 0x3a43
+#define MN_vcmpneq_usps 0x3a51
+#define MN_vcmpeq_usps 0x3a5e
+#define MN_vcmpngt_usps 0x3a6a
+#define MN_vcmpnlt_usps 0x3a77
 #define MN_extractps (MN_vextractps + 1)
-#define MN_vextractps 0x3927
-#define MN_vcmpngtps 0x3932
-#define MN_vcmpgtps 0x393c
+#define MN_vextractps 0x3a84
+#define MN_vcmpngtps 0x3a8f
+#define MN_vcmpgtps 0x3a99
 #define MN_cmpnltps (MN_vcmpnltps + 1)
-#define MN_vcmpnltps 0x3945
+#define MN_vcmpnltps 0x3aa2
 #define MN_cmpltps (MN_vcmpltps + 1)
-#define MN_vcmpltps 0x394f
-#define MN_vgetmantps 0x3958
+#define MN_vcmpltps 0x3aac
+#define MN_vgetmantps 0x3ab5
 #define MN_movntps (MN_vmovntps + 1)
-#define MN_vmovntps 0x3963
+#define MN_vmovntps 0x3ac0
 #define MN_insertps (MN_vinsertps + 1)
-#define MN_vinsertps 0x396c
+#define MN_vinsertps 0x3ac9
 #define MN_sqrtps (MN_rsqrtps + 1)
 #define MN_rsqrtps (MN_vrsqrtps + 1)
-#define MN_vrsqrtps 0x3976
-#define MN_vsqrtps 0x397f
-#define MN_vtestps 0x3987
+#define MN_vrsqrtps 0x3ad3
+#define MN_vsqrtps 0x3adc
+#define MN_vtestps 0x3ae4
 #define MN_movups (MN_vmovups + 1)
-#define MN_vmovups 0x398f
+#define MN_vmovups 0x3aec
 #define MN_blendvps (MN_vblendvps + 1)
-#define MN_vblendvps 0x3997
+#define MN_vblendvps 0x3af4
 #define MN_divps (MN_vdivps + 1)
-#define MN_vdivps 0x39a1
-#define MN_vmaskmovps 0x39a8
+#define MN_vdivps 0x3afe
+#define MN_vmaskmovps 0x3b05
 #define MN_maxps (MN_vmaxps + 1)
-#define MN_vmaxps 0x39b3
-#define MN_vfrczps 0x39ba
-#define MN_xrstors 0x39c2
+#define MN_vmaxps 0x3b10
+#define MN_vfrczps 0x3b17
+#define MN_xrstors 0x3b1f
 #define MN_ss (MN_vfmsub231ss + 9)
-#define MN_vfmsub231ss 0x39ca
-#define MN_vfnmsub231ss 0x39d6
-#define MN_vfmadd231ss 0x39e3
-#define MN_vfnmadd231ss 0x39ef
-#define MN_vfmsub132ss 0x39fc
-#define MN_vfnmsub132ss 0x3a08
-#define MN_vfmadd132ss 0x3a15
-#define MN_vfnmadd132ss 0x3a21
+#define MN_vfmsub231ss 0x3b27
+#define MN_vfnmsub231ss 0x3b33
+#define MN_vfmadd231ss 0x3b40
+#define MN_vfnmadd231ss 0x3b4c
+#define MN_vfmsub132ss 0x3b59
+#define MN_vfnmsub132ss 0x3b65
+#define MN_vfmadd132ss 0x3b72
+#define MN_vfnmadd132ss 0x3b7e
 #define MN_cvtsd2ss (MN_vcvtsd2ss + 1)
-#define MN_vcvtsd2ss 0x3a2e
-#define MN_vcvtsh2ss 0x3a38
+#define MN_vcvtsd2ss 0x3b8b
+#define MN_vcvtsh2ss 0x3b95
 #define MN_cvtsi2ss (MN_vcvtsi2ss + 1)
-#define MN_vcvtsi2ss 0x3a42
-#define MN_vcvtusi2ss 0x3a4c
-#define MN_vfmsub213ss 0x3a57
-#define MN_vfnmsub213ss 0x3a63
-#define MN_vfmadd213ss 0x3a70
-#define MN_vfnmadd213ss 0x3a7c
-#define MN_vrcp14ss 0x3a89
-#define MN_vrsqrt14ss 0x3a92
-#define MN_vrcp28ss 0x3a9d
-#define MN_vrsqrt28ss 0x3aa6
+#define MN_vcvtsi2ss 0x3b9f
+#define MN_vcvtusi2ss 0x3ba9
+#define MN_vfmsub213ss 0x3bb4
+#define MN_vfnmsub213ss 0x3bc0
+#define MN_vfmadd213ss 0x3bcd
+#define MN_vfnmadd213ss 0x3bd9
+#define MN_vrcp14ss 0x3be6
+#define MN_vrsqrt14ss 0x3bef
+#define MN_vrcp28ss 0x3bfa
+#define MN_vrsqrt28ss 0x3c03
 #define MN_subss (MN_vfmsubss + 3)
-#define MN_vfmsubss 0x3ab1
-#define MN_vfnmsubss 0x3aba
-#define MN_vsubss 0x3ac4
+#define MN_vfmsubss 0x3c0e
+#define MN_vfnmsubss 0x3c17
+#define MN_vsubss 0x3c21
 #define MN_addss (MN_v4fmaddss + 4)
-#define MN_v4fmaddss 0x3acb
-#define MN_vfmaddss 0x3ad5
-#define MN_v4fnmaddss 0x3ade
-#define MN_vfnmaddss 0x3ae9
-#define MN_vaddss 0x3af3
+#define MN_v4fmaddss 0x3c28
+#define MN_vfmaddss 0x3c32
+#define MN_v4fnmaddss 0x3c3b
+#define MN_vfnmaddss 0x3c46
+#define MN_vaddss 0x3c50
 #define MN_roundss (MN_vroundss + 1)
-#define MN_vroundss 0x3afa
+#define MN_vroundss 0x3c57
 #define MN_cmpunordss (MN_vcmpunordss + 1)
-#define MN_vcmpunordss 0x3b03
+#define MN_vcmpunordss 0x3c60
 #define MN_cmpordss (MN_vcmpordss + 1)
-#define MN_vcmpordss 0x3b0f
-#define MN_vreducess 0x3b19
-#define MN_vrangess 0x3b23
-#define MN_vcmpngess 0x3b2c
-#define MN_vcmpgess 0x3b36
-#define MN_vrndscaless 0x3b3f
+#define MN_vcmpordss 0x3c6c
+#define MN_vreducess 0x3c76
+#define MN_vrangess 0x3c80
+#define MN_vcmpngess 0x3c89
+#define MN_vcmpgess 0x3c93
+#define MN_vrndscaless 0x3c9c
 #define MN_cmpnless (MN_vcmpnless + 1)
-#define MN_vcmpnless 0x3b4b
+#define MN_vcmpnless 0x3ca8
 #define MN_cmpless (MN_vcmpless + 1)
-#define MN_vcmpless 0x3b55
-#define MN_vcmpfalsess 0x3b5e
-#define MN_vcmptruess 0x3b6a
-#define MN_vscalefss 0x3b75
+#define MN_vcmpless 0x3cb2
+#define MN_vcmpfalsess 0x3cbb
+#define MN_vcmptruess 0x3cc7
+#define MN_vscalefss 0x3cd2
 #define MN_comiss (MN_ucomiss + 1)
 #define MN_ucomiss (MN_vucomiss + 1)
-#define MN_vucomiss 0x3b7f
-#define MN_vcomiss 0x3b88
+#define MN_vucomiss 0x3cdc
+#define MN_vcomiss 0x3ce5
 #define MN_lss (MN_mulss + 2)
 #define MN_mulss (MN_vmulss + 1)
-#define MN_vmulss 0x3b90
-#define MN_vfixupimmss 0x3b97
+#define MN_vmulss 0x3ced
+#define MN_vfixupimmss 0x3cf4
 #define MN_minss (MN_vminss + 1)
-#define MN_vminss 0x3ba3
+#define MN_vminss 0x3d00
 #define MN_rcpss (MN_vrcpss + 1)
-#define MN_vrcpss 0x3baa
+#define MN_vrcpss 0x3d07
 #define MN_cmpss (MN_vcmpss + 1)
-#define MN_vcmpss 0x3bb1
-#define MN_vgetexpss 0x3bb8
-#define MN_vcmpunord_qss 0x3bc2
-#define MN_vcmpord_qss 0x3bd0
+#define MN_vcmpss 0x3d0e
+#define MN_vgetexpss 0x3d15
+#define MN_vcmpunord_qss 0x3d1f
+#define MN_vcmpord_qss 0x3d2d
 #define MN_cmpneqss (MN_vcmpneqss + 1)
-#define MN_vcmpneqss 0x3bdc
+#define MN_vcmpneqss 0x3d39
 #define MN_cmpeqss (MN_vcmpeqss + 1)
-#define MN_vcmpeqss 0x3be6
-#define MN_vcmpge_oqss 0x3bef
-#define MN_vcmple_oqss 0x3bfb
-#define MN_vcmpfalse_oqss 0x3c07
-#define MN_vcmpneq_oqss 0x3c16
-#define MN_vcmpeq_oqss 0x3c23
-#define MN_vcmpgt_oqss 0x3c2f
-#define MN_vcmplt_oqss 0x3c3b
-#define MN_vcmpnge_uqss 0x3c47
-#define MN_vcmpnle_uqss 0x3c54
-#define MN_vcmptrue_uqss 0x3c61
-#define MN_vcmpneq_uqss 0x3c6f
-#define MN_vcmpeq_uqss 0x3c7c
-#define MN_vcmpngt_uqss 0x3c88
-#define MN_vcmpnlt_uqss 0x3c95
-#define MN_vcmpunord_sss 0x3ca2
-#define MN_vcmpord_sss 0x3cb0
-#define MN_vcmpge_osss 0x3cbc
-#define MN_vcmple_osss 0x3cc8
-#define MN_vcmpfalse_osss 0x3cd4
-#define MN_vcmpneq_osss 0x3ce3
-#define MN_vcmpeq_osss 0x3cf0
-#define MN_vcmpgt_osss 0x3cfc
-#define MN_vcmplt_osss 0x3d08
-#define MN_vfpclassss 0x3d14
-#define MN_vcmpnge_usss 0x3d1f
-#define MN_vcmpnle_usss 0x3d2c
-#define MN_vcmptrue_usss 0x3d39
-#define MN_vcmpneq_usss 0x3d47
-#define MN_vcmpeq_usss 0x3d54
-#define MN_vcmpngt_usss 0x3d60
-#define MN_vcmpnlt_usss 0x3d6d
-#define MN_vcmpngtss 0x3d7a
-#define MN_vcmpgtss 0x3d84
+#define MN_vcmpeqss 0x3d43
+#define MN_vcmpge_oqss 0x3d4c
+#define MN_vcmple_oqss 0x3d58
+#define MN_vcmpfalse_oqss 0x3d64
+#define MN_vcmpneq_oqss 0x3d73
+#define MN_vcmpeq_oqss 0x3d80
+#define MN_vcmpgt_oqss 0x3d8c
+#define MN_vcmplt_oqss 0x3d98
+#define MN_vcmpnge_uqss 0x3da4
+#define MN_vcmpnle_uqss 0x3db1
+#define MN_vcmptrue_uqss 0x3dbe
+#define MN_vcmpneq_uqss 0x3dcc
+#define MN_vcmpeq_uqss 0x3dd9
+#define MN_vcmpngt_uqss 0x3de5
+#define MN_vcmpnlt_uqss 0x3df2
+#define MN_vcmpunord_sss 0x3dff
+#define MN_vcmpord_sss 0x3e0d
+#define MN_vcmpge_osss 0x3e19
+#define MN_vcmple_osss 0x3e25
+#define MN_vcmpfalse_osss 0x3e31
+#define MN_vcmpneq_osss 0x3e40
+#define MN_vcmpeq_osss 0x3e4d
+#define MN_vcmpgt_osss 0x3e59
+#define MN_vcmplt_osss 0x3e65
+#define MN_vfpclassss 0x3e71
+#define MN_vcmpnge_usss 0x3e7c
+#define MN_vcmpnle_usss 0x3e89
+#define MN_vcmptrue_usss 0x3e96
+#define MN_vcmpneq_usss 0x3ea4
+#define MN_vcmpeq_usss 0x3eb1
+#define MN_vcmpngt_usss 0x3ebd
+#define MN_vcmpnlt_usss 0x3eca
+#define MN_vcmpngtss 0x3ed7
+#define MN_vcmpgtss 0x3ee1
 #define MN_cmpnltss (MN_vcmpnltss + 1)
-#define MN_vcmpnltss 0x3d8d
+#define MN_vcmpnltss 0x3eea
 #define MN_cmpltss (MN_vcmpltss + 1)
-#define MN_vcmpltss 0x3d97
-#define MN_vgetmantss 0x3da0
-#define MN_movntss 0x3dab
+#define MN_vcmpltss 0x3ef4
+#define MN_vgetmantss 0x3efd
+#define MN_movntss 0x3f08
 #define MN_sqrtss (MN_rsqrtss + 1)
 #define MN_rsqrtss (MN_vrsqrtss + 1)
-#define MN_vrsqrtss 0x3db3
-#define MN_vsqrtss 0x3dbc
-#define MN_vbroadcastss 0x3dc4
+#define MN_vrsqrtss 0x3f10
+#define MN_vsqrtss 0x3f19
+#define MN_vbroadcastss 0x3f21
 #define MN_divss (MN_vdivss + 1)
-#define MN_vdivss 0x3dd1
+#define MN_vdivss 0x3f2e
 #define MN_movss (MN_vmovss + 1)
-#define MN_vmovss 0x3dd8
+#define MN_vmovss 0x3f35
 #define MN_maxss (MN_vmaxss + 1)
-#define MN_vmaxss 0x3ddf
-#define MN_vfrczss 0x3de6
-#define MN_bts 0x3dee
-#define MN_erets 0x3df2
-#define MN_sets 0x3df8
-#define MN_clts 0x3dfd
-#define MN_outs 0x3e02
-#define MN_setzus 0x3e07
+#define MN_vmaxss 0x3f3c
+#define MN_vfrczss 0x3f43
+#define MN_bts 0x3f4b
+#define MN_erets 0x3f4f
+#define MN_sets 0x3f55
+#define MN_clts 0x3f5a
+#define MN_ctests 0x3f5f
+#define MN_outs 0x3f66
+#define MN_setzus 0x3f6b
 #define MN_movs (MN_cmovs + 1)
-#define MN_cmovs 0x3e0e
-#define MN_fldl2t 0x3e14
-#define MN_xlat 0x3e1b
-#define MN_bt 0x3e20
-#define MN_fxtract 0x3e23
-#define MN_lgdt 0x3e2b
-#define MN_sgdt 0x3e30
-#define MN_lidt 0x3e35
-#define MN_sidt 0x3e3a
-#define MN_fldt 0x3e3f
-#define MN_lldt 0x3e44
-#define MN_sldt 0x3e49
+#define MN_cmovs 0x3f72
+#define MN_fldl2t 0x3f78
+#define MN_xlat 0x3f7f
+#define MN_bt 0x3f84
+#define MN_fxtract 0x3f87
+#define MN_lgdt 0x3f8f
+#define MN_sgdt 0x3f94
+#define MN_lidt 0x3f99
+#define MN_sidt 0x3f9e
+#define MN_fldt 0x3fa3
+#define MN_lldt 0x3fa8
+#define MN_sldt 0x3fad
 #define MN_ret (MN_iret + 1)
 #define MN_iret (MN_uiret + 1)
-#define MN_uiret 0x3e4e
-#define MN_lret 0x3e54
-#define MN_seamret 0x3e59
-#define MN_sysret 0x3e61
-#define MN_hreset 0x3e68
-#define MN_pfcmpgt 0x3e6f
-#define MN_ht 0x3e77
+#define MN_uiret 0x3fb2
+#define MN_lret 0x3fb8
+#define MN_seamret 0x3fbd
+#define MN_sysret 0x3fc5
+#define MN_hreset 0x3fcc
+#define MN_pfcmpgt 0x3fd3
+#define MN_ht 0x3fdb
 #define MN_wait (MN_fwait + 1)
-#define MN_fwait 0x3e7a
+#define MN_fwait 0x3fde
 #define MN_mwait (MN_umwait + 1)
-#define MN_umwait 0x3e80
-#define MN_mcommit 0x3e87
-#define MN_finit 0x3e8f
-#define MN_skinit 0x3e95
-#define MN_fninit 0x3e9c
-#define MN_vmgexit 0x3ea3
-#define MN_sysexit 0x3eab
-#define MN_hlt 0x3eb3
-#define MN_popcnt 0x3eb7
-#define MN_lzcnt 0x3ebe
-#define MN_tzcnt 0x3ec4
-#define MN_hnt 0x3eca
+#define MN_umwait 0x3fe4
+#define MN_mcommit 0x3feb
+#define MN_finit 0x3ff3
+#define MN_skinit 0x3ff9
+#define MN_fninit 0x4000
+#define MN_vmgexit 0x4007
+#define MN_sysexit 0x400f
+#define MN_hlt 0x4017
+#define MN_popcnt 0x401b
+#define MN_lzcnt 0x4022
+#define MN_tzcnt 0x4028
+#define MN_hnt 0x402e
 #define MN_int (MN_frndint + 4)
-#define MN_frndint 0x3ece
-#define MN_not 0x3ed6
-#define MN_invept 0x3eda
-#define MN_xsaveopt 0x3ee1
-#define MN_clflushopt 0x3eea
-#define MN_fstpt 0x3ef5
-#define MN_xabort 0x3efb
-#define MN_fsqrt 0x3f02
-#define MN_pfrsqrt 0x3f08
+#define MN_frndint 0x4032
+#define MN_not 0x403a
+#define MN_invept 0x403e
+#define MN_ccmpt 0x4045
+#define MN_xsaveopt 0x404b
+#define MN_clflushopt 0x4054
+#define MN_fstpt 0x405f
+#define MN_xabort 0x4065
+#define MN_fsqrt 0x406c
+#define MN_pfrsqrt 0x4072
 #define MN_aesdeclast (MN_vaesdeclast + 1)
-#define MN_vaesdeclast 0x3f10
+#define MN_vaesdeclast 0x407a
 #define MN_aesenclast (MN_vaesenclast + 1)
-#define MN_vaesenclast 0x3f1c
+#define MN_vaesenclast 0x4086
 #define MN_test (MN_ptest + 1)
 #define MN_ptest (MN_vptest + 1)
-#define MN_vptest 0x3f28
-#define MN_xtest 0x3f2f
-#define MN_fst 0x3f35
-#define MN_fist 0x3f39
-#define MN_rdmsrlist 0x3f3e
-#define MN_wrmsrlist 0x3f48
+#define MN_vptest 0x4092
+#define MN_xtest 0x4099
+#define MN_fst 0x409f
+#define MN_fist 0x40a3
+#define MN_rdmsrlist 0x40a8
+#define MN_wrmsrlist 0x40b2
 #define MN_aeskeygenassist (MN_vaeskeygenassist + 1)
-#define MN_vaeskeygenassist 0x3f52
-#define MN_vmptrst 0x3f63
-#define MN_ftst 0x3f6b
-#define MN_rmpadjust 0x3f70
-#define MN_out 0x3f7a
-#define MN_pext 0x3f7e
-#define MN_bndcu 0x3f83
-#define MN_enclu 0x3f89
-#define MN_fcmovnu 0x3f8f
+#define MN_vaeskeygenassist 0x40bc
+#define MN_vmptrst 0x40cd
+#define MN_ftst 0x40d5
+#define MN_rmpadjust 0x40da
+#define MN_ctestt 0x40e4
+#define MN_out 0x40eb
+#define MN_pext 0x40ef
+#define MN_bndcu 0x40f4
+#define MN_enclu 0x40fa
+#define MN_fcmovnu 0x4100
 #define MN_lddqu (MN_vlddqu + 1)
-#define MN_vlddqu 0x3f97
+#define MN_vlddqu 0x4108
 #define MN_movdqu (MN_maskmovdqu + 4)
 #define MN_maskmovdqu (MN_vmaskmovdqu + 1)
-#define MN_vmaskmovdqu 0x3f9e
-#define MN_vmovdqu 0x3faa
-#define MN_rdpkru 0x3fb2
-#define MN_wrpkru 0x3fb9
-#define MN_rdpru 0x3fc0
-#define MN_eretu 0x3fc6
-#define MN_fcmovu 0x3fcc
-#define MN_imulzu 0x3fd3
-#define MN_xgetbv 0x3fda
-#define MN_xsetbv 0x3fe1
+#define MN_vmaskmovdqu 0x410f
+#define MN_vmovdqu 0x411b
+#define MN_rdpkru 0x4123
+#define MN_wrpkru 0x412a
+#define MN_rdpru 0x4131
+#define MN_eretu 0x4137
+#define MN_fcmovu 0x413d
+#define MN_imulzu 0x4144
+#define MN_xgetbv 0x414b
+#define MN_xsetbv 0x4152
 #define MN_div (MN_fdiv + 1)
-#define MN_fdiv 0x3fe8
+#define MN_fdiv 0x4159
 #define MN_idiv (MN_fidiv + 1)
-#define MN_fidiv 0x3fed
-#define MN_enclv 0x3ff3
-#define MN_fldenv 0x3ff9
-#define MN_fstenv 0x4000
-#define MN_fnstenv 0x4007
+#define MN_fidiv 0x415e
+#define MN_enclv 0x4164
+#define MN_fldenv 0x416a
+#define MN_fstenv 0x4171
+#define MN_fnstenv 0x4178
 #define MN_mov (MN_vpcmov + 3)
-#define MN_vpcmov 0x400f
-#define MN_bndmov 0x4016
-#define MN_smov 0x401d
-#define MN_rex_w 0x4022
-#define MN_vcvttph2w 0x4028
-#define MN_vcvtph2w 0x4032
-#define MN_vpermi2w 0x403b
-#define MN_vpmovm2w 0x4044
-#define MN_vpermt2w 0x404d
-#define MN_vpshaw 0x4056
+#define MN_vpcmov 0x4180
+#define MN_bndmov 0x4187
+#define MN_smov 0x418e
+#define MN_rex_w 0x4193
+#define MN_vcvttph2w 0x4199
+#define MN_vcvtph2w 0x41a3
+#define MN_vpermi2w 0x41ac
+#define MN_vpmovm2w 0x41b5
+#define MN_vpermt2w 0x41be
+#define MN_vpshaw 0x41c7
 #define MN_psraw (MN_vpsraw + 1)
-#define MN_vpsraw 0x405d
-#define MN_vphsubbw 0x4064
-#define MN_cbw 0x406d
+#define MN_vpsraw 0x41ce
+#define MN_vphsubbw 0x41d5
+#define MN_cbw 0x41de
 #define MN_psadbw (MN_vdbpsadbw + 3)
-#define MN_vdbpsadbw 0x4071
+#define MN_vdbpsadbw 0x41e2
 #define MN_mpsadbw (MN_vmpsadbw + 1)
-#define MN_vmpsadbw 0x407b
-#define MN_vpsadbw 0x4084
-#define MN_vphaddbw 0x408c
+#define MN_vmpsadbw 0x41ec
+#define MN_vpsadbw 0x41f5
+#define MN_vphaddbw 0x41fd
 #define MN_punpckhbw (MN_vpunpckhbw + 1)
-#define MN_vpunpckhbw 0x4095
-#define MN_kunpckbw 0x40a0
+#define MN_vpunpckhbw 0x4206
+#define MN_kunpckbw 0x4211
 #define MN_punpcklbw (MN_vpunpcklbw + 1)
-#define MN_vpunpcklbw 0x40a9
-#define MN_vphaddubw 0x40b4
+#define MN_vpunpcklbw 0x421a
+#define MN_vphaddubw 0x4225
 #define MN_phsubw (MN_vphsubw + 1)
-#define MN_vphsubw 0x40be
+#define MN_vphsubw 0x422f
 #define MN_psubw (MN_vpsubw + 1)
-#define MN_vpsubw 0x40c6
+#define MN_vpsubw 0x4237
 #define MN_pmovsxbw (MN_vpmovsxbw + 1)
-#define MN_vpmovsxbw 0x40cd
+#define MN_vpmovsxbw 0x423e
 #define MN_pmovzxbw (MN_vpmovzxbw + 1)
-#define MN_vpmovzxbw 0x40d7
-#define MN_fldcw 0x40e1
-#define MN_fstcw 0x40e7
-#define MN_fnstcw 0x40ed
+#define MN_vpmovzxbw 0x4248
+#define MN_fldcw 0x4252
+#define MN_fstcw 0x4258
+#define MN_fnstcw 0x425e
 #define MN_phaddw (MN_vphaddw + 1)
-#define MN_vphaddw 0x40f4
-#define MN_kaddw 0x40fc
+#define MN_vphaddw 0x4265
+#define MN_kaddw 0x426d
 #define MN_paddw (MN_vpaddw + 1)
-#define MN_vpaddw 0x4102
-#define MN_vpshldw 0x4109
-#define MN_kandw 0x4111
-#define MN_vpexpandw 0x4117
+#define MN_vpaddw 0x4273
+#define MN_vpshldw 0x427a
+#define MN_kandw 0x4282
+#define MN_vpexpandw 0x4288
 #define MN_pblendw (MN_vpblendw + 1)
-#define MN_vpblendw 0x4121
-#define MN_vpshrdw 0x412a
+#define MN_vpblendw 0x4292
+#define MN_vpshrdw 0x429b
 #define MN_packssdw (MN_vpackssdw + 1)
-#define MN_vpackssdw 0x4132
+#define MN_vpackssdw 0x42a3
 #define MN_packusdw (MN_vpackusdw + 1)
-#define MN_vpackusdw 0x413c
-#define MN_vpmovusdw 0x4146
-#define MN_vpmovsdw 0x4150
-#define MN_vpmovdw 0x4159
-#define MN_vpcomgew 0x4161
-#define MN_vpcomlew 0x416a
-#define MN_vpcmpnlew 0x4173
-#define MN_vpcmplew 0x417d
-#define MN_vpcomfalsew 0x4186
-#define MN_vpcomtruew 0x4192
-#define MN_pi2fw 0x419d
-#define MN_pshufw 0x41a3
+#define MN_vpackusdw 0x42ad
+#define MN_vpmovusdw 0x42b7
+#define MN_vpmovsdw 0x42c1
+#define MN_vpmovdw 0x42ca
+#define MN_vpcomgew 0x42d2
+#define MN_vpcomlew 0x42db
+#define MN_vpcmpnlew 0x42e4
+#define MN_vpcmplew 0x42ee
+#define MN_vpcomfalsew 0x42f7
+#define MN_vpcomtruew 0x4303
+#define MN_pi2fw 0x430e
+#define MN_pshufw 0x4314
 #define MN_pavgw (MN_vpavgw + 1)
-#define MN_vpavgw 0x41aa
-#define MN_prefetchw 0x41b1
+#define MN_vpavgw 0x431b
+#define MN_prefetchw 0x4322
 #define MN_pshufhw (MN_vpshufhw + 1)
-#define MN_vpshufhw 0x41bb
+#define MN_vpshufhw 0x432c
 #define MN_pmulhw (MN_vpmulhw + 1)
-#define MN_vpmulhw 0x41c4
-#define MN_pf2iw 0x41cc
+#define MN_vpmulhw 0x4335
+#define MN_pf2iw 0x433d
 #define MN_pshuflw (MN_vpshuflw + 1)
-#define MN_vpshuflw 0x41d2
-#define MN_vpshlw 0x41db
+#define MN_vpshuflw 0x4343
+#define MN_vpshlw 0x434c
 #define MN_psllw (MN_vpsllw + 1)
-#define MN_vpsllw 0x41e2
+#define MN_vpsllw 0x4353
 #define MN_pmullw (MN_vpmullw + 1)
-#define MN_vpmullw 0x41e9
+#define MN_vpmullw 0x435a
 #define MN_psrlw (MN_vpsrlw + 1)
-#define MN_vpsrlw 0x41f1
-#define MN_kshiftlw 0x41f8
-#define MN_vpblendmw 0x4201
-#define MN_vptestnmw 0x420b
-#define MN_vpcomw 0x4215
-#define MN_vpermw 0x421c
-#define MN_vptestmw 0x4223
-#define MN_kandnw 0x422c
+#define MN_vpsrlw 0x4362
+#define MN_kshiftlw 0x4369
+#define MN_vpblendmw 0x4372
+#define MN_vptestnmw 0x437c
+#define MN_vpcomw 0x4386
+#define MN_vpermw 0x438d
+#define MN_vptestmw 0x4394
+#define MN_kandnw 0x439d
 #define MN_psignw (MN_vpsignw + 1)
-#define MN_vpsignw 0x4233
-#define MN_vpcmpw 0x423b
-#define MN_vpcomeqw 0x4242
-#define MN_vpcomneqw 0x424b
-#define MN_vpcmpneqw 0x4255
+#define MN_vpsignw 0x43a4
+#define MN_vpcmpw 0x43ac
+#define MN_vpcomeqw 0x43b3
+#define MN_vpcomneqw 0x43bc
+#define MN_vpcmpneqw 0x43c6
 #define MN_pcmpeqw (MN_vpcmpeqw + 1)
-#define MN_vpcmpeqw 0x425f
-#define MN_vpmovusqw 0x4268
-#define MN_vpmovsqw 0x4272
-#define MN_vpmovqw 0x427b
-#define MN_verw 0x4283
-#define MN_pmulhrw 0x4288
-#define MN_korw 0x4290
-#define MN_kxnorw 0x4295
-#define MN_kxorw 0x429c
+#define MN_vpcmpeqw 0x43d0
+#define MN_vpmovusqw 0x43d9
+#define MN_vpmovsqw 0x43e3
+#define MN_vpmovqw 0x43ec
+#define MN_verw 0x43f4
+#define MN_pmulhrw 0x43f9
+#define MN_korw 0x4401
+#define MN_kxnorw 0x4406
+#define MN_kxorw 0x440d
 #define MN_pinsrw (MN_vpinsrw + 1)
-#define MN_vpinsrw 0x42a2
-#define MN_kshiftrw 0x42aa
+#define MN_vpinsrw 0x4413
+#define MN_kshiftrw 0x441b
 #define MN_pextrw (MN_vpextrw + 1)
-#define MN_vpextrw 0x42b3
+#define MN_vpextrw 0x4424
 #define MN_pabsw (MN_vpabsw + 1)
-#define MN_vpabsw 0x42bb
+#define MN_vpabsw 0x442c
 #define MN_pmaddubsw (MN_vpmaddubsw + 1)
-#define MN_vpmaddubsw 0x42c2
+#define MN_vpmaddubsw 0x4433
 #define MN_phsubsw (MN_vphsubsw + 1)
-#define MN_vphsubsw 0x42cd
+#define MN_vphsubsw 0x443e
 #define MN_psubsw (MN_vpsubsw + 1)
-#define MN_vpsubsw 0x42d6
+#define MN_vpsubsw 0x4447
 #define MN_phaddsw (MN_vphaddsw + 1)
-#define MN_vphaddsw 0x42de
+#define MN_vphaddsw 0x444f
 #define MN_paddsw (MN_vpaddsw + 1)
-#define MN_vpaddsw 0x42e7
-#define MN_lmsw 0x42ef
-#define MN_smsw 0x42f4
+#define MN_vpaddsw 0x4458
+#define MN_lmsw 0x4460
+#define MN_smsw 0x4465
 #define MN_pminsw (MN_vpminsw + 1)
-#define MN_vpminsw 0x42f9
+#define MN_vpminsw 0x446a
 #define MN_pmulhrsw (MN_vpmulhrsw + 1)
-#define MN_vpmulhrsw 0x4301
-#define MN_vpcompressw 0x430b
-#define MN_fstsw 0x4317
-#define MN_fnstsw 0x431d
+#define MN_vpmulhrsw 0x4472
+#define MN_vpcompressw 0x447c
+#define MN_fstsw 0x4488
+#define MN_fnstsw 0x448e
 #define MN_psubusw (MN_vpsubusw + 1)
-#define MN_vpsubusw 0x4324
+#define MN_vpsubusw 0x4495
 #define MN_paddusw (MN_vpaddusw + 1)
-#define MN_vpaddusw 0x432d
-#define MN_movsw 0x4336
+#define MN_vpaddusw 0x449e
+#define MN_movsw 0x44a7
 #define MN_pmaxsw (MN_vpmaxsw + 1)
-#define MN_vpmaxsw 0x433c
-#define MN_cbtw 0x4344
-#define MN_vpcomgtw 0x4349
+#define MN_vpmaxsw 0x44ad
+#define MN_cbtw 0x44b5
+#define MN_vpcomgtw 0x44ba
 #define MN_pcmpgtw (MN_vpcmpgtw + 1)
-#define MN_vpcmpgtw 0x4352
-#define MN_vpcomltw 0x435b
-#define MN_vpcmpnltw 0x4364
-#define MN_vpcmpltw 0x436e
-#define MN_vpopcntw 0x4377
-#define MN_knotw 0x4380
-#define MN_vprotw 0x4386
-#define MN_vpbroadcastw 0x438d
-#define MN_ktestw 0x439a
-#define MN_kortestw 0x43a1
-#define MN_vcvttph2uw 0x43aa
-#define MN_vcvtph2uw 0x43b5
-#define MN_vpcomgeuw 0x43bf
-#define MN_vpcomleuw 0x43c9
-#define MN_vpcmpnleuw 0x43d3
-#define MN_vpcmpleuw 0x43de
-#define MN_vpcomfalseuw 0x43e8
-#define MN_vpcomtrueuw 0x43f5
+#define MN_vpcmpgtw 0x44c3
+#define MN_vpcomltw 0x44cc
+#define MN_vpcmpnltw 0x44d5
+#define MN_vpcmpltw 0x44df
+#define MN_vpopcntw 0x44e8
+#define MN_knotw 0x44f1
+#define MN_vprotw 0x44f7
+#define MN_vpbroadcastw 0x44fe
+#define MN_ktestw 0x450b
+#define MN_kortestw 0x4512
+#define MN_vcvttph2uw 0x451b
+#define MN_vcvtph2uw 0x4526
+#define MN_vpcomgeuw 0x4530
+#define MN_vpcomleuw 0x453a
+#define MN_vpcmpnleuw 0x4544
+#define MN_vpcmpleuw 0x454f
+#define MN_vpcomfalseuw 0x4559
+#define MN_vpcomtrueuw 0x4566
 #define MN_pmulhuw (MN_vpmulhuw + 1)
-#define MN_vpmulhuw 0x4401
-#define MN_vpcomuw 0x440a
+#define MN_vpmulhuw 0x4572
+#define MN_vpcomuw 0x457b
 #define MN_pminuw (MN_vpminuw + 1)
-#define MN_vpminuw 0x4412
-#define MN_vpcmpuw 0x441a
-#define MN_vpcomequw 0x4422
-#define MN_vpcomnequw 0x442c
-#define MN_vpcmpnequw 0x4437
-#define MN_vpcmpequw 0x4442
+#define MN_vpminuw 0x4583
+#define MN_vpcmpuw 0x458b
+#define MN_vpcomequw 0x4593
+#define MN_vpcomnequw 0x459d
+#define MN_vpcmpnequw 0x45a8
+#define MN_vpcmpequw 0x45b3
 #define MN_phminposuw (MN_vphminposuw + 1)
-#define MN_vphminposuw 0x444c
-#define MN_vpcomgtuw 0x4458
-#define MN_vpcomltuw 0x4462
-#define MN_vpcmpnltuw 0x446c
-#define MN_vpcmpltuw 0x4477
+#define MN_vphminposuw 0x45bd
+#define MN_vpcomgtuw 0x45c9
+#define MN_vpcomltuw 0x45d3
+#define MN_vpcmpnltuw 0x45dd
+#define MN_vpcmpltuw 0x45e8
 #define MN_pmaxuw (MN_vpmaxuw + 1)
-#define MN_vpmaxuw 0x4481
-#define MN_vpsravw 0x4489
-#define MN_vpshldvw 0x4491
-#define MN_vpshrdvw 0x449a
-#define MN_vpsllvw 0x44a3
-#define MN_vpsrlvw 0x44ab
-#define MN_kmovw 0x44b3
-#define MN_vmovw 0x44b9
-#define MN_vpmacsww 0x44bf
-#define MN_vpmacssww 0x44c8
-#define MN_movzw 0x44d2
-#define MN_rex_x 0x44d8
-#define MN_fyl2x 0x44de
-#define MN_rex64x 0x44e4
-#define MN_vcvtneps2bf16x 0x44eb
-#define MN_pfmax 0x44fa
-#define MN_adcx 0x4500
-#define MN_bndldx 0x4505
-#define MN_vfpclasspdx 0x450c
-#define MN_fclex 0x4518
-#define MN_fnclex 0x451e
-#define MN_rex 0x4525
-#define MN_vcvtpd2phx 0x4529
-#define MN_vcvtdq2phx 0x4534
-#define MN_vcvtudq2phx 0x453f
-#define MN_vcvtqq2phx 0x454b
-#define MN_vcvtuqq2phx 0x4556
-#define MN_vcvtps2phx 0x4562
-#define MN_vfpclassphx 0x456d
-#define MN_shlx 0x4579
-#define MN_mulx 0x457e
-#define MN_adox 0x4583
-#define MN_vcvttpd2dqx 0x4588
-#define MN_vcvtpd2dqx 0x4594
-#define MN_vcvttpd2udqx 0x459f
-#define MN_vcvtpd2udqx 0x45ac
-#define MN_rex_rx 0x45b8
-#define MN_sarx 0x45bf
-#define MN_shrx 0x45c4
-#define MN_rorx 0x45c9
-#define MN_monitorx 0x45ce
-#define MN_rex_wrx 0x45d7
-#define MN_vcvtpd2psx 0x45df
-#define MN_vcvtph2psx 0x45ea
-#define MN_vcvtqq2psx 0x45f5
-#define MN_vcvtuqq2psx 0x4600
-#define MN_vfpclasspsx 0x460c
-#define MN_movsx 0x4618
-#define MN_mwaitx 0x461e
-#define MN_bndstx 0x4625
-#define MN_rex_wx 0x462c
-#define MN_rexx 0x4633
-#define MN_vcvtps2phxx 0x4638
-#define MN_movzx 0x4644
-#define MN_rex64y 0x464a
-#define MN_vcvtneps2bf16y 0x4651
-#define MN_vfpclasspdy 0x4660
-#define MN_loadiwkey 0x466c
-#define MN_vcvtpd2phy 0x4676
-#define MN_vcvtdq2phy 0x4681
-#define MN_vcvtudq2phy 0x468c
-#define MN_vcvtqq2phy 0x4698
-#define MN_vcvtuqq2phy 0x46a3
-#define MN_vfpclassphy 0x46af
-#define MN_vcvttpd2dqy 0x46bb
-#define MN_vcvtpd2dqy 0x46c7
-#define MN_vcvttpd2udqy 0x46d2
-#define MN_vcvtpd2udqy 0x46df
-#define MN_rmpquery 0x46eb
-#define MN_clrssbsy 0x46f4
-#define MN_setssbsy 0x46fd
-#define MN_vcvtpd2psy 0x4706
-#define MN_vcvtqq2psy 0x4711
-#define MN_vcvtuqq2psy 0x471c
-#define MN_vfpclasspsy 0x4728
-#define MN_rex64xy 0x4734
-#define MN_rexy 0x473c
-#define MN_vcvtps2phxy 0x4741
-#define MN_rexxy 0x474d
-#define MN_rex64z 0x4753
-#define MN_fldz 0x475a
-#define MN_vfpclasspdz 0x475f
-#define MN_vcvtpd2phz 0x476b
-#define MN_vcvtqq2phz 0x4776
-#define MN_vcvtuqq2phz 0x4781
-#define MN_vfpclassphz 0x478d
-#define MN_jz 0x4799
-#define MN_jnz 0x479c
-#define MN_repnz 0x47a0
-#define MN_loopnz 0x47a6
-#define MN_setnz 0x47ad
-#define MN_setzunz 0x47b3
-#define MN_cmovnz 0x47bb
-#define MN_repz 0x47c2
-#define MN_loopz 0x47c7
-#define MN_vfpclasspsz 0x47cd
-#define MN_setz 0x47d9
-#define MN_setzuz 0x47de
-#define MN_cmovz 0x47e5
-#define MN_rex64xz 0x47eb
-#define MN_jecxz 0x47f3
-#define MN_jcxz 0x47f9
-#define MN_jrcxz 0x47fe
-#define MN_rexz 0x4804
-#define MN_rexxz 0x4809
-#define MN_rex64yz 0x480f
-#define MN_rex64xyz 0x4817
-#define MN_rexyz 0x4820
-#define MN_rexxyz 0x4826
-#define MN__disp32_ 0x482d
-#define MN__rex2_ 0x4836
-#define MN__vex2_ 0x483d
-#define MN__vex3_ 0x4844
-#define MN__disp16_ 0x484b
-#define MN__disp8_ 0x4854
-#define MN__load_ 0x485c
-#define MN__store_ 0x4863
-#define MN__nooptimize_ 0x486b
-#define MN__nf_ 0x4878
-#define MN__rex_ 0x487d
-#define MN__evex_ 0x4883
-#define MN__vex_ 0x488a
-#define MN__insn 0x4890
+#define MN_vpmaxuw 0x45f2
+#define MN_vpsravw 0x45fa
+#define MN_vpshldvw 0x4602
+#define MN_vpshrdvw 0x460b
+#define MN_vpsllvw 0x4614
+#define MN_vpsrlvw 0x461c
+#define MN_kmovw 0x4624
+#define MN_vmovw 0x462a
+#define MN_vpmacsww 0x4630
+#define MN_vpmacssww 0x4639
+#define MN_movzw 0x4643
+#define MN_rex_x 0x4649
+#define MN_fyl2x 0x464f
+#define MN_rex64x 0x4655
+#define MN_vcvtneps2bf16x 0x465c
+#define MN_pfmax 0x466b
+#define MN_adcx 0x4671
+#define MN_bndldx 0x4676
+#define MN_vfpclasspdx 0x467d
+#define MN_fclex 0x4689
+#define MN_fnclex 0x468f
+#define MN_rex 0x4696
+#define MN_vcvtpd2phx 0x469a
+#define MN_vcvtdq2phx 0x46a5
+#define MN_vcvtudq2phx 0x46b0
+#define MN_vcvtqq2phx 0x46bc
+#define MN_vcvtuqq2phx 0x46c7
+#define MN_vcvtps2phx 0x46d3
+#define MN_vfpclassphx 0x46de
+#define MN_shlx 0x46ea
+#define MN_mulx 0x46ef
+#define MN_adox 0x46f4
+#define MN_vcvttpd2dqx 0x46f9
+#define MN_vcvtpd2dqx 0x4705
+#define MN_vcvttpd2udqx 0x4710
+#define MN_vcvtpd2udqx 0x471d
+#define MN_rex_rx 0x4729
+#define MN_sarx 0x4730
+#define MN_shrx 0x4735
+#define MN_rorx 0x473a
+#define MN_monitorx 0x473f
+#define MN_rex_wrx 0x4748
+#define MN_vcvtpd2psx 0x4750
+#define MN_vcvtph2psx 0x475b
+#define MN_vcvtqq2psx 0x4766
+#define MN_vcvtuqq2psx 0x4771
+#define MN_vfpclasspsx 0x477d
+#define MN_movsx 0x4789
+#define MN_mwaitx 0x478f
+#define MN_bndstx 0x4796
+#define MN_rex_wx 0x479d
+#define MN_rexx 0x47a4
+#define MN_vcvtps2phxx 0x47a9
+#define MN_movzx 0x47b5
+#define MN_rex64y 0x47bb
+#define MN_vcvtneps2bf16y 0x47c2
+#define MN_vfpclasspdy 0x47d1
+#define MN_loadiwkey 0x47dd
+#define MN_vcvtpd2phy 0x47e7
+#define MN_vcvtdq2phy 0x47f2
+#define MN_vcvtudq2phy 0x47fd
+#define MN_vcvtqq2phy 0x4809
+#define MN_vcvtuqq2phy 0x4814
+#define MN_vfpclassphy 0x4820
+#define MN_vcvttpd2dqy 0x482c
+#define MN_vcvtpd2dqy 0x4838
+#define MN_vcvttpd2udqy 0x4843
+#define MN_vcvtpd2udqy 0x4850
+#define MN_rmpquery 0x485c
+#define MN_clrssbsy 0x4865
+#define MN_setssbsy 0x486e
+#define MN_vcvtpd2psy 0x4877
+#define MN_vcvtqq2psy 0x4882
+#define MN_vcvtuqq2psy 0x488d
+#define MN_vfpclasspsy 0x4899
+#define MN_rex64xy 0x48a5
+#define MN_rexy 0x48ad
+#define MN_vcvtps2phxy 0x48b2
+#define MN_rexxy 0x48be
+#define MN_rex64z 0x48c4
+#define MN_fldz 0x48cb
+#define MN_vfpclasspdz 0x48d0
+#define MN_vcvtpd2phz 0x48dc
+#define MN_vcvtqq2phz 0x48e7
+#define MN_vcvtuqq2phz 0x48f2
+#define MN_vfpclassphz 0x48fe
+#define MN_jz 0x490a
+#define MN_jnz 0x490d
+#define MN_repnz 0x4911
+#define MN_ccmpnz 0x4917
+#define MN_loopnz 0x491e
+#define MN_setnz 0x4925
+#define MN_ctestnz 0x492b
+#define MN_setzunz 0x4933
+#define MN_cmovnz 0x493b
+#define MN_repz 0x4942
+#define MN_ccmpz 0x4947
+#define MN_loopz 0x494d
+#define MN_vfpclasspsz 0x4953
+#define MN_setz 0x495f
+#define MN_ctestz 0x4964
+#define MN_setzuz 0x496b
+#define MN_cmovz 0x4972
+#define MN_rex64xz 0x4978
+#define MN_jecxz 0x4980
+#define MN_jcxz 0x4986
+#define MN_jrcxz 0x498b
+#define MN_rexz 0x4991
+#define MN_rexxz 0x4996
+#define MN_rex64yz 0x499c
+#define MN_rex64xyz 0x49a4
+#define MN_rexyz 0x49ad
+#define MN_rexxyz 0x49b3
+#define MN__disp32_ 0x49ba
+#define MN__rex2_ 0x49c3
+#define MN__vex2_ 0x49ca
+#define MN__vex3_ 0x49d1
+#define MN__disp16_ 0x49d8
+#define MN__disp8_ 0x49e1
+#define MN__load_ 0x49e9
+#define MN__store_ 0x49f0
+#define MN__nooptimize_ 0x49f8
+#define MN__nf_ 0x4a05
+#define MN__rex_ 0x4a0a
+#define MN__evex_ 0x4a10
+#define MN__vex_ 0x4a17
+#define MN__insn 0x4a1d

diff --git a/opcodes/i386-opc.h b/opcodes/i386-opc.h
index 38b8e64e75558b37f9af1d8953f634045e726e63..7400428eb24f1600d6180a3e052b7b416ea6d528 100644 (file)
--- a/opcodes/i386-opc.h
+++ b/opcodes/i386-opc.h
@@ -581,6 +581,8 @@ enum
 #define IMPLICIT_STACK_OP 9
   /* Instruction zeroes upper part of register.  */
 #define ZERO_UPPER 10
+  /* Instruction support SCC.  */
+#define SCC 11
   OperandConstraint,
   /* instruction ignores operand size prefix and in Intel mode ignores
      mnemonic size suffix check.  */

diff --git a/opcodes/i386-opc.tbl b/opcodes/i386-opc.tbl
index c91068001558aed031ec176dbf4a58b5f2594040..e365f06314276cd7099d3296fab1dc79c55a9cb4 100644 (file)
--- a/opcodes/i386-opc.tbl
+++ b/opcodes/i386-opc.tbl
@@ -86,6 +86,7 @@
 #define Ugh               OperandConstraint=UGH
 #define ImplicitStackOp   OperandConstraint=IMPLICIT_STACK_OP
 #define ZU                OperandConstraint=ZERO_UPPER
+#define Scc               OperandConstraint=SCC
 
 #define ATTSyntax         Dialect=ATT_SYNTAX
 #define ATTMnemonic       Dialect=ATT_MNEMONIC
@@ -341,10 +342,28 @@ cmp, 0x38, 0, D|W|CheckOperandSize|Modrm|No_sSuf, { Reg8|Reg16|Reg32|Reg64, Reg8
 cmp, 0x83/7, 0, Modrm|No_bSuf|No_sSuf, { Imm8S, Reg16|Reg32|Reg64|Unspecified|BaseIndex }
 cmp, 0x3c, 0, W|No_sSuf, { Imm8|Imm16|Imm32|Imm32S, Acc|Byte|Word|Dword|Qword }
 cmp, 0x80/7, 0, W|Modrm|No_sSuf, { Imm8|Imm16|Imm32|Imm32S, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+cmp, 0x380a, APX_F, D|W|CheckOperandSize|EVexMap4|Scc|Modrm|No_sSuf, { Reg8|Reg16|Reg32|Reg64, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+cmp, 0x830a/7, APX_F, Modrm|EVexMap4|Scc|No_bSuf|No_sSuf, { Imm8S, Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+cmp, 0x800a/7, APX_F, W|Modrm|EVexMap4|Scc|No_sSuf, { Imm8|Imm16|Imm32|Imm32S, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+
+<scc:opc, o:0, no:1, b:2, c:2, nae:2, nb:3, nc:3, ae:3, e:4, z:4, ne:5, nz:5, be:6, na:6, nbe:7, a:7, +
+         s:8, ns:9, t:a, f:b, l:c, nge:c, nl:d, ge:d, le:e, ng:e, nle:f, g:f>
+
+ccmp<scc>, 0x380<scc:opc>, APX_F, D|W|CheckOperandSize|Modrm|EVexMap4|Scc|No_sSuf, { Reg8|Reg16|Reg32|Reg64, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+ccmp<scc>, 0x830<scc:opc>/7, APX_F, Modrm|EVexMap4|Scc|No_bSuf|No_sSuf, { Imm8S, Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+ccmp<scc>, 0x800<scc:opc>/7, APX_F, W|Modrm|EVexMap4|Scc|No_sSuf, { Imm8|Imm16|Imm32|Imm32S, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
 
 test, 0x84, 0, D|W|C|CheckOperandSize|Modrm|No_sSuf, { Reg8|Reg16|Reg32|Reg64, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
 test, 0xa8, 0, W|No_sSuf|Optimize, { Imm8|Imm16|Imm32|Imm32S, Acc|Byte|Word|Dword|Qword }
 test, 0xf6/0, 0, W|Modrm|No_sSuf|Optimize, { Imm8|Imm16|Imm32|Imm32S, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+test, 0x840a, 0, D|W|C|CheckOperandSize|Modrm|EVexMap4|Scc|No_sSuf, { Reg8|Reg16|Reg32|Reg64, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+test, 0xf60a/0, 0, W|Modrm|EVexMap4|Scc|No_sSuf, { Imm8|Imm16|Imm32|Imm32S, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+
+ctest<scc>, 0x840<scc:opc>, APX_F, D|W|C|CheckOperandSize|Modrm|EVexMap4|Scc|No_sSuf, { Reg8|Reg16|Reg32|Reg64, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+ctest<scc>, 0xf60<scc:opc>/0, APX_F, W|Modrm|EVexMap4|Scc|No_sSuf, { Imm8|Imm16|Imm32|Imm32S, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+ctest<scc>, 0xf60<scc:opc>/1, APX_F, W|Modrm|EVexMap4|Scc|No_sSuf, { Imm8|Imm16|Imm32|Imm32S, Reg8|Reg16|Reg32|Reg64|Unspecified|BaseIndex }
+
+<scc>
 
 <incdec:opc, inc:0, dec:1>
 

diff --git a/opcodes/i386-tbl.h b/opcodes/i386-tbl.h
index 0e84836d8dac2c8e198c349641ec48cdd490ba26..60a191519f3570c158dba0ae0631bb46484bac76 100644 (file)
--- a/opcodes/i386-tbl.h
+++ b/opcodes/i386-tbl.h
@@ -1590,6 +1590,876 @@ static const insn_template i386_optab[] =
          0, 0, 0, 0, 0, 0 } },
       { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0,
          0, 0, 0, 0, 1, 0 } } } },
+  { MN_cmp, 0x380a, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_cmp, 0x830a, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_cmp, 0x800a, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpo, 0x3800, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpo, 0x8300, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpo, 0x8000, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpno, 0x3801, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpno, 0x8301, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpno, 0x8001, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpb, 0x3802, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpb, 0x8302, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpb, 0x8002, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpc, 0x3802, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpc, 0x8302, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpc, 0x8002, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnae, 0x3802, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnae, 0x8302, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnae, 0x8002, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnb, 0x3803, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnb, 0x8303, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnb, 0x8003, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnc, 0x3803, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnc, 0x8303, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnc, 0x8003, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpae, 0x3803, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpae, 0x8303, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpae, 0x8003, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpe, 0x3804, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpe, 0x8304, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpe, 0x8004, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpz, 0x3804, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpz, 0x8304, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpz, 0x8004, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpne, 0x3805, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpne, 0x8305, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpne, 0x8005, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnz, 0x3805, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnz, 0x8305, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnz, 0x8005, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpbe, 0x3806, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpbe, 0x8306, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpbe, 0x8006, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpna, 0x3806, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpna, 0x8306, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpna, 0x8006, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnbe, 0x3807, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnbe, 0x8307, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnbe, 0x8007, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpa, 0x3807, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpa, 0x8307, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpa, 0x8007, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmps, 0x3808, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmps, 0x8308, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmps, 0x8008, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpns, 0x3809, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpns, 0x8309, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpns, 0x8009, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpt, 0x380a, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpt, 0x830a, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpt, 0x800a, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpf, 0x380b, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpf, 0x830b, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpf, 0x800b, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpl, 0x380c, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpl, 0x830c, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpl, 0x800c, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnge, 0x380c, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnge, 0x830c, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnge, 0x800c, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnl, 0x380d, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnl, 0x830d, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnl, 0x800d, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpge, 0x380d, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpge, 0x830d, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpge, 0x800d, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmple, 0x380e, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmple, 0x830e, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmple, 0x800e, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpng, 0x380e, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpng, 0x830e, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpng, 0x800e, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnle, 0x380f, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnle, 0x830f, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpnle, 0x800f, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpg, 0x380f, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpg, 0x830f, 2, SPACE_EVEXMAP4, 7,
+    { 0, 0, 0, 1, 0, 0, 0, 0, 11, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ccmpg, 0x800f, 2, SPACE_EVEXMAP4, 7,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
   { MN_test, 0x84, 2, SPACE_BASE, None,
     { 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
@@ -1598,27 +2468,887 @@ static const insn_template i386_optab[] =
     { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
     { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
          0, 0, 0, 0, 0, 0 } },
-      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_test, 0xa8, 2, SPACE_BASE, None,
+    { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } } } },
+  { MN_test, 0xf6, 2, SPACE_BASE, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_test, 0x840a, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_test, 0xf60a, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctesto, 0x8400, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctesto, 0xf600, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctesto, 0xf600, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestno, 0x8401, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestno, 0xf601, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestno, 0xf601, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestb, 0x8402, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestb, 0xf602, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestb, 0xf602, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestc, 0x8402, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestc, 0xf602, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestc, 0xf602, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnae, 0x8402, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnae, 0xf602, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnae, 0xf602, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnb, 0x8403, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnb, 0xf603, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnb, 0xf603, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnc, 0x8403, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
          0, 0, 0, 0, 1, 0 } } } },
-  { MN_test, 0xa8, 2, SPACE_BASE, None,
-    { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,
+  { MN_ctestnc, 0xf603, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
     { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnc, 0xf603, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
     { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
     { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          0, 0, 0, 0, 0, 0 } },
-      { { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
-         0, 0, 0, 0, 0, 0 } } } },
-  { MN_test, 0xf6, 2, SPACE_BASE, 0,
-    { 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
-      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestae, 0x8403, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
       0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
     { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestae, 0xf603, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
     { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
     { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          0, 0, 0, 0, 0, 0 } },
-      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestae, 0xf603, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_cteste, 0x8404, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_cteste, 0xf604, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_cteste, 0xf604, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestz, 0x8404, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestz, 0xf604, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestz, 0xf604, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestne, 0x8405, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestne, 0xf605, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestne, 0xf605, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnz, 0x8405, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnz, 0xf605, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnz, 0xf605, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestbe, 0x8406, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestbe, 0xf606, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestbe, 0xf606, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestna, 0x8406, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestna, 0xf606, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestna, 0xf606, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnbe, 0x8407, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnbe, 0xf607, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnbe, 0xf607, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctesta, 0x8407, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctesta, 0xf607, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctesta, 0xf607, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctests, 0x8408, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctests, 0xf608, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctests, 0xf608, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestns, 0x8409, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestns, 0xf609, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestns, 0xf609, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestt, 0x840a, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestt, 0xf60a, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestt, 0xf60a, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestf, 0x840b, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestf, 0xf60b, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestf, 0xf60b, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestl, 0x840c, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestl, 0xf60c, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestl, 0xf60c, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnge, 0x840c, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnge, 0xf60c, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnge, 0xf60c, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnl, 0x840d, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnl, 0xf60d, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnl, 0xf60d, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestge, 0x840d, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestge, 0xf60d, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestge, 0xf60d, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestle, 0x840e, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestle, 0xf60e, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestle, 0xf60e, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestng, 0x840e, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestng, 0xf60e, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestng, 0xf60e, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnle, 0x840f, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnle, 0xf60f, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestnle, 0xf60f, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestg, 0x840f, 2, SPACE_EVEXMAP4, None,
+    { 1, 1, 0, 1, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestg, 0xf60f, 2, SPACE_EVEXMAP4, 0,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
+         0, 0, 0, 0, 1, 0 } } } },
+  { MN_ctestg, 0xf60f, 2, SPACE_EVEXMAP4, 1,
+    { 0, 1, 0, 1, 0, 0, 0, 0, 11, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0 },
+    { { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 } },
+    { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+    { { { 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 0, 0 } },
+      { { 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0,
          0, 0, 0, 0, 1, 0 } } } },
   { MN_inc, 0x40 | (0 <<3), 1, SPACE_BASE, None,
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0,
@@ -43801,298 +45531,305 @@ static const i386_op_off_t i386_op_sets[] =
     63,   65,   67,   69,   70,   71,   72,   73,
     74,   76,   78,   80,   82,   83,   84,   85,
     95,  105,  115,  125,  135,  145,  155,  157,
-   161,  164,  168,  172,  175,  178,  179,  180,
-   181,  182,  184,  186,  187,  188,  189,  190,
-   191,  192,  193,  194,  195,  196,  197,  198,
-   200,  213,  217,  221,  225,  235,  245,  255,
-   265,  275,  285,  295,  305,  312,  319,  328,
-   331,  339,  342,  348,  350,  352,  354,  356,
-   357,  358,  359,  360,  361,  362,  363,  364,
-   365,  366,  367,  368,  369,  370,  371,  372,
-   373,  374,  375,  376,  377,  378,  379,  380,
-   381,  382,  383,  384,  385,  386,  387,  388,
-   389,  391,  393,  395,  397,  399,  402,  405,
-   408,  411,  414,  417,  420,  423,  426,  429,
-   432,  435,  438,  441,  444,  447,  450,  453,
-   456,  459,  462,  465,  468,  471,  474,  477,
-   480,  483,  486,  489,  490,  491,  492,  493,
-   494,  495,  496,  497,  498,  499,  500,  501,
-   502,  503,  504,  505,  506,  507,  508,  509,
-   510,  511,  512,  513,  514,  515,  516,  517,
-   518,  519,  521,  523,  525,  527,  530,  533,
-   535,  537,  540,  543,  546,  549,  551,  552,
-   553,  555,  557,  559,  561,  562,  563,  564,
-   565,  566,  567,  568,  569,  571,  573,  575,
-   577,  579,  581,  582,  584,  586,  588,  590,
-   592,  594,  596,  598,  600,  604,  606,  607,
-   608,  609,  612,  613,  617,  619,  620,  621,
-   622,  624,  628,  629,  633,  634,  635,  637,
-   639,  640,  641,  642,  643,  644,  645,  646,
-   647,  648,  649,  653,  654,  657,  661,  662,
-   668,  672,  673,  679,  683,  684,  687,  691,
-   692,  698,  702,  703,  709,  710,  711,  712,
-   713,  714,  715,  716,  717,  718,  719,  720,
-   721,  722,  723,  724,  725,  726,  727,  728,
-   729,  730,  731,  732,  735,  738,  739,  740,
-   741,  742,  743,  744,  745,  746,  747,  748,
-   749,  750,  751,  752,  753,  754,  755,  756,
-   757,  758,  759,  760,  761,  762,  763,  764,
-   765,  766,  767,  768,  769,  770,  771,  772,
-   773,  774,  775,  776,  777,  778,  779,  780,
-   781,  782,  783,  784,  785,  786,  787,  788,
-   789,  790,  791,  792,  793,  794,  795,  796,
-   797,  798,  799,  800,  801,  802,  803,  804,
-   805,  806,  807,  808,  809,  810,  811,  812,
-   813,  814,  815,  816,  817,  818,  819,  820,
-   821,  822,  823,  824,  825,  826,  827,  828,
-   829,  830,  831,  832,  833,  834,  836,  838,
-   839,  840,  841,  842,  843,  844,  845,  846,
-   847,  848,  850,  852,  854,  856,  858,  860,
-   862,  864,  866,  868,  870,  872,  874,  876,
-   878,  880,  882,  884,  886,  888,  890,  892,
-   894,  896,  898,  900,  902,  904,  906,  908,
-   909,  910,  911,  912,  913,  914,  915,  916,
-   917,  918,  919,  920,  923,  926,  929,  932,
-   935,  938,  939,  940,  941,  942,  943,  944,
-   950,  960,  964,  968,  972,  976,  980,  983,
-   987,  991,  995,  999, 1003, 1006, 1009, 1012,
-  1015, 1018, 1021, 1024, 1027, 1031, 1035, 1039,
-  1042, 1050, 1056, 1064, 1072, 1078, 1086, 1092,
-  1100, 1104, 1108, 1111, 1115, 1119, 1123, 1127,
-  1131, 1135, 1139, 1142, 1146, 1150, 1153, 1156,
-  1158, 1160, 1163, 1166, 1168, 1170, 1172, 1174,
-  1176, 1178, 1180, 1182, 1184, 1186, 1188, 1190,
-  1192, 1194, 1196, 1198, 1200, 1202, 1204, 1205,
-  1206, 1212, 1214, 1215, 1217, 1219, 1221, 1223,
-  1224, 1226, 1228, 1230, 1232, 1234, 1236, 1239,
-  1241, 1244, 1246, 1248, 1249, 1251, 1254, 1256,
-  1258, 1260, 1263, 1267, 1271, 1280, 1286, 1290,
-  1294, 1298, 1302, 1305, 1309, 1310, 1311, 1312,
-  1313, 1317, 1318, 1321, 1324, 1327, 1330, 1331,
-  1333, 1335, 1337, 1339, 1341, 1343, 1345, 1347,
-  1349, 1352, 1355, 1358, 1361, 1364, 1366, 1368,
-  1370, 1372, 1374, 1376, 1378, 1380, 1382, 1384,
-  1386, 1388, 1390, 1392, 1394, 1396, 1398, 1400,
-  1403, 1406, 1412, 1415, 1418, 1421, 1424, 1427,
-  1430, 1433, 1438, 1443, 1445, 1448, 1453, 1456,
-  1459, 1462, 1465, 1468, 1471, 1474, 1477, 1480,
-  1483, 1486, 1489, 1492, 1494, 1497, 1499, 1500,
-  1503, 1505, 1507, 1509, 1512, 1514, 1515, 1517,
-  1520, 1522, 1524, 1526, 1528, 1529, 1530, 1534,
-  1536, 1539, 1542, 1545, 1548, 1551, 1554, 1556,
-  1558, 1560, 1562, 1564, 1566, 1569, 1572, 1574,
-  1576, 1578, 1579, 1580, 1583, 1585, 1586, 1587,
-  1588, 1589, 1590, 1591, 1593, 1595, 1596, 1597,
-  1598, 1599, 1602, 1605, 1608, 1611, 1614, 1617,
-  1620, 1623, 1626, 1630, 1634, 1638, 1641, 1644,
-  1647, 1651, 1655, 1659, 1662, 1664, 1666, 1670,
-  1674, 1676, 1678, 1682, 1684, 1686, 1688, 1691,
-  1695, 1697, 1699, 1705, 1708, 1711, 1713, 1719,
-  1722, 1725, 1728, 1730, 1732, 1735, 1738, 1740,
-  1742, 1745, 1748, 1750, 1752, 1754, 1756, 1758,
-  1761, 1763, 1765, 1767, 1769, 1771, 1774, 1776,
-  1778, 1781, 1783, 1786, 1788, 1790, 1794, 1798,
-  1800, 1802, 1806, 1807, 1808, 1809, 1810, 1811,
-  1812, 1813, 1814, 1816, 1818, 1820, 1822, 1824,
-  1826, 1828, 1830, 1832, 1834, 1836, 1838, 1840,
-  1842, 1844, 1846, 1848, 1850, 1851, 1852, 1854,
-  1856, 1858, 1860, 1861, 1862, 1863, 1864, 1866,
-  1869, 1871, 1873, 1875, 1877, 1879, 1881, 1883,
-  1885, 1887, 1889, 1891, 1893, 1895, 1897, 1899,
-  1901, 1903, 1905, 1907, 1909, 1911, 1913, 1915,
-  1917, 1919, 1921, 1923, 1925, 1927, 1929, 1931,
-  1933, 1935, 1937, 1939, 1941, 1943, 1945, 1947,
-  1949, 1951, 1953, 1955, 1957, 1959, 1961, 1963,
-  1965, 1967, 1969, 1971, 1973, 1975, 1977, 1979,
-  1981, 1983, 1985, 1987, 1989, 1991, 1993, 1995,
-  1997, 1999, 2001, 2003, 2005, 2007, 2009, 2011,
-  2013, 2015, 2017, 2019, 2021, 2023, 2025, 2027,
-  2029, 2031, 2033, 2035, 2037, 2039, 2041, 2043,
-  2045, 2047, 2049, 2051, 2053, 2055, 2057, 2059,
-  2061, 2063, 2065, 2067, 2069, 2071, 2073, 2075,
-  2077, 2079, 2081, 2083, 2085, 2087, 2089, 2091,
-  2093, 2095, 2097, 2099, 2101, 2103, 2105, 2107,
-  2109, 2111, 2113, 2115, 2117, 2119, 2121, 2123,
-  2125, 2127, 2129, 2131, 2133, 2135, 2137, 2139,
-  2141, 2143, 2145, 2147, 2149, 2151, 2153, 2155,
-  2157, 2159, 2161, 2163, 2165, 2167, 2169, 2171,
-  2173, 2175, 2177, 2179, 2181, 2183, 2185, 2187,
-  2189, 2191, 2193, 2195, 2197, 2199, 2201, 2203,
-  2205, 2207, 2209, 2211, 2213, 2215, 2217, 2219,
-  2221, 2223, 2225, 2227, 2229, 2231, 2233, 2235,
-  2237, 2239, 2241, 2243, 2245, 2247, 2249, 2251,
-  2256, 2258, 2263, 2265, 2267, 2272, 2274, 2276,
-  2278, 2283, 2285, 2287, 2289, 2293, 2299, 2301,
-  2306, 2308, 2310, 2312, 2314, 2316, 2318, 2320,
-  2322, 2324, 2325, 2326, 2328, 2330, 2331, 2332,
-  2333, 2334, 2336, 2338, 2339, 2340, 2341, 2343,
-  2345, 2347, 2349, 2351, 2353, 2355, 2357, 2359,
-  2361, 2363, 2365, 2367, 2371, 2372, 2373, 2375,
-  2379, 2383, 2385, 2389, 2393, 2394, 2395, 2397,
-  2399, 2401, 2403, 2408, 2412, 2416, 2418, 2420,
-  2422, 2424, 2425, 2427, 2429, 2431, 2433, 2435,
-  2437, 2439, 2441, 2443, 2445, 2447, 2449, 2451,
-  2453, 2455, 2457, 2459, 2461, 2463, 2465, 2467,
-  2469, 2470, 2471, 2473, 2475, 2476, 2477, 2480,
-  2483, 2486, 2489, 2491, 2493, 2495, 2497, 2499,
-  2501, 2502, 2503, 2504, 2506, 2510, 2512, 2514,
-  2520, 2524, 2525, 2526, 2527, 2528, 2529, 2530,
-  2531, 2535, 2537, 2539, 2543, 2545, 2547, 2549,
-  2551, 2553, 2555, 2557, 2559, 2561, 2563, 2565,
-  2567, 2569, 2571, 2572, 2575, 2578, 2583, 2588,
-  2591, 2594, 2597, 2600, 2605, 2610, 2613, 2616,
-  2618, 2620, 2622, 2624, 2626, 2628, 2630, 2631,
-  2633, 2635, 2637, 2639, 2641, 2642, 2643, 2644,
-  2648, 2652, 2654, 2658, 2662, 2666, 2670, 2674,
-  2676, 2680, 2682, 2684, 2686, 2688, 2690, 2692,
-  2694, 2696, 2697, 2699, 2701, 2703, 2705, 2707,
-  2709, 2711, 2713, 2714, 2715, 2716, 2718, 2720,
-  2722, 2724, 2725, 2726, 2728, 2730, 2732, 2734,
-  2736, 2738, 2739, 2741, 2743, 2745, 2747, 2748,
-  2749, 2751, 2753, 2755, 2757, 2759, 2761, 2763,
-  2765, 2766, 2767, 2769, 2770, 2773, 2776, 2778,
-  2781, 2782, 2783, 2785, 2786, 2788, 2790, 2792,
-  2794, 2796, 2797, 2798, 2799, 2800, 2801, 2804,
-  2809, 2814, 2819, 2824, 2827, 2832, 2837, 2839,
-  2841, 2843, 2845, 2846, 2847, 2849, 2851, 2853,
-  2855, 2857, 2859, 2861, 2862, 2863, 2864, 2865,
-  2866, 2867, 2872, 2877, 2878, 2879, 2880, 2881,
-  2882, 2883, 2884, 2885, 2886, 2887, 2888, 2889,
-  2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897,
-  2898, 2899, 2900, 2901, 2902, 2903, 2904, 2905,
-  2906, 2907, 2908, 2909, 2910, 2911, 2912, 2913,
-  2914, 2915, 2916, 2917, 2918, 2919, 2920, 2921,
-  2922, 2923, 2924, 2925, 2926, 2927, 2928, 2929,
-  2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937,
-  2938, 2939, 2940, 2941, 2942, 2943, 2944, 2945,
-  2946, 2947, 2948, 2949, 2950, 2951, 2952, 2953,
-  2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961,
-  2962, 2963, 2964, 2965, 2966, 2967, 2968, 2969,
-  2970, 2971, 2972, 2973, 2974, 2975, 2976, 2977,
-  2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985,
-  2986, 2987, 2988, 2989, 2990, 2991, 2992, 2993,
-  2994, 2995, 2996, 2997, 2998, 2999, 3000, 3001,
-  3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009,
-  3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017,
-  3018, 3019, 3020, 3021, 3022, 3023, 3024, 3025,
-  3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033,
-  3034, 3035, 3036, 3037, 3038, 3039, 3040, 3041,
-  3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049,
-  3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057,
-  3058, 3059, 3060, 3061, 3062, 3063, 3064, 3065,
-  3066, 3067, 3068, 3069, 3070, 3071, 3072, 3073,
-  3074, 3075, 3076, 3077, 3078, 3080, 3082, 3083,
-  3084, 3085, 3086, 3087, 3088, 3089, 3090, 3091,
-  3092, 3093, 3094, 3095, 3096, 3097, 3098, 3099,
-  3100, 3101, 3102, 3103, 3104, 3105, 3106, 3107,
-  3108, 3109, 3110, 3112, 3114, 3116, 3118, 3119,
-  3120, 3121, 3122, 3123, 3124, 3125, 3126, 3127,
-  3128, 3129, 3130, 3131, 3133, 3134, 3135, 3136,
-  3138, 3139, 3140, 3141, 3142, 3143, 3144, 3145,
-  3146, 3147, 3148, 3149, 3150, 3151, 3152, 3153,
-  3154, 3155, 3156, 3157, 3158, 3159, 3160, 3161,
-  3162, 3163, 3164, 3165, 3166, 3167, 3168, 3169,
-  3170, 3171, 3172, 3173, 3174, 3175, 3176, 3177,
-  3178, 3179, 3181, 3183, 3184, 3185, 3187, 3188,
-  3190, 3192, 3193, 3194, 3196, 3198, 3200, 3202,
-  3203, 3204, 3205, 3206, 3207, 3208, 3209, 3210,
-  3211, 3212, 3213, 3214, 3215, 3216, 3217, 3218,
-  3221, 3224, 3225, 3226, 3227, 3228, 3229, 3230,
-  3232, 3234, 3236, 3237, 3238, 3239, 3240, 3241,
-  3242, 3244, 3245, 3246, 3247, 3248, 3249, 3250,
-  3251, 3252, 3253, 3254, 3255, 3256, 3257, 3258,
-  3259, 3260, 3261, 3262, 3263, 3264, 3267, 3270,
-  3271, 3272, 3273, 3274, 3275, 3276, 3277, 3278,
-  3279, 3280, 3281, 3282, 3283, 3284, 3285, 3286,
-  3287, 3288, 3289, 3290, 3291, 3292, 3293, 3294,
-  3295, 3296, 3297, 3298, 3299, 3300, 3301, 3302,
-  3303, 3304, 3305, 3306, 3307, 3308, 3309, 3310,
+   164,  167,  170,  173,  176,  179,  182,  185,
+   188,  191,  194,  197,  200,  203,  206,  209,
+   212,  215,  218,  221,  224,  227,  230,  233,
+   236,  239,  242,  245,  248,  253,  256,  259,
+   262,  265,  268,  271,  274,  277,  280,  283,
+   286,  289,  292,  295,  298,  301,  304,  307,
+   310,  313,  316,  319,  322,  325,  328,  331,
+   334,  337,  341,  345,  348,  351,  352,  353,
+   354,  355,  357,  359,  360,  361,  362,  363,
+   364,  365,  366,  367,  368,  369,  370,  371,
+   373,  386,  390,  394,  398,  408,  418,  428,
+   438,  448,  458,  468,  478,  485,  492,  501,
+   504,  512,  515,  521,  523,  525,  527,  529,
+   530,  531,  532,  533,  534,  535,  536,  537,
+   538,  539,  540,  541,  542,  543,  544,  545,
+   546,  547,  548,  549,  550,  551,  552,  553,
+   554,  555,  556,  557,  558,  559,  560,  561,
+   562,  564,  566,  568,  570,  572,  575,  578,
+   581,  584,  587,  590,  593,  596,  599,  602,
+   605,  608,  611,  614,  617,  620,  623,  626,
+   629,  632,  635,  638,  641,  644,  647,  650,
+   653,  656,  659,  662,  663,  664,  665,  666,
+   667,  668,  669,  670,  671,  672,  673,  674,
+   675,  676,  677,  678,  679,  680,  681,  682,
+   683,  684,  685,  686,  687,  688,  689,  690,
+   691,  692,  694,  696,  698,  700,  703,  706,
+   708,  710,  713,  716,  719,  722,  724,  725,
+   726,  728,  730,  732,  734,  735,  736,  737,
+   738,  739,  740,  741,  742,  744,  746,  748,
+   750,  752,  754,  755,  757,  759,  761,  763,
+   765,  767,  769,  771,  773,  777,  779,  780,
+   781,  782,  785,  786,  790,  792,  793,  794,
+   795,  797,  801,  802,  806,  807,  808,  810,
+   812,  813,  814,  815,  816,  817,  818,  819,
+   820,  821,  822,  826,  827,  830,  834,  835,
+   841,  845,  846,  852,  856,  857,  860,  864,
+   865,  871,  875,  876,  882,  883,  884,  885,
+   886,  887,  888,  889,  890,  891,  892,  893,
+   894,  895,  896,  897,  898,  899,  900,  901,
+   902,  903,  904,  905,  908,  911,  912,  913,
+   914,  915,  916,  917,  918,  919,  920,  921,
+   922,  923,  924,  925,  926,  927,  928,  929,
+   930,  931,  932,  933,  934,  935,  936,  937,
+   938,  939,  940,  941,  942,  943,  944,  945,
+   946,  947,  948,  949,  950,  951,  952,  953,
+   954,  955,  956,  957,  958,  959,  960,  961,
+   962,  963,  964,  965,  966,  967,  968,  969,
+   970,  971,  972,  973,  974,  975,  976,  977,
+   978,  979,  980,  981,  982,  983,  984,  985,
+   986,  987,  988,  989,  990,  991,  992,  993,
+   994,  995,  996,  997,  998,  999, 1000, 1001,
+  1002, 1003, 1004, 1005, 1006, 1007, 1009, 1011,
+  1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019,
+  1020, 1021, 1023, 1025, 1027, 1029, 1031, 1033,
+  1035, 1037, 1039, 1041, 1043, 1045, 1047, 1049,
+  1051, 1053, 1055, 1057, 1059, 1061, 1063, 1065,
+  1067, 1069, 1071, 1073, 1075, 1077, 1079, 1081,
+  1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089,
+  1090, 1091, 1092, 1093, 1096, 1099, 1102, 1105,
+  1108, 1111, 1112, 1113, 1114, 1115, 1116, 1117,
+  1123, 1133, 1137, 1141, 1145, 1149, 1153, 1156,
+  1160, 1164, 1168, 1172, 1176, 1179, 1182, 1185,
+  1188, 1191, 1194, 1197, 1200, 1204, 1208, 1212,
+  1215, 1223, 1229, 1237, 1245, 1251, 1259, 1265,
+  1273, 1277, 1281, 1284, 1288, 1292, 1296, 1300,
+  1304, 1308, 1312, 1315, 1319, 1323, 1326, 1329,
+  1331, 1333, 1336, 1339, 1341, 1343, 1345, 1347,
+  1349, 1351, 1353, 1355, 1357, 1359, 1361, 1363,
+  1365, 1367, 1369, 1371, 1373, 1375, 1377, 1378,
+  1379, 1385, 1387, 1388, 1390, 1392, 1394, 1396,
+  1397, 1399, 1401, 1403, 1405, 1407, 1409, 1412,
+  1414, 1417, 1419, 1421, 1422, 1424, 1427, 1429,
+  1431, 1433, 1436, 1440, 1444, 1453, 1459, 1463,
+  1467, 1471, 1475, 1478, 1482, 1483, 1484, 1485,
+  1486, 1490, 1491, 1494, 1497, 1500, 1503, 1504,
+  1506, 1508, 1510, 1512, 1514, 1516, 1518, 1520,
+  1522, 1525, 1528, 1531, 1534, 1537, 1539, 1541,
+  1543, 1545, 1547, 1549, 1551, 1553, 1555, 1557,
+  1559, 1561, 1563, 1565, 1567, 1569, 1571, 1573,
+  1576, 1579, 1585, 1588, 1591, 1594, 1597, 1600,
+  1603, 1606, 1611, 1616, 1618, 1621, 1626, 1629,
+  1632, 1635, 1638, 1641, 1644, 1647, 1650, 1653,
+  1656, 1659, 1662, 1665, 1667, 1670, 1672, 1673,
+  1676, 1678, 1680, 1682, 1685, 1687, 1688, 1690,
+  1693, 1695, 1697, 1699, 1701, 1702, 1703, 1707,
+  1709, 1712, 1715, 1718, 1721, 1724, 1727, 1729,
+  1731, 1733, 1735, 1737, 1739, 1742, 1745, 1747,
+  1749, 1751, 1752, 1753, 1756, 1758, 1759, 1760,
+  1761, 1762, 1763, 1764, 1766, 1768, 1769, 1770,
+  1771, 1772, 1775, 1778, 1781, 1784, 1787, 1790,
+  1793, 1796, 1799, 1803, 1807, 1811, 1814, 1817,
+  1820, 1824, 1828, 1832, 1835, 1837, 1839, 1843,
+  1847, 1849, 1851, 1855, 1857, 1859, 1861, 1864,
+  1868, 1870, 1872, 1878, 1881, 1884, 1886, 1892,
+  1895, 1898, 1901, 1903, 1905, 1908, 1911, 1913,
+  1915, 1918, 1921, 1923, 1925, 1927, 1929, 1931,
+  1934, 1936, 1938, 1940, 1942, 1944, 1947, 1949,
+  1951, 1954, 1956, 1959, 1961, 1963, 1967, 1971,
+  1973, 1975, 1979, 1980, 1981, 1982, 1983, 1984,
+  1985, 1986, 1987, 1989, 1991, 1993, 1995, 1997,
+  1999, 2001, 2003, 2005, 2007, 2009, 2011, 2013,
+  2015, 2017, 2019, 2021, 2023, 2024, 2025, 2027,
+  2029, 2031, 2033, 2034, 2035, 2036, 2037, 2039,
+  2042, 2044, 2046, 2048, 2050, 2052, 2054, 2056,
+  2058, 2060, 2062, 2064, 2066, 2068, 2070, 2072,
+  2074, 2076, 2078, 2080, 2082, 2084, 2086, 2088,
+  2090, 2092, 2094, 2096, 2098, 2100, 2102, 2104,
+  2106, 2108, 2110, 2112, 2114, 2116, 2118, 2120,
+  2122, 2124, 2126, 2128, 2130, 2132, 2134, 2136,
+  2138, 2140, 2142, 2144, 2146, 2148, 2150, 2152,
+  2154, 2156, 2158, 2160, 2162, 2164, 2166, 2168,
+  2170, 2172, 2174, 2176, 2178, 2180, 2182, 2184,
+  2186, 2188, 2190, 2192, 2194, 2196, 2198, 2200,
+  2202, 2204, 2206, 2208, 2210, 2212, 2214, 2216,
+  2218, 2220, 2222, 2224, 2226, 2228, 2230, 2232,
+  2234, 2236, 2238, 2240, 2242, 2244, 2246, 2248,
+  2250, 2252, 2254, 2256, 2258, 2260, 2262, 2264,
+  2266, 2268, 2270, 2272, 2274, 2276, 2278, 2280,
+  2282, 2284, 2286, 2288, 2290, 2292, 2294, 2296,
+  2298, 2300, 2302, 2304, 2306, 2308, 2310, 2312,
+  2314, 2316, 2318, 2320, 2322, 2324, 2326, 2328,
+  2330, 2332, 2334, 2336, 2338, 2340, 2342, 2344,
+  2346, 2348, 2350, 2352, 2354, 2356, 2358, 2360,
+  2362, 2364, 2366, 2368, 2370, 2372, 2374, 2376,
+  2378, 2380, 2382, 2384, 2386, 2388, 2390, 2392,
+  2394, 2396, 2398, 2400, 2402, 2404, 2406, 2408,
+  2410, 2412, 2414, 2416, 2418, 2420, 2422, 2424,
+  2429, 2431, 2436, 2438, 2440, 2445, 2447, 2449,
+  2451, 2456, 2458, 2460, 2462, 2466, 2472, 2474,
+  2479, 2481, 2483, 2485, 2487, 2489, 2491, 2493,
+  2495, 2497, 2498, 2499, 2501, 2503, 2504, 2505,
+  2506, 2507, 2509, 2511, 2512, 2513, 2514, 2516,
+  2518, 2520, 2522, 2524, 2526, 2528, 2530, 2532,
+  2534, 2536, 2538, 2540, 2544, 2545, 2546, 2548,
+  2552, 2556, 2558, 2562, 2566, 2567, 2568, 2570,
+  2572, 2574, 2576, 2581, 2585, 2589, 2591, 2593,
+  2595, 2597, 2598, 2600, 2602, 2604, 2606, 2608,
+  2610, 2612, 2614, 2616, 2618, 2620, 2622, 2624,
+  2626, 2628, 2630, 2632, 2634, 2636, 2638, 2640,
+  2642, 2643, 2644, 2646, 2648, 2649, 2650, 2653,
+  2656, 2659, 2662, 2664, 2666, 2668, 2670, 2672,
+  2674, 2675, 2676, 2677, 2679, 2683, 2685, 2687,
+  2693, 2697, 2698, 2699, 2700, 2701, 2702, 2703,
+  2704, 2708, 2710, 2712, 2716, 2718, 2720, 2722,
+  2724, 2726, 2728, 2730, 2732, 2734, 2736, 2738,
+  2740, 2742, 2744, 2745, 2748, 2751, 2756, 2761,
+  2764, 2767, 2770, 2773, 2778, 2783, 2786, 2789,
+  2791, 2793, 2795, 2797, 2799, 2801, 2803, 2804,
+  2806, 2808, 2810, 2812, 2814, 2815, 2816, 2817,
+  2821, 2825, 2827, 2831, 2835, 2839, 2843, 2847,
+  2849, 2853, 2855, 2857, 2859, 2861, 2863, 2865,
+  2867, 2869, 2870, 2872, 2874, 2876, 2878, 2880,
+  2882, 2884, 2886, 2887, 2888, 2889, 2891, 2893,
+  2895, 2897, 2898, 2899, 2901, 2903, 2905, 2907,
+  2909, 2911, 2912, 2914, 2916, 2918, 2920, 2921,
+  2922, 2924, 2926, 2928, 2930, 2932, 2934, 2936,
+  2938, 2939, 2940, 2942, 2943, 2946, 2949, 2951,
+  2954, 2955, 2956, 2958, 2959, 2961, 2963, 2965,
+  2967, 2969, 2970, 2971, 2972, 2973, 2974, 2977,
+  2982, 2987, 2992, 2997, 3000, 3005, 3010, 3012,
+  3014, 3016, 3018, 3019, 3020, 3022, 3024, 3026,
+  3028, 3030, 3032, 3034, 3035, 3036, 3037, 3038,
+  3039, 3040, 3045, 3050, 3051, 3052, 3053, 3054,
+  3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062,
+  3063, 3064, 3065, 3066, 3067, 3068, 3069, 3070,
+  3071, 3072, 3073, 3074, 3075, 3076, 3077, 3078,
+  3079, 3080, 3081, 3082, 3083, 3084, 3085, 3086,
+  3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094,
+  3095, 3096, 3097, 3098, 3099, 3100, 3101, 3102,
+  3103, 3104, 3105, 3106, 3107, 3108, 3109, 3110,
+  3111, 3112, 3113, 3114, 3115, 3116, 3117, 3118,
+  3119, 3120, 3121, 3122, 3123, 3124, 3125, 3126,
+  3127, 3128, 3129, 3130, 3131, 3132, 3133, 3134,
+  3135, 3136, 3137, 3138, 3139, 3140, 3141, 3142,
+  3143, 3144, 3145, 3146, 3147, 3148, 3149, 3150,
+  3151, 3152, 3153, 3154, 3155, 3156, 3157, 3158,
+  3159, 3160, 3161, 3162, 3163, 3164, 3165, 3166,
+  3167, 3168, 3169, 3170, 3171, 3172, 3173, 3174,
+  3175, 3176, 3177, 3178, 3179, 3180, 3181, 3182,
+  3183, 3184, 3185, 3186, 3187, 3188, 3189, 3190,
+  3191, 3192, 3193, 3194, 3195, 3196, 3197, 3198,
+  3199, 3200, 3201, 3202, 3203, 3204, 3205, 3206,
+  3207, 3208, 3209, 3210, 3211, 3212, 3213, 3214,
+  3215, 3216, 3217, 3218, 3219, 3220, 3221, 3222,
+  3223, 3224, 3225, 3226, 3227, 3228, 3229, 3230,
+  3231, 3232, 3233, 3234, 3235, 3236, 3237, 3238,
+  3239, 3240, 3241, 3242, 3243, 3244, 3245, 3246,
+  3247, 3248, 3249, 3250, 3251, 3253, 3255, 3256,
+  3257, 3258, 3259, 3260, 3261, 3262, 3263, 3264,
+  3265, 3266, 3267, 3268, 3269, 3270, 3271, 3272,
+  3273, 3274, 3275, 3276, 3277, 3278, 3279, 3280,
+  3281, 3282, 3283, 3285, 3287, 3289, 3291, 3292,
+  3293, 3294, 3295, 3296, 3297, 3298, 3299, 3300,
+  3301, 3302, 3303, 3304, 3306, 3307, 3308, 3309,
   3311, 3312, 3313, 3314, 3315, 3316, 3317, 3318,
-  3319, 3320, 3321, 3322, 3323, 3324, 3327, 3329,
-  3332, 3335, 3337, 3340, 3343, 3346, 3349, 3350,
-  3353, 3354, 3355, 3356, 3357, 3358, 3362, 3364,
-  3367, 3368, 3369, 3370, 3371, 3372, 3373, 3374,
-  3375, 3376, 3377, 3378, 3379, 3380, 3381, 3382,
-  3383, 3384, 3385, 3386, 3387, 3388, 3389, 3390,
-  3391, 3392, 3393, 3394, 3395, 3396, 3397, 3398,
-  3399, 3400, 3401, 3402, 3403, 3404, 3405, 3406,
-  3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414,
-  3415, 3416, 3417, 3418, 3419, 3420, 3421, 3422,
+  3319, 3320, 3321, 3322, 3323, 3324, 3325, 3326,
+  3327, 3328, 3329, 3330, 3331, 3332, 3333, 3334,
+  3335, 3336, 3337, 3338, 3339, 3340, 3341, 3342,
+  3343, 3344, 3345, 3346, 3347, 3348, 3349, 3350,
+  3351, 3352, 3354, 3356, 3357, 3358, 3360, 3361,
+  3363, 3365, 3366, 3367, 3369, 3371, 3373, 3375,
+  3376, 3377, 3378, 3379, 3380, 3381, 3382, 3383,
+  3384, 3385, 3386, 3387, 3388, 3389, 3390, 3391,
+  3394, 3397, 3398, 3399, 3400, 3401, 3402, 3403,
+  3405, 3407, 3409, 3410, 3411, 3412, 3413, 3414,
+  3415, 3417, 3418, 3419, 3420, 3421, 3422, 3423,
   3424, 3425, 3426, 3427, 3428, 3429, 3430, 3431,
-  3432, 3433, 3434, 3435, 3436, 3437, 3438, 3439,
-  3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447,
-  3448, 3449, 3450, 3451, 3452, 3453, 3454, 3455,
-  3456, 3457, 3458, 3459, 3460, 3461, 3462, 3463,
-  3466, 3469, 3472, 3475, 3478, 3481, 3484, 3487,
-  3490, 3493, 3496, 3499, 3502, 3505, 3508, 3509,
-  3510, 3511, 3512, 3514, 3515, 3516, 3517, 3518,
-  3519, 3520, 3521, 3522, 3523, 3524, 3525, 3526,
-  3527, 3528, 3529, 3530, 3531, 3532, 3533, 3534,
-  3535, 3536, 3537, 3538, 3539, 3540, 3541, 3542,
-  3543, 3544, 3545, 3546, 3547, 3548, 3549, 3550,
-  3551, 3552, 3553, 3554, 3555, 3556, 3557, 3558,
-  3559, 3560, 3561, 3562, 3563, 3564, 3565, 3566,
-  3567, 3568, 3569, 3570, 3571, 3572, 3573, 3574,
-  3575, 3578, 3581, 3582, 3583, 3584, 3585, 3586,
-  3587, 3588, 3589, 3590, 3591, 3592, 3593, 3594,
-  3595, 3596, 3597, 3598, 3599, 3600, 3601, 3602,
-  3603, 3604, 3605, 3606, 3607, 3608, 3609, 3610,
-  3611, 3612, 3613, 3614, 3615, 3616, 3617, 3618,
-  3619, 3620, 3621, 3622, 3623, 3624, 3625, 3626,
-  3627, 3628, 3629, 3630, 3631, 3632, 3633, 3634,
-  3635, 3636, 3637, 3638, 3639, 3640, 3641, 3642,
-  3643, 3646, 3649, 3652, 3653, 3654, 3655, 3656,
-  3657, 3658, 3659, 3660, 3661, 3662, 3663, 3664,
-  3665, 3666, 3667, 3668, 3671, 3674, 3675, 3676,
-  3679, 3680, 3681, 3682, 3683, 3686, 3689, 3692,
-  3693, 3694, 3695, 3696, 3697, 3698, 3699, 3700,
-  3701, 3702, 3704, 3706, 3707, 3708, 3709, 3710,
-  3711, 3712, 3713, 3714, 3715, 3716, 3717, 3718,
-  3719, 3720, 3721, 3722, 3723, 3724, 3725, 3726,
-  3727, 3728, 3729, 3730, 3731, 3733, 3735, 3736,
-  3737, 3738, 3739, 3740, 3741, 3742, 3743, 3744,
-  3745, 3746, 3747, 3748, 3749, 3750, 3751, 3752,
-  3753, 3754, 3755, 3756, 3757, 3758, 3759, 3760,
-  3762, 3764, 3766, 3768, 3769, 3770, 3771, 3772,
-  3773, 3774, 3775, 3776, 3777, 3778, 3779, 3780,
-  3781, 3782, 3783, 3785, 3786, 3788, 3791, 3793,
-  3794, 3795, 3797, 3799, 3800, 3801, 3802, 3803,
-  3804, 3805, 3807, 3809, 3811, 3813, 3814, 3815,
-  3816, 3817, 3818, 3819, 3820, 3821, 3822, 3824,
-  3826, 3827, 3829, 3831, 3832, 3837, 3839, 3841,
-  3842, 3843, 3844, 3845, 3846, 3847, 3848, 3850,
-  3852, 3853, 3854, 3855, 3857, 3860, 3863, 3866,
-  3868, 3869, 3870, 3871, 3872, 3873, 3874, 3875,
-  3876, 3877, 3878, 3879, 3880, 3881, 3882, 3883,
+  3432, 3433, 3434, 3435, 3436, 3437, 3440, 3443,
+  3444, 3445, 3446, 3447, 3448, 3449, 3450, 3451,
+  3452, 3453, 3454, 3455, 3456, 3457, 3458, 3459,
+  3460, 3461, 3462, 3463, 3464, 3465, 3466, 3467,
+  3468, 3469, 3470, 3471, 3472, 3473, 3474, 3475,
+  3476, 3477, 3478, 3479, 3480, 3481, 3482, 3483,
+  3484, 3485, 3486, 3487, 3488, 3489, 3490, 3491,
+  3492, 3493, 3494, 3495, 3496, 3497, 3500, 3502,
+  3505, 3508, 3510, 3513, 3516, 3519, 3522, 3523,
+  3526, 3527, 3528, 3529, 3530, 3531, 3535, 3537,
+  3540, 3541, 3542, 3543, 3544, 3545, 3546, 3547,
+  3548, 3549, 3550, 3551, 3552, 3553, 3554, 3555,
+  3556, 3557, 3558, 3559, 3560, 3561, 3562, 3563,
+  3564, 3565, 3566, 3567, 3568, 3569, 3570, 3571,
+  3572, 3573, 3574, 3575, 3576, 3577, 3578, 3579,
+  3580, 3581, 3582, 3583, 3584, 3585, 3586, 3587,
+  3588, 3589, 3590, 3591, 3592, 3593, 3594, 3595,
+  3597, 3598, 3599, 3600, 3601, 3602, 3603, 3604,
+  3605, 3606, 3607, 3608, 3609, 3610, 3611, 3612,
+  3613, 3614, 3615, 3616, 3617, 3618, 3619, 3620,
+  3621, 3622, 3623, 3624, 3625, 3626, 3627, 3628,
+  3629, 3630, 3631, 3632, 3633, 3634, 3635, 3636,
+  3639, 3642, 3645, 3648, 3651, 3654, 3657, 3660,
+  3663, 3666, 3669, 3672, 3675, 3678, 3681, 3682,
+  3683, 3684, 3685, 3687, 3688, 3689, 3690, 3691,
+  3692, 3693, 3694, 3695, 3696, 3697, 3698, 3699,
+  3700, 3701, 3702, 3703, 3704, 3705, 3706, 3707,
+  3708, 3709, 3710, 3711, 3712, 3713, 3714, 3715,
+  3716, 3717, 3718, 3719, 3720, 3721, 3722, 3723,
+  3724, 3725, 3726, 3727, 3728, 3729, 3730, 3731,
+  3732, 3733, 3734, 3735, 3736, 3737, 3738, 3739,
+  3740, 3741, 3742, 3743, 3744, 3745, 3746, 3747,
+  3748, 3751, 3754, 3755, 3756, 3757, 3758, 3759,
+  3760, 3761, 3762, 3763, 3764, 3765, 3766, 3767,
+  3768, 3769, 3770, 3771, 3772, 3773, 3774, 3775,
+  3776, 3777, 3778, 3779, 3780, 3781, 3782, 3783,
+  3784, 3785, 3786, 3787, 3788, 3789, 3790, 3791,
+  3792, 3793, 3794, 3795, 3796, 3797, 3798, 3799,
+  3800, 3801, 3802, 3803, 3804, 3805, 3806, 3807,
+  3808, 3809, 3810, 3811, 3812, 3813, 3814, 3815,
+  3816, 3819, 3822, 3825, 3826, 3827, 3828, 3829,
+  3830, 3831, 3832, 3833, 3834, 3835, 3836, 3837,
+  3838, 3839, 3840, 3841, 3844, 3847, 3848, 3849,
+  3852, 3853, 3854, 3855, 3856, 3859, 3862, 3865,
+  3866, 3867, 3868, 3869, 3870, 3871, 3872, 3873,
+  3874, 3875, 3877, 3879, 3880, 3881, 3882, 3883,
   3884, 3885, 3886, 3887, 3888, 3889, 3890, 3891,
   3892, 3893, 3894, 3895, 3896, 3897, 3898, 3899,
-  3900, 3901, 3902, 3903, 3904, 3905, 3906, 3907,
-  3908, 3909, 3910, 3911, 3912, 3913, 3914, 3915,
-  3916, 3917, 3918, 3919, 3920, 3921, 3922, 3923,
-  3924, 3925, 3926, 3927, 3928, 3929, 3930, 3931,
-  3932, 3933, 3934, 3935, 3936, 3937, 3938, 3939,
-  3940, 3941, 3942, 3943, 3944, 3945, 3946, 3947,
-  3948, 3949, 3950, 3951, 3952, 3953, 3954, 3955,
-  3956, 3957, 3958, 3959, 3960, 3961, 3962, 3963,
-  3964, 3965, 3966, 3967, 3968, 3969, 3970, 3971,
-  3972, 3973, 3974, 3975, 3976, 3977, 3978, 3979,
-  3980, 3981, 3982, 3983, 3984, 3985, 3986, 3987,
-  3988, 3989, 3990, 3991, 3992, 3993, 3994, 3995,
-  3996, 3997, 3998, 3999, 4000, 4001, 4002, 4003,
-  4004, 4005, 4006, 4007, 4008, 4009, 4010, 4013,
-  4014, 4015, 4018, 4019, 4020, 4022, 4023, 4024,
-  4025, 4027, 4028, 4029, 4030, 4032, 4033, 4034,
-  4035, 4038, 4039, 4040, 4041, 4042, 4045, 4048,
-  4051, 4054, 4057, 4058, 4059, 4060, 4061, 4063,
-  4065, 4066, 4067, 4068, 4071, 4074, 4077, 4080,
-  4083, 4084, 4085, 4086, 4088, 4089, 4090, 4091,
-  4093, 4094, 4095, 4096, 4097, 4098, 4099, 4100,
-  4101, 4102, 4103, 4104, 4105, 4106, 4107, 4108,
-  4109, 4110, 4111, 4112, 4113, 4114, 4115, 4116,
-  4117, 4118, 4119, 4120, 4121, 4122, 4123, 4124,
-  4125, 4126, 4127, 4128, 4129, 4130, 4131, 4132,
-  4134, 4136, 4138, 4140, 4142, 4143, 4144, 4147,
-  4150, 4151, 4152, 4153, 4154
+  3900, 3901, 3902, 3903, 3904, 3906, 3908, 3909,
+  3910, 3911, 3912, 3913, 3914, 3915, 3916, 3917,
+  3918, 3919, 3920, 3921, 3922, 3923, 3924, 3925,
+  3926, 3927, 3928, 3929, 3930, 3931, 3932, 3933,
+  3935, 3937, 3939, 3941, 3942, 3943, 3944, 3945,
+  3946, 3947, 3948, 3949, 3950, 3951, 3952, 3953,
+  3954, 3955, 3956, 3958, 3959, 3961, 3964, 3966,
+  3967, 3968, 3970, 3972, 3973, 3974, 3975, 3976,
+  3977, 3978, 3980, 3982, 3984, 3986, 3987, 3988,
+  3989, 3990, 3991, 3992, 3993, 3994, 3995, 3997,
+  3999, 4000, 4002, 4004, 4005, 4010, 4012, 4014,
+  4015, 4016, 4017, 4018, 4019, 4020, 4021, 4023,
+  4025, 4026, 4027, 4028, 4030, 4033, 4036, 4039,
+  4041, 4042, 4043, 4044, 4045, 4046, 4047, 4048,
+  4049, 4050, 4051, 4052, 4053, 4054, 4055, 4056,
+  4057, 4058, 4059, 4060, 4061, 4062, 4063, 4064,
+  4065, 4066, 4067, 4068, 4069, 4070, 4071, 4072,
+  4073, 4074, 4075, 4076, 4077, 4078, 4079, 4080,
+  4081, 4082, 4083, 4084, 4085, 4086, 4087, 4088,
+  4089, 4090, 4091, 4092, 4093, 4094, 4095, 4096,
+  4097, 4098, 4099, 4100, 4101, 4102, 4103, 4104,
+  4105, 4106, 4107, 4108, 4109, 4110, 4111, 4112,
+  4113, 4114, 4115, 4116, 4117, 4118, 4119, 4120,
+  4121, 4122, 4123, 4124, 4125, 4126, 4127, 4128,
+  4129, 4130, 4131, 4132, 4133, 4134, 4135, 4136,
+  4137, 4138, 4139, 4140, 4141, 4142, 4143, 4144,
+  4145, 4146, 4147, 4148, 4149, 4150, 4151, 4152,
+  4153, 4154, 4155, 4156, 4157, 4158, 4159, 4160,
+  4161, 4162, 4163, 4164, 4165, 4166, 4167, 4168,
+  4169, 4170, 4171, 4172, 4173, 4174, 4175, 4176,
+  4177, 4178, 4179, 4180, 4181, 4182, 4183, 4186,
+  4187, 4188, 4191, 4192, 4193, 4195, 4196, 4197,
+  4198, 4200, 4201, 4202, 4203, 4205, 4206, 4207,
+  4208, 4211, 4212, 4213, 4214, 4215, 4218, 4221,
+  4224, 4227, 4230, 4231, 4232, 4233, 4234, 4236,
+  4238, 4239, 4240, 4241, 4244, 4247, 4250, 4253,
+  4256, 4257, 4258, 4259, 4261, 4262, 4263, 4264,
+  4266, 4267, 4268, 4269, 4270, 4271, 4272, 4273,
+  4274, 4275, 4276, 4277, 4278, 4279, 4280, 4281,
+  4282, 4283, 4284, 4285, 4286, 4287, 4288, 4289,
+  4290, 4291, 4292, 4293, 4294, 4295, 4296, 4297,
+  4298, 4299, 4300, 4301, 4302, 4303, 4304, 4305,
+  4307, 4309, 4311, 4313, 4315, 4316, 4317, 4320,
+  4323, 4324, 4325, 4326, 4327
 };
 
 /* i386 mnemonics table.  */
@@ -44208,14 +45945,18 @@ const char i386_mnemonics[] =
   "\0""pusha"
   "\0""ja"
   "\0""jna"
+  "\0""ccmpna"
   "\0""setna"
+  "\0""ctestna"
   "\0""setzuna"
   "\0""fcmovna"
+  "\0""ccmpa"
   "\0""popa"
   "\0""vmovntdqa"
   "\0""vmovdqa"
   "\0""seta"
   "\0""prefetchnta"
+  "\0""ctesta"
   "\0""setzua"
   "\0""fcmova"
   "\0""rex.b"
@@ -44268,9 +46009,12 @@ const char i386_mnemonics[] =
   "\0""kandnb"
   "\0""vpsignb"
   "\0""jnb"
+  "\0""ccmpnb"
   "\0""setnb"
+  "\0""ctestnb"
   "\0""setzunb"
   "\0""fcmovnb"
+  "\0""ccmpb"
   "\0""vpcmpb"
   "\0""vpcomeqb"
   "\0""vgf2p8affineqb"
@@ -44310,6 +46054,7 @@ const char i386_mnemonics[] =
   "\0""knotb"
   "\0""vprotb"
   "\0""vpbroadcastb"
+  "\0""ctestb"
   "\0""ktestb"
   "\0""kortestb"
   "\0""vpcomgeub"
@@ -44370,15 +46115,18 @@ const char i386_mnemonics[] =
   "\0""vaesenc"
   "\0""inc"
   "\0""jnc"
+  "\0""ccmpnc"
   "\0""setnc"
+  "\0""ctestnc"
   "\0""vmfunc"
   "\0""setzunc"
   "\0""cmovnc"
   "\0""tlbsync"
+  "\0""ccmpc"
   "\0""rdtsc"
   "\0""btc"
   "\0""setc"
-  "\0""stc"
+  "\0""ctestc"
   "\0""setzuc"
   "\0""cmovc"
   "\0""vpermi2d"
@@ -44828,18 +46576,26 @@ const char i386_mnemonics[] =
   "\0""fldl2e"
   "\0""jae"
   "\0""jnae"
+  "\0""ccmpnae"
   "\0""setnae"
+  "\0""ctestnae"
   "\0""setzunae"
   "\0""fcmovnae"
+  "\0""ccmpae"
   "\0""setae"
+  "\0""ctestae"
   "\0""setzuae"
   "\0""fcmovae"
   "\0""jbe"
   "\0""jnbe"
+  "\0""ccmpnbe"
   "\0""setnbe"
+  "\0""ctestnbe"
   "\0""setzunbe"
   "\0""fcmovnbe"
+  "\0""ccmpbe"
   "\0""setbe"
+  "\0""ctestbe"
   "\0""setzube"
   "\0""fcmovbe"
   "\0""lfence"
@@ -44849,32 +46605,43 @@ const char i386_mnemonics[] =
   "\0""ffree"
   "\0""jge"
   "\0""jnge"
+  "\0""ccmpnge"
   "\0""setnge"
+  "\0""ctestnge"
   "\0""setzunge"
   "\0""cmovnge"
+  "\0""ccmpge"
   "\0""pfcmpge"
   "\0""setge"
+  "\0""ctestge"
   "\0""setzuge"
   "\0""cmovge"
   "\0""je"
   "\0""fscale"
   "\0""jle"
   "\0""jnle"
+  "\0""ccmpnle"
   "\0""setnle"
+  "\0""ctestnle"
   "\0""setzunle"
   "\0""cmovnle"
+  "\0""ccmple"
   "\0""setle"
+  "\0""ctestle"
   "\0""setzule"
   "\0""cmovle"
   "\0""vmresume"
   "\0""jne"
   "\0""repne"
+  "\0""ccmpne"
   "\0""loopne"
   "\0""setne"
+  "\0""ctestne"
   "\0""setzune"
   "\0""fcmovne"
   "\0""repe"
   "\0""jpe"
+  "\0""ccmpe"
   "\0""loope"
   "\0""setpe"
   "\0""setzupe"
@@ -44895,6 +46662,7 @@ const char i386_mnemonics[] =
   "\0""vmwrite"
   "\0""ptwrite"
   "\0""cldemote"
+  "\0""cteste"
   "\0""sha1nexte"
   "\0""setzue"
   "\0""leave"
@@ -44908,9 +46676,11 @@ const char i386_mnemonics[] =
   "\0""lahf"
   "\0""sahf"
   "\0""pushf"
+  "\0""ccmpf"
   "\0""popf"
   "\0""bsf"
   "\0""retf"
+  "\0""ctestf"
   "\0""neg"
   "\0""ldtilecfg"
   "\0""sttilecfg"
@@ -44918,13 +46688,17 @@ const char i386_mnemonics[] =
   "\0""pconfig"
   "\0""jg"
   "\0""jng"
+  "\0""ccmpng"
   "\0""xstore-rng"
   "\0""xstorerng"
   "\0""setng"
+  "\0""ctestng"
   "\0""setzung"
   "\0""cmovng"
   "\0""invlpg"
+  "\0""ccmpg"
   "\0""setg"
+  "\0""ctestg"
   "\0""setzug"
   "\0""cmovg"
   "\0""vmlaunch"
@@ -45186,16 +46960,20 @@ const char i386_mnemonics[] =
   "\0""fistpll"
   "\0""fisttpll"
   "\0""jnl"
+  "\0""ccmpnl"
   "\0""setnl"
+  "\0""ctestnl"
   "\0""setzunl"
   "\0""cmovnl"
   "\0""rol"
+  "\0""ccmpl"
   "\0""arpl"
   "\0""vpmacsdql"
   "\0""vpmacssdql"
   "\0""lsl"
   "\0""movsl"
   "\0""setl"
+  "\0""ctestl"
   "\0""cwtl"
   "\0""pfmul"
   "\0""fimul"
@@ -45230,10 +47008,13 @@ const char i386_mnemonics[] =
   "\0""vmrun"
   "\0""jo"
   "\0""jno"
+  "\0""ccmpno"
   "\0""setno"
+  "\0""ctestno"
   "\0""setzuno"
   "\0""cmovno"
   "\0""jpo"
+  "\0""ccmpo"
   "\0""setpo"
   "\0""setzupo"
   "\0""cmovpo"
@@ -45243,6 +47024,7 @@ const char i386_mnemonics[] =
   "\0""seto"
   "\0""into"
   "\0""cqto"
+  "\0""ctesto"
   "\0""ssto"
   "\0""setzuo"
   "\0""cmovo"
@@ -45522,8 +47304,10 @@ const char i386_mnemonics[] =
   "\0""femms"
   "\0""lwpins"
   "\0""jns"
+  "\0""ccmpns"
   "\0""wrmsrns"
   "\0""setns"
+  "\0""ctestns"
   "\0""setzuns"
   "\0""cmovns"
   "\0""fcos"
@@ -45619,7 +47403,7 @@ const char i386_mnemonics[] =
   "\0""vunpcklps"
   "\0""vmulps"
   "\0""vmovlps"
-  "\0""cmps"
+  "\0""ccmps"
   "\0""vblendmps"
   "\0""vfixupimmps"
   "\0""vpermps"
@@ -45793,6 +47577,7 @@ const char i386_mnemonics[] =
   "\0""erets"
   "\0""sets"
   "\0""clts"
+  "\0""ctests"
   "\0""outs"
   "\0""setzus"
   "\0""cmovs"
@@ -45830,6 +47615,7 @@ const char i386_mnemonics[] =
   "\0""frndint"
   "\0""not"
   "\0""invept"
+  "\0""ccmpt"
   "\0""xsaveopt"
   "\0""clflushopt"
   "\0""fstpt"
@@ -45848,6 +47634,7 @@ const char i386_mnemonics[] =
   "\0""vmptrst"
   "\0""ftst"
   "\0""rmpadjust"
+  "\0""ctestt"
   "\0""out"
   "\0""pext"
   "\0""bndcu"
@@ -46092,14 +47879,18 @@ const char i386_mnemonics[] =
   "\0""jz"
   "\0""jnz"
   "\0""repnz"
+  "\0""ccmpnz"
   "\0""loopnz"
   "\0""setnz"
+  "\0""ctestnz"
   "\0""setzunz"
   "\0""cmovnz"
   "\0""repz"
+  "\0""ccmpz"
   "\0""loopz"
   "\0""vfpclasspsz"
   "\0""setz"
+  "\0""ctestz"
   "\0""setzuz"
   "\0""cmovz"
   "\0""rex64xz"